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

package/core/class/Attestation.ts

@@ -1,429 +0,0 @@
-import {
-  Hex,
-  IAttestation,
-  JSONStr,
-  MultiAttestData,
-  MultiAttestPayload,
-  SignerOrProvider,
-  TNetwork,
-  TSchemaName,
-} from "../types";
-import { Schema } from "./Schema";
-import { AttestationError, SchemaError } from "./SchemaError";
-import {
-  SchemaDecodedItem,
-  SchemaItem,
-  SchemaValue,
-} from "@ethereum-attestation-service/eas-sdk";
-import { getDate } from "../utils/get-date";
-import { GAP } from "./GAP";
-import { GapSchema } from "./GapSchema";
-import { Networks, nullRef } from "../consts";
-import { GapContract } from "./contract/GapContract";
-import { IpfsStorage } from "./remote-storage/IpfsStorage";
-import { AttestationWithTx } from "./types/attestations";
-
-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;
-  chainID?: number;
-}
-
-/**
- * Represents the EAS Attestation and provides methods to manage attestations.
- * @example
- *
- * ```ts
- * const grantee = new Attestation({
- *  schema: Schema.get("Grantee", "network-name"), // Use this.schema.gap.findSchema("SchemaName") if using default GAP schemas
- *  data: { grantee: true },
- *  uid: "0xabc123",
- * });
- *
- * const granteeDetails = new Attestation({
- *  schema: Schema.get("GranteeDetails", "optimism"),
- *  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 class Attestation<T = unknown, S extends Schema = GapSchema>
-  implements AttestationArgs<T, S>
-{
-  readonly schema: S;
-  private _data: T;
-
-  protected _uid: Hex;
-  readonly refUID?: Hex;
-  readonly attester?: Hex;
-  readonly recipient: Hex;
-  readonly revoked?: boolean;
-  readonly revocationTime?: Date;
-  readonly createdAt: Date;
-  private _chainID: number;
-
-  private _reference?: Attestation;
-
-  constructor(args: AttestationArgs<T, S>) {
-    this.schema = args.schema;
-
-    this._data = this.fromDecodedSchema(args.data);
-
-    this.setValues(this._data);
-    this._uid = args.uid || nullRef;
-    this.refUID = args.refUID || nullRef;
-    this.attester = args.attester;
-    this.recipient = args.recipient;
-    this.revoked = args.revoked;
-    this.revocationTime = getDate(args.revocationTime);
-    this.createdAt = getDate(args.createdAt || Date.now() / 1000);
-    this._chainID = args.chainID || Networks[this.schema.gap.network].chainId;
-  }
-
-  /**
-   * Encodes the schema.
-   * @returns
-   */
-  encodeSchema(schema: SchemaItem[]) {
-    return this.schema.encode(schema);
-  }
-
-  /**
-   * Sets a field in the schema.
-   */
-  setValue<K extends keyof T>(key: K, value: SchemaValue) {
-    this.schema.setValue(key as string, value);
-  }
-
-  /**
-   * Set attestation values to be uploaded.
-   * @param values
-   */
-  setValues(values: T) {
-    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 as keyof T, value.value || value);
-    });
-  }
-
-  /**
-   * Returns the referenced attestation
-   */
-  reference<Ref = unknown, RefSchema extends Schema = Schema>() {
-    return this._reference as Attestation<Ref, RefSchema>;
-  }
-
-  /**
-   * Returns the attestation data as a JSON string.
-   * @param data
-   * @returns
-   */
-  fromDecodedSchema(data: T | JSONStr): T {
-    return typeof data === "string"
-      ? Attestation.fromDecodedSchema<T>(data)
-      : data;
-  }
-
-  /**
-   * Revokes this attestation.
-   * @param eas
-   * @param signer
-   * @returns
-   */
-  async revoke(
-    signer: SignerOrProvider,
-    callback?: Function
-  ): Promise<AttestationWithTx> {
-    try {
-      callback?.("preparing");
-      const { tx } = await GapContract.multiRevoke(signer, [
-        {
-          data: [
-            {
-              uid: this.uid,
-              value: 0n,
-            },
-          ],
-          schema: this.schema.uid,
-        },
-      ]).then((res) => {
-        callback?.("confirmed");
-        return res;
-      });
-      return { tx, uids: [this.uid] };
-    } catch (error) {
-      console.error(error);
-      throw new SchemaError(
-        "REVOKE_ERROR",
-        "Error revoking attestation.",
-        error
-      );
-    }
-  }
-
-  /**
-   * 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: SignerOrProvider,
-    ...args: unknown[]
-  ): Promise<AttestationWithTx> {
-    const callback =
-      typeof args[args.length - 1] === "function"
-        ? (args.pop() as (status: string) => void)
-        : null;
-    console.log(`Attesting ${this.schema.name}`);
-    try {
-      const { tx, uids } = await this.schema.attest<T>({
-        data: this.data,
-        to: this.recipient,
-        refUID: this.refUID,
-        signer,
-        callback: callback,
-      });
-
-      this._uid = uids[0];
-      console.log(`Attested ${this.schema.name} with UID ${this.uid}`);
-      return { tx, uids };
-    } catch (error) {
-      console.error(error);
-      throw new AttestationError(
-        "ATTEST_ERROR",
-        "Error during attestation.",
-        error
-      );
-    }
-  }
-
-  /**
-   * Validates the payload.
-   *
-   * If an attestation should have anything
-   * specifically explicit, it should be implemented in
-   * order to avoid errors.
-   * @returns
-   */
-  protected 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]
-   */
-  async payloadFor(refIdx: number): Promise<{
-    payload: MultiAttestData;
-    raw: MultiAttestData;
-  }> {
-    this.assertPayload();
-
-    if (this.schema.isJsonSchema()) {
-      if ((this as any).type) {
-        (this._data as T & { type: string }).type = (this as any).type;
-        this.schema.setValue("json", JSON.stringify(this._data));
-      }
-    }
-
-    const payload = (encode = true): MultiAttestData => ({
-      uid: 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) as any,
-            recipient: this.recipient,
-          },
-        ],
-      },
-    });
-    return {
-      payload: payload(),
-      raw: payload(false),
-    };
-  }
-
-  /**
-   * Returns an Attestation instance from a JSON decoded schema.
-   * @param data
-   * @returns
-   */
-  static fromDecodedSchema<T>(data: JSONStr): T {
-    try {
-      const parsed: SchemaDecodedItem[] = JSON.parse(data);
-
-      if (data.length < 2 && !/\{.*\}/gim.test(data)) return {} as T;
-      if (parsed.length === 1 && parsed[0].name === "json") {
-        const { value } = parsed[0];
-        return (
-          typeof value.value === "string"
-            ? JSON.parse(value.value)
-            : value.value
-        ) as T;
-      }
-
-      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 as any)
-              : Number(value);
-          } else acc[curr.name] = value;
-          return acc;
-        }, {}) as T;
-      }
-
-      throw new SchemaError(
-        "INVALID_DATA",
-        "Data must be a valid JSON array string."
-      );
-    } catch (error) {
-      console.error(error);
-      throw new SchemaError(
-        "INVALID_DATA",
-        "Data must be a valid JSON string.",
-        error
-      );
-    }
-  }
-
-  /**
-   * Transform attestation interface-based into class-based.
-   */
-  static fromInterface<T extends Attestation = Attestation>(
-    attestations: IAttestation[],
-    network: TNetwork
-  ) {
-    const result: T[] = [];
-    attestations.forEach((attestation) => {
-      try {
-        const schema = Schema.get(attestation.schemaId, network);
-        result.push(
-          <T>new Attestation({
-            ...attestation,
-            schema,
-            chainID: Networks[network].chainId,
-            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
-   */
-  protected assert(args: AttestationArgs, strict = false) {
-    const { schema, uid } = args;
-
-    if (!schema || !(schema instanceof Schema)) {
-      throw new SchemaError("MISSING_FIELD", "Schema must be an array.");
-    }
-
-    if (!uid) {
-      throw new SchemaError("MISSING_FIELD", "Schema uid is required");
-    }
-
-    if (strict) Schema.validate(this.schema.gap.network);
-  }
-
-  get chainID() {
-    return this._chainID;
-  }
-
-  get data(): T {
-    return this._data;
-  }
-
-  get uid() {
-    return this._uid;
-  }
-
-  set uid(uid: Hex) {
-    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<T = unknown>(data: T, schema: Schema, from: Hex, to: Hex) {
-    return new Attestation({
-      data: data,
-      recipient: to,
-      attester: from,
-      schema,
-      uid: "0x0",
-      createdAt: new Date(),
-      chainID: Networks[schema.gap.network].chainId,
-    });
-  }
-}

package/core/class/Fetcher.ts

@@ -1,224 +0,0 @@
-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";
-import { GAP } from "./GAP";
-
-export abstract class Fetcher extends AxiosGQL {
-  protected gap: GAP;
-
-  constructor(url: string) {
-    super(url);
-  }
-
-  set gapInstance(gap: GAP) {
-    this.gap = gap;
-  }
-
-  /**
-   * 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 all available communities with details for a grantee;
-   *
-   * If search is defined, will try to find communities by the search string.
-   * @param address grantee address
-   * @param withGrants if true, will get community grants.
-   * @returns
-   */
-  abstract communitiesOf(
-    address: Hex,
-    withGrants?: boolean
-  ): Promise<Community[]>;
-
-  /**
-   * Fetch all available communities (admin) with details for a grantee;
-   *
-   * If search is defined, will try to find communities by the search string.
-   * @param address grantee address
-   * @param withGrants if true, will get community grants.
-   * @returns
-   */
-  abstract communitiesAdminOf(
-    address: Hex,
-    withGrants?: boolean
-  ): 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>;
-
-  /**
-   * Search projects and communities by name. This method will return a list of projects and a list of communities
-   * __Must be implemented by the indexer__
-   * @param query
-   */
-  abstract search(
-    query: string
-  ): Promise<{ projects: Project[]; communities: Community[] }>;
-
-  /**
-   * Search projects by name. This method will return a list of projects
-   * __Must be implemented by the indexer__
-   * @param query
-   */
-  abstract searchProjects(query: 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, page?: number, pageLimit?: number);
-
-  /**
-   * 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>;
-
-  /**
-   * Get grants for a project by an external uid
-   * > Works only for the indexed projects
-   * @param projectExtId
-   */
-  abstract grantsForExtProject(projectExtId: string): Promise<Grant[]>;
-}