@show-karma/karma-gap-sdk 0.1.29

package/core/class/Gelato/Gelato.js

@@ -0,0 +1,263 @@
+// /* eslint-disable no-shadow */
+// /* eslint-disable no-promise-executor-return */
+// /* eslint-disable no-await-in-loop */
+// /* eslint-disable id-length */
+// /* eslint-disable class-methods-use-this */
+// /* eslint-disable no-useless-constructor */
+// /* eslint-disable import/no-extraneous-dependencies */
+// import { GelatoRelay } from "@gelatonetwork/relay-sdk";
+// import { ethers } from "ethers";
+// import axios from "axios";
+// import ABI from "./";
+// import { Hex } from "core/types";
+// enum TaskState {
+//   CheckPending = "CheckPending",
+//   ExecPending = "ExecPending",
+//   ExecSuccess = "ExecSuccess",
+//   ExecReverted = "ExecReverted",
+//   WaitingForConfirmation = "WaitingForConfirmation",
+//   Blacklisted = "Blacklisted",
+//   Cancelled = "Cancelled",
+//   NotFound = "NotFound",
+// }
+// export class DelegateRegistryContract extends GelatoRelay {
+//   contract: ethers.Contract;
+//   constructor(readonly contractAddress: Hex) {
+//     super();
+//     this.contract = new ethers.Contract(contractAddress, ABI);
+//   }
+//   /**
+//    * Returns the r, s, v values of a signature
+//    * @param signature
+//    * @returns
+//    */
+//   private getRSV(signature: string) {
+//     const r = signature.slice(0, 66);
+//     const s = `0x${signature.slice(66, 130)}`;
+//     const v = `0x${signature.slice(130, 132)}`;
+//     return { r, s, v };
+//   }
+//   /**
+//    * Returns the nonce of a delegate
+//    * @param address
+//    * @returns
+//    */
+//   async getNonce(address: Hex) {
+//     const nonce = <bigint>await readFn({
+//       abi: ABI,
+//       address: this.contractAddress,
+//       functionName: "nonces",
+//       args: [address],
+//       chainId: 10,
+//     });
+//     return {
+//       nonce: Number(nonce),
+//       next: Number(nonce + 1n),
+//     };
+//   }
+//   /**
+//    * Waits for a transaction to be mined at Gelato Network
+//    * @param taskId
+//    * @returns
+//    */
+//   wait(taskId: string): Promise<string> {
+//     return new Promise((resolve, reject) => {
+//       const loop = async () => {
+//         const oneSecond = 1;
+//         while (oneSecond) {
+//           const status = await this.getTaskStatus(taskId);
+//           // print status :D so we can debug this for now
+//           // eslint-disable-next-line no-console
+//           console.log(status);
+//           if (!status) {
+//             reject(new Error("Transaction goes wrong."));
+//             break;
+//           }
+//           if (status && status.taskState === TaskState.ExecSuccess) {
+//             resolve(status.transactionHash || "");
+//             break;
+//           } else if (
+//             [
+//               TaskState.Cancelled,
+//               TaskState.ExecReverted,
+//               TaskState.Blacklisted,
+//             ].includes(status?.taskState)
+//           ) {
+//             reject(
+//               new Error(
+//                 status.lastCheckMessage
+//                   ?.split(/(RegisterDelegate)|(Execution error): /)
+//                   .at(-1) || ""
+//               )
+//             );
+//             break;
+//           }
+//           await new Promise((r) => setTimeout(r, 500));
+//         }
+//       };
+//       loop();
+//     });
+//   }
+//   /**
+//    * Executes a transaction on the DelegateRegistry contract
+//    * @param fn the function to call
+//    * @param args the arguments to pass to the function
+//    * @returns the transaction hash and a wait function to wait for the transaction to be mined
+//    */
+//   public async transaction(fn: string, args: unknown[]) {
+//     const { hash } = await writeFn({
+//       abi: ABI,
+//       address: this.contractAddress,
+//       functionName: fn,
+//       args,
+//       chainId: 10,
+//     });
+//     return {
+//       hash,
+//       wait: () => waitForTransaction({ hash }),
+//     };
+//   }
+//   public async registerDelegate(data: DelegateWithProfile) {
+//     return this.transaction("registerDelegate", [
+//       data.tokenAddress,
+//       BigInt(data.tokenChainId),
+//       JSON.stringify(data.profile),
+//     ]);
+//   }
+//   /**
+//    * Creates the payload for register delegate by signature
+//    * returning the payload
+//    * @param data
+//    * @returns
+//    */
+//   public async registerDelegateBySig(
+//     address: Hex,
+//     data: DelegateWithProfile
+//   ): Promise<Parameters<GelatoRelay["sponsoredCall"]>> {
+//     const { nonce } = await this.getNonce(address);
+//     // 2 minutes expiry
+//     const expiry = ((Date.now() + 1000 * 120) / 1000).toFixed(0);
+//     const metadata = JSON.stringify(data.profile);
+//     const types = {
+//       RegisterDelegate: [
+//         { name: "tokenAddress", type: "address" },
+//         { name: "tokenChainId", type: "uint256" },
+//         { name: "metadata", type: "string" },
+//         { name: "nonce", type: "uint256" },
+//         { name: "expiry", type: "uint256" },
+//       ],
+//     } as const;
+//     const signature = await signTypedData({
+//       message: {
+//         tokenAddress: data.tokenAddress,
+//         tokenChainId: BigInt(data.tokenChainId),
+//         metadata,
+//         nonce,
+//         expiry,
+//       },
+//       domain: {
+//         name: "delegate-registry",
+//         version: "1.0",
+//         chainId: data.tokenChainId,
+//         verifyingContract: this.contractAddress,
+//       },
+//       primaryType: "RegisterDelegate",
+//       types,
+//     });
+//     const { r, s, v } = this.getRSV(signature);
+//     const { data: payload } =
+//       await this.contract.populateTransaction.registerDelegateBySig(
+//         address,
+//         data.tokenAddress,
+//         BigInt(data.tokenChainId),
+//         metadata,
+//         nonce,
+//         expiry,
+//         v,
+//         r,
+//         s
+//       );
+//     // eslint-disable-next-line no-console
+//     console.log({ payload, signature, r, s, v });
+//     if (!payload) throw new Error("Payload is undefined");
+//     return [
+//       {
+//         data: payload,
+//         chainId: 10,
+//         target: this.contractAddress,
+//       },
+//       "{apiKey}", // filled in the api
+//       {
+//         retries: 3,
+//       },
+//     ];
+//   }
+//   /**
+//    * Sends a sponsored call to the DelegateRegistry contract using GelatoRelay
+//    * @param payload
+//    * @returns
+//    */
+//   static async sendGelato(...params: Parameters<GelatoRelay["sponsoredCall"]>) {
+//     const client = new this(params[0].target as Hex);
+//     const relayResponse = await client.sponsoredCall(...params);
+//     return {
+//       taskId: relayResponse.taskId,
+//       wait: () => client.wait(relayResponse.taskId),
+//     };
+//   }
+//   /**
+//    * Deregisters a delegate on the DelegateRegistry contract
+//    * @param tokenAddress
+//    * @param tokenChainId
+//    * @returns
+//    */
+//   public deregisterDelegate(tokenAddress: string, tokenChainId: number) {
+//     return this.transaction("deregisterDelegate", [tokenAddress, tokenChainId]);
+//   }
+//   /**
+//    * Returns a delegate from the DelegateRegistry contract
+//    * @param delegateAddress
+//    * @param tokenAddress
+//    * @param tokenChainId
+//    * @returns
+//    */
+//   static async getDelegate(
+//     addresses: string[],
+//     tokenAddress: string,
+//     tokenChainId: number
+//   ): Promise<DelegateRegistryWithInterests[]> {
+//     const query = `
+//       {
+//         delegates(where: { delegateAddress_in: ["${addresses.join(
+//           '","'
+//         )}"], tokenAddress: "${tokenAddress}", tokenChainId: ${tokenChainId} }) {
+//           id
+//           delegateAddress
+//           tokenAddress
+//           tokenChainId
+//           statement
+//           status
+//           blockTimestamp
+//           name
+//           ipfsMetadata
+//           acceptedCoC
+//           interests
+//         }
+//       }`;
+//     const {
+//       data: {
+//         data: { delegates },
+//       },
+//     } = await axios.post<{ data: DelegateStatementRes }>(this.subgraphUrl, {
+//       query,
+//     });
+//     return delegates.map((item) => {
+//       if (Array.isArray(item?.interests))
+//         return item as DelegateRegistryWithInterests;
+//       return <DelegateRegistryWithInterests>{
+//         ...item,
+//         interests: item.interests?.split(",") || [],
+//       };
+//     });
+//   }
+// }

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/Fetcher.d.ts

@@ -0,0 +1,132 @@
+import { Hex, IAttestation, TSchemaName } from "core/types";
+import { Attestation } from "../Attestation";
+import { Community, Grant, MemberOf, Milestone, Project } from "../entities";
+import { Grantee } from "../types/attestations";
+import { AxiosGQL } from "./AxiosGQL";
+export declare abstract class Fetcher extends AxiosGQL {
+    /**
+     * Fetch a single attestation by its UID.
+     * @param uid
+     */
+    abstract attestation<T = unknown>(uid: Hex): Promise<Attestation<T>>;
+    /**
+     * Fetch attestations of a schema.
+     * @param schemaName
+     * @param search if set, will search decodedDataJson by the value.
+     * @returns
+     */
+    abstract attestations(schemaName: TSchemaName, search?: string): Promise<IAttestation[]>;
+    /**
+     * Fetch attestations of a schema.
+     * @param schemaName
+     * @param recipient
+     * @returns
+     */
+    abstract attestationsOf(schemaName: TSchemaName, recipient: Hex): Promise<IAttestation[]>;
+    /**
+     * Fetch attestations of a schema for a specific recipient.
+     * @param schemaName
+     * @param recipient
+     * @returns
+     */
+    abstract attestationsTo(schemaName: TSchemaName, recipient: Hex): Promise<IAttestation[]>;
+    /**
+     * Fetch all available communities with details and grantees uids.
+     *
+     * If search is defined, will try to find communities by the search string.
+     * @param search
+     * @returns
+     */
+    abstract communities(search?: string): Promise<Community[]>;
+    /**
+     * Fetch a set of communities by their ids.
+     * @param uids
+     * @returns
+     */
+    abstract communitiesByIds(uids: Hex[]): Promise<Community[]>;
+    /**
+     * Fetch a community by its name with details, grants and milestones.
+     *
+     * It is possible that the resulted community is not the one you are looking for.
+     * @param name
+     * @returns
+     */
+    abstract communityBySlug(slug: string): Promise<Community>;
+    /**
+     * Fetch a community by its id. This method will also return the
+     * community details and projects.
+     */
+    abstract communityById(uid: Hex): Promise<Community>;
+    /**
+     * Fetch a project by its id.
+     * @param uid
+     * @returns
+     */
+    abstract projectById(uid: Hex): Promise<Project>;
+    /**
+     * Fetch a project by its slug.
+     * @param slug
+     * @returns
+     */
+    abstract projectBySlug(slug: string): Promise<Project>;
+    /**
+     * Fetch projects with details and members.
+     * @param name if set, will search by the name.
+     * @returns
+     */
+    abstract projects(name?: string): Promise<Project[]>;
+    /**
+     * Fetch projects with details and members.
+     * @param grantee the public address of the grantee
+     * @returns
+     */
+    abstract projectsOf(grantee: Hex): Promise<Project[]>;
+    /**
+     * Fetch Grantee with details and projects.
+     * @param address
+     * @param withProjects if true, will get grantee project details.
+     * @returns
+     */
+    abstract grantee(address: Hex): Promise<Grantee>;
+    /**
+     * Fetch all Grantees with details.
+     * @returns
+     */
+    abstract grantees(): Promise<Grantee[]>;
+    /**
+     * Fetches the grantes related to a grantee address (recipient).
+     * @param grantee grantee address
+     * @returns
+     */
+    abstract grantsOf(grantee: Hex, withCommunity?: boolean): Promise<Grant[]>;
+    /**
+     * Fetch grants for an array of projects with milestones.
+     * @param projects
+     * @returns
+     */
+    abstract grantsFor(projects: Project[], withCommunity?: boolean): Promise<Grant[]>;
+    /**
+     * Fetch a grants that belongs to a community.
+     * @param uid community uid
+     * @returns
+     */
+    abstract grantsByCommunity(uid: Hex): any;
+    /**
+     * Fetch all milestones related to an array of Grants.
+     * @param grants
+     * @returns
+     */
+    abstract milestonesOf(grants: Grant[]): Promise<Milestone[]>;
+    /**
+     * Bulk fetch members with details of an array of Projects.
+     * @param projects
+     * @returns
+     */
+    abstract membersOf(projects: Project[]): Promise<MemberOf[]>;
+    /**
+     * Check if a name is already in use.
+     * @param slug
+     * @returns
+     */
+    abstract slugExists(slug: string): Promise<boolean>;
+}

package/core/class/GraphQL/Fetcher.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Fetcher = void 0;
+const AxiosGQL_1 = require("./AxiosGQL");
+class Fetcher extends AxiosGQL_1.AxiosGQL {
+}
+exports.Fetcher = Fetcher;

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

@@ -0,0 +1,160 @@
+import { Attestation } from "../Attestation";
+import { Hex, IAttestation, TSchemaName } from "../../types";
+import { Grantee } from "../types/attestations";
+import { GapSchema } from "../GapSchema";
+import { EASClient } from "./EASClient";
+import { Grant, Milestone, Project, MemberOf } from "../entities";
+import { Community } from "../entities/Community";
+export declare class GAPFetcher extends EASClient {
+    /**
+     * Fetches all the schemas deployed by an owner
+     * @param owner
+     */
+    schemas(owner: Hex): Promise<GapSchema[]>;
+    /**
+     * Fetch a single attestation by its UID.
+     * @param uid
+     */
+    attestation<T = unknown>(uid: Hex): Promise<Attestation<T, GapSchema>>;
+    /**
+     * Fetch attestations of a schema.
+     * @param schemaName
+     * @param search if set, will search decodedDataJson by the value.
+     * @returns
+     */
+    attestations(schemaName: TSchemaName, search?: string): Promise<IAttestation[]>;
+    /**
+     * Fetch attestations of a schema.
+     * @param schemaName
+     * @param recipient
+     * @returns
+     */
+    attestationsOf(schemaName: TSchemaName, recipient: Hex): Promise<IAttestation[]>;
+    /**
+     * Fetch attestations of a schema for a specific recipient.
+     * @param schemaName
+     * @param recipient
+     * @returns
+     */
+    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[]>;
+    /**
+     * Fetch all available communities with details and grantees uids.
+     *
+     * If search is defined, will try to find communities by the search string.
+     * @param search
+     * @returns
+     */
+    communities(search?: string): Promise<Community[]>;
+    /**
+     * Fetch a set of communities by their ids.
+     * @param uids
+     * @returns
+     */
+    communitiesByIds(uids: Hex[]): Promise<Community[]>;
+    /**
+     * Get details for a set of communities and returns the updated array.
+     * @param communities
+     * @returns
+     */
+    communitiesDetails(communities: Community[]): Promise<Community[]>;
+    /**
+     * Fetch a community by its name with details, grants and milestones.
+     *
+     * It is possible that the resulted community is not the one you are looking for.
+     * @param name
+     * @returns
+     */
+    communityBySlug(slug: string): Promise<Community>;
+    /**
+     * Fetch a community by its id. This method will also return the
+     * community details and projects.
+     */
+    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[]>;
+    /**
+     * Fetch a project by its id.
+     * @param uid
+     * @returns
+     */
+    projectById(uid: Hex): Promise<Project>;
+    /**
+     * Fetch a project by its id.
+     * @param uid
+     * @returns
+     */
+    projectBySlug(slug: string): Promise<Project>;
+    /**
+     * Check if a name is already in use.
+     * @param slug
+     * @returns
+     */
+    slugExists(slug: string): Promise<boolean>;
+    /**
+     * Fetch projects with details and members.
+     * @param name if set, will search by the name.
+     * @returns
+     */
+    projects(name?: string): Promise<Project[]>;
+    /**
+     * Fetch projects with details and members.
+     * @param grantee the public address of the grantee
+     * @returns
+     */
+    projectsOf(grantee: Hex): Promise<Project[]>;
+    /**
+     * Fetch Grantee with details and projects.
+     * @param address
+     * @param withProjects if true, will get grantee project details.
+     * @returns
+     */
+    grantee(address: Hex): Promise<Grantee>;
+    /**
+     * Fetch all Grantees with details.
+     * @returns
+     */
+    grantees(): Promise<Grantee[]>;
+    /**
+     * Fetches the grantes related to a grantee address (recipient).
+     * @param grantee
+     * @returns
+     */
+    grantsOf(grantee: Hex, withCommunity?: boolean): Promise<Grant[]>;
+    grantsUpdates(grants: Grant[]): Promise<Grant[]>;
+    grantsByCommunity(uid: Hex): Promise<Grant[]>;
+    /**
+     * Fetch grants for an array of projects with milestones.
+     * @param projects
+     * @returns
+     */
+    grantsFor(projects: Project[], withCommunity?: boolean): Promise<Grant[]>;
+    /**
+     * Fetch all milestones related to an array of Grants.
+     * @param grants
+     * @returns
+     */
+    milestonesOf(grants: Grant[]): Promise<Milestone[]>;
+    /**
+     * Bulk fetch members with details of an array of Projects.
+     * @param projects
+     * @returns
+     */
+    membersOf(projects: Project[]): Promise<MemberOf[]>;
+    /**
+     * Returns a string to be used to search by a value in `decodedDataJson`.
+     * @param field
+     * @param value
+     */
+    private getSearchFieldString;
+}