@show-karma/karma-gap-sdk 0.1.29

package/core/class/Attestation.d.ts

@@ -0,0 +1,169 @@
+import { Hex, IAttestation, JSONStr, MultiAttestData, SignerOrProvider } from "../types";
+import { Schema } from "./Schema";
+import { SchemaItem, SchemaValue } from "@ethereum-attestation-service/eas-sdk";
+import { GapSchema } from "./GapSchema";
+export interface AttestationArgs<T = unknown, S extends Schema = Schema> {
+    data: T | string;
+    schema: S;
+    uid?: Hex;
+    refUID?: Hex;
+    attester?: Hex;
+    recipient: Hex;
+    revoked?: boolean;
+    revocationTime?: Date | number;
+    createdAt?: Date | number;
+}
+/**
+ * Represents the EAS Attestation and provides methods to manage attestations.
+ * @example
+ *
+ * ```ts
+ * const grantee = new Attestation({
+ *  schema: Schema.get("Grantee"), // Use GapSchema.find("SchemaName") if using default GAP schemas
+ *  data: { grantee: true },
+ *  uid: "0xabc123",
+ * });
+ *
+ * const granteeDetails = new Attestation({
+ *  schema: Schema.get("GranteeDetails"),
+ *  data: {
+ *    name: "John Doe",
+ *    description: "A description",
+ *    imageURL: "https://example.com/image.png",
+ *  },
+ *  uid: "0xab234"
+ * );
+ *
+ * // Return the refferenced attestation
+ * const ref = granteeDetails.reference<Grantee>();
+ *
+ * // Revoke attestation
+ * granteeDetails.revoke();
+ *
+ * // Get attestation data from a decoded JSON string.
+ * granteeDetails.fromDecodedSchema(granteeDetails.data);
+ * ```
+ */
+export declare class Attestation<T = unknown, S extends Schema = GapSchema> implements AttestationArgs<T, S> {
+    readonly schema: S;
+    private _data;
+    protected _uid: Hex;
+    readonly refUID?: Hex;
+    readonly attester?: Hex;
+    readonly recipient: Hex;
+    readonly revoked?: boolean;
+    readonly revocationTime?: Date;
+    readonly createdAt: Date;
+    private _reference?;
+    constructor(args: AttestationArgs<T, S>);
+    /**
+     * Encodes the schema.
+     * @returns
+     */
+    encodeSchema(schema: SchemaItem[]): string;
+    /**
+     * Sets a field in the schema.
+     */
+    setValue<K extends keyof T>(key: K, value: SchemaValue): void;
+    /**
+     * Set attestation values to be uploaded.
+     * @param values
+     */
+    setValues(values: T): void;
+    /**
+     * Returns the referenced attestation
+     */
+    reference<Ref = unknown, RefSchema extends Schema = Schema>(): Attestation<Ref, RefSchema>;
+    /**
+     * Returns the attestation data as a JSON string.
+     * @param data
+     * @returns
+     */
+    fromDecodedSchema(data: T | JSONStr): T;
+    /**
+     * Revokes this attestation.
+     * @param eas
+     * @param signer
+     * @returns
+     */
+    revoke(signer: SignerOrProvider): Promise<any>;
+    /**
+     * Attests the data using the specified signer and schema.
+     * @param signer - The signer or provider to use for attestation.
+     * @param args - Additional arguments to pass to the schema's `attest` method.
+     * @returns A Promise that resolves to the UID of the attestation.
+     * @throws An `AttestationError` if an error occurs during attestation.
+     */
+    attest(signer: SignerOrProvider, ...args: unknown[]): Promise<void>;
+    /**
+     * Validates the payload.
+     *
+     * If an attestation should have anything
+     * specifically explicit, it should be implemented in
+     * order to avoid errors.
+     * @returns
+     */
+    protected assertPayload(): boolean;
+    /**
+     * Get the multi attestation payload for the referred index.
+     *
+     * The index should be the array position this payload wants
+     * to reference.
+     *
+     * E.g:
+     *
+     * 1. Project is index 0;
+     * 2. Project details is index 1;
+     * 3. Grant is index 2;
+     * 4. Grant details is index 3;
+     * 5. Milestone is index 4;
+     *
+     * `[Project, projectDetails, grant, grantDetails, milestone]`
+     *
+     * -> Project.payloadFor(0); // refs itself (no effect)
+     *
+     * -> project.details.payloadFor(0); // ref project
+     *
+     * -> grant.payloadFor(0); // ref project
+     *
+     * -> grant.details.payloadFor(2); // ref grant
+     *
+     * -> milestone.payloadFor(2); // ref grant
+     *
+     *
+     * @param refIdx
+     * @returns [Encoded payload, Raw payload]
+     */
+    payloadFor(refIdx: number): {
+        payload: MultiAttestData;
+        raw: MultiAttestData;
+    };
+    /**
+     * Returns an Attestation instance from a JSON decoded schema.
+     * @param data
+     * @returns
+     */
+    static fromDecodedSchema<T>(data: JSONStr): T;
+    /**
+     * Transform attestation interface-based into class-based.
+     */
+    static fromInterface<T extends Attestation = Attestation>(attestations: IAttestation[]): T[];
+    /**
+     * Asserts if schema is valid.
+     * > Does not check refUID if `strict = false`. To check refUID use `Schema.validate()`
+     * @param args
+     */
+    protected assert(args: AttestationArgs, strict?: boolean): void;
+    get data(): T;
+    get uid(): Hex;
+    set uid(uid: Hex);
+    /**
+     * Create attestation to serve as Attestation data.
+     * @param data Data to attest
+     * @param schema selected schema
+     * @param from attester
+     * @param to recipient
+     * @returns
+     */
+    static factory<T = unknown>(data: T, schema: Schema, from: Hex, to: Hex): Attestation<T, Schema<string>>;
+}

package/core/class/Attestation.js

@@ -0,0 +1,311 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Attestation = void 0;
+const Schema_1 = require("./Schema");
+const SchemaError_1 = require("./SchemaError");
+const get_date_1 = require("../utils/get-date");
+const consts_1 = require("../consts");
+const GapContract_1 = require("./contract/GapContract");
+/**
+ * Represents the EAS Attestation and provides methods to manage attestations.
+ * @example
+ *
+ * ```ts
+ * const grantee = new Attestation({
+ *  schema: Schema.get("Grantee"), // Use GapSchema.find("SchemaName") if using default GAP schemas
+ *  data: { grantee: true },
+ *  uid: "0xabc123",
+ * });
+ *
+ * const granteeDetails = new Attestation({
+ *  schema: Schema.get("GranteeDetails"),
+ *  data: {
+ *    name: "John Doe",
+ *    description: "A description",
+ *    imageURL: "https://example.com/image.png",
+ *  },
+ *  uid: "0xab234"
+ * );
+ *
+ * // Return the refferenced attestation
+ * const ref = granteeDetails.reference<Grantee>();
+ *
+ * // Revoke attestation
+ * granteeDetails.revoke();
+ *
+ * // Get attestation data from a decoded JSON string.
+ * granteeDetails.fromDecodedSchema(granteeDetails.data);
+ * ```
+ */
+class Attestation {
+    constructor(args) {
+        this.schema = args.schema;
+        this._data = this.fromDecodedSchema(args.data);
+        this.setValues(this._data);
+        this._uid = args.uid || consts_1.nullRef;
+        this.refUID = args.refUID || consts_1.nullRef;
+        this.attester = args.attester;
+        this.recipient = args.recipient;
+        this.revoked = args.revoked;
+        this.revocationTime = (0, get_date_1.getDate)(args.revocationTime);
+        this.createdAt = (0, get_date_1.getDate)(args.createdAt || Date.now());
+    }
+    /**
+     * Encodes the schema.
+     * @returns
+     */
+    encodeSchema(schema) {
+        return this.schema.encode(schema);
+    }
+    /**
+     * Sets a field in the schema.
+     */
+    setValue(key, value) {
+        this.schema.setValue(key, value);
+    }
+    /**
+     * Set attestation values to be uploaded.
+     * @param values
+     */
+    setValues(values) {
+        const isJsonSchema = this.schema.isJsonSchema();
+        if (isJsonSchema)
+            this.schema.setValue("json", JSON.stringify(values));
+        this._data = values;
+        Object.entries(values).forEach(([key, value]) => {
+            this[key] = value;
+            if (!isJsonSchema)
+                this.setValue(key, value.value || value);
+        });
+    }
+    /**
+     * Returns the referenced attestation
+     */
+    reference() {
+        return this._reference;
+    }
+    /**
+     * Returns the attestation data as a JSON string.
+     * @param data
+     * @returns
+     */
+    fromDecodedSchema(data) {
+        return typeof data === "string"
+            ? Attestation.fromDecodedSchema(data)
+            : data;
+    }
+    /**
+     * Revokes this attestation.
+     * @param eas
+     * @param signer
+     * @returns
+     */
+    revoke(signer) {
+        try {
+            return GapContract_1.GapContract.multiRevoke(signer, [
+                {
+                    data: [
+                        {
+                            uid: this.uid,
+                            value: 0n,
+                        },
+                    ],
+                    schema: this.schema.uid,
+                },
+            ]);
+        }
+        catch (error) {
+            console.error(error);
+            throw new SchemaError_1.SchemaError("REVOKE_ERROR", "Error revoking attestation.");
+        }
+    }
+    /**
+     * Attests the data using the specified signer and schema.
+     * @param signer - The signer or provider to use for attestation.
+     * @param args - Additional arguments to pass to the schema's `attest` method.
+     * @returns A Promise that resolves to the UID of the attestation.
+     * @throws An `AttestationError` if an error occurs during attestation.
+     */
+    async attest(signer, ...args) {
+        console.log(`Attesting ${this.schema.name}`);
+        try {
+            const uid = await this.schema.attest({
+                data: this.data,
+                to: this.recipient,
+                refUID: this.refUID,
+                signer,
+            });
+            this._uid = uid;
+            console.log(`Attested ${this.schema.name} with UID ${uid}`);
+        }
+        catch (error) {
+            console.error(error);
+            throw new SchemaError_1.AttestationError("ATTEST_ERROR", "Error during attestation.");
+        }
+    }
+    /**
+     * Validates the payload.
+     *
+     * If an attestation should have anything
+     * specifically explicit, it should be implemented in
+     * order to avoid errors.
+     * @returns
+     */
+    assertPayload() {
+        return true;
+    }
+    /**
+     * Get the multi attestation payload for the referred index.
+     *
+     * The index should be the array position this payload wants
+     * to reference.
+     *
+     * E.g:
+     *
+     * 1. Project is index 0;
+     * 2. Project details is index 1;
+     * 3. Grant is index 2;
+     * 4. Grant details is index 3;
+     * 5. Milestone is index 4;
+     *
+     * `[Project, projectDetails, grant, grantDetails, milestone]`
+     *
+     * -> Project.payloadFor(0); // refs itself (no effect)
+     *
+     * -> project.details.payloadFor(0); // ref project
+     *
+     * -> grant.payloadFor(0); // ref project
+     *
+     * -> grant.details.payloadFor(2); // ref grant
+     *
+     * -> milestone.payloadFor(2); // ref grant
+     *
+     *
+     * @param refIdx
+     * @returns [Encoded payload, Raw payload]
+     */
+    payloadFor(refIdx) {
+        this.assertPayload();
+        const payload = (encode = true) => ({
+            uid: consts_1.nullRef,
+            refIdx,
+            multiRequest: {
+                schema: this.schema.uid,
+                data: [
+                    {
+                        refUID: this.refUID,
+                        expirationTime: 0n,
+                        revocable: this.schema.revocable || true,
+                        value: 0n,
+                        data: (encode ? this.schema.encode() : this.schema.schema),
+                        recipient: this.recipient,
+                    },
+                ],
+            },
+        });
+        return {
+            payload: payload(),
+            raw: payload(false),
+        };
+    }
+    /**
+     * Returns an Attestation instance from a JSON decoded schema.
+     * @param data
+     * @returns
+     */
+    static fromDecodedSchema(data) {
+        try {
+            const parsed = JSON.parse(data);
+            if (data.length < 2 && !/\{.*\}/gim.test(data))
+                return {};
+            if (parsed.length === 1 && parsed[0].name === "json") {
+                const { value } = parsed[0];
+                return (typeof value.value === "string"
+                    ? JSON.parse(value.value)
+                    : value.value);
+            }
+            if (parsed && Array.isArray(parsed)) {
+                return parsed.reduce((acc, curr) => {
+                    const { value } = curr.value;
+                    if (curr.type.includes("uint")) {
+                        acc[curr.name] = ["string", "bigint"].includes(typeof value)
+                            ? BigInt(value)
+                            : Number(value);
+                    }
+                    else
+                        acc[curr.name] = value;
+                    return acc;
+                }, {});
+            }
+            throw new SchemaError_1.SchemaError("INVALID_DATA", "Data must be a valid JSON array string.");
+        }
+        catch (error) {
+            console.error(error);
+            throw new SchemaError_1.SchemaError("INVALID_DATA", "Data must be a valid JSON string.");
+        }
+    }
+    /**
+     * Transform attestation interface-based into class-based.
+     */
+    static fromInterface(attestations) {
+        const result = [];
+        attestations.forEach((attestation) => {
+            try {
+                const schema = Schema_1.Schema.get(attestation.schemaId);
+                result.push(new Attestation({
+                    ...attestation,
+                    schema,
+                    data: attestation.decodedDataJson,
+                }));
+            }
+            catch (e) {
+                console.log(e);
+            }
+        });
+        return result;
+    }
+    /**
+     * Asserts if schema is valid.
+     * > Does not check refUID if `strict = false`. To check refUID use `Schema.validate()`
+     * @param args
+     */
+    assert(args, strict = false) {
+        const { schema, uid } = args;
+        if (!schema || !(schema instanceof Schema_1.Schema)) {
+            throw new SchemaError_1.SchemaError("MISSING_FIELD", "Schema must be an array.");
+        }
+        if (!uid) {
+            throw new SchemaError_1.SchemaError("MISSING_FIELD", "Schema uid is required");
+        }
+        if (strict)
+            Schema_1.Schema.validate();
+    }
+    get data() {
+        return this._data;
+    }
+    get uid() {
+        return this._uid;
+    }
+    set uid(uid) {
+        this._uid = uid;
+    }
+    /**
+     * Create attestation to serve as Attestation data.
+     * @param data Data to attest
+     * @param schema selected schema
+     * @param from attester
+     * @param to recipient
+     * @returns
+     */
+    static factory(data, schema, from, to) {
+        return new Attestation({
+            data: data,
+            recipient: to,
+            attester: from,
+            schema,
+            uid: "0x0",
+            createdAt: new Date(),
+        });
+    }
+}
+exports.Attestation = Attestation;

package/core/class/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 "./GraphQL/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/Fetcher.js

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