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

package/core/utils/map-filter.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapFilter = mapFilter;
+/**
+ * Filters an array by its condition then maps it to the desired format.
+ * @param arr
+ * @param condition
+ * @param mapTo
+ * @returns
+ */
+function mapFilter(arr, condition, mapTo) {
+    const newArray = [];
+    for (const item of arr) {
+        if (condition(item)) {
+            newArray.push(mapTo(item));
+        }
+    }
+    return newArray;
+}

package/core/utils/serialize-bigint.d.ts

@@ -0,0 +1 @@
+export declare function serializeWithBigint(value: unknown): string;

package/core/utils/serialize-bigint.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeWithBigint = serializeWithBigint;
+function serializeWithBigint(value) {
+    return JSON.stringify(value, (this,
+        (key, value) => (typeof value === "bigint" ? value.toString() : value)));
+}

package/core/utils/to-unix.d.ts

@@ -0,0 +1 @@
+export declare function toUnix(value: number | Date | string): number;

package/core/utils/to-unix.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toUnix = toUnix;
+function toUnix(value) {
+    switch (typeof value) {
+        case "number":
+            value = Math.round(value);
+            if (value.toString().length > 13)
+                throw new Error("Invalid timestamp length");
+            if (value.toString().length === 10)
+                return value;
+            return Math.floor(value / 1000);
+        case "string":
+            if (/\D/.test(value))
+                return null;
+            return toUnix(+value);
+        case "object":
+            if (value instanceof Date)
+                return toUnix(value.getTime());
+            return null;
+        default:
+            return null;
+    }
+}

package/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./core"), exports);

package/package.json

@@ -1,47 +1,47 @@
 {
-  "name": "@show-karma/karma-gap-sdk",
-  "publishConfig": {
-    "access": "public"
-  },
-  "version": "0.4.16",
-  "description": "Simple and easy interface between EAS and Karma GAP.",
-  "main": "./index.js",
-  "author": "KarmaHQ",
-  "license": "MIT",
-  "private": false,
-  "repository": {
-    "url": "git+https://github.com/show-karma/karma-gap-sdk.git",
-    "type": "git"
-  },
-  "scripts": {
-    "deploy": "npx ts-node ./core/scripts/deploy.ts",
-    "csv-upload": "npx ts-node ./csv-upload/scripts/run.ts",
-    "test-file": "npx ts-node ./test-file-indexer-api.ts",
-    "test-milestone": "npx ts-node ./milestone-workflow-example.ts",
-    "create-community": "npx ts-node ./create-community-example.ts",
-    "publish-npm": "npm version patch && tsc && cd .dist && npm publish --scope=@show-karma/karma-gap-sdk --access public"
-  },
-  "dependencies": {
-    "@allo-team/allo-v2-sdk": "^1.0.63",
-    "@ethereum-attestation-service/eas-sdk": "1.4.2",
-    "@gelatonetwork/relay-sdk": "^5.6.0",
-    "@types/sha256": "^0.2.0",
-    "axios": "^1.7.9",
-    "dotenv": "^17.2.3",
-    "ethers": "6.11.0",
-    "sha256": "^0.2.0",
-    "simple-ts-job-runner": "^1.0.12"
-  },
-  "overrides": {
-    "ws": ">=8.17.1",
-    "cookie": ">=0.7.0"
-  },
-  "devDependencies": {
-    "@types/node": "^20.5.0",
-    "eslint": "^8.47.0",
-    "fast-csv": "^4.3.6",
-    "husky": "^8.0.3",
-    "prettier": "^3.0.1",
-    "typescript": "^5.1.6"
-  }
+    "name": "@show-karma/karma-gap-sdk",
+    "publishConfig": {
+        "access": "public"
+    },
+    "version": "0.4.17",
+    "description": "Simple and easy interface between EAS and Karma GAP.",
+    "main": "./index.js",
+    "author": "KarmaHQ",
+    "license": "MIT",
+    "private": false,
+    "repository": {
+        "url": "git+https://github.com/show-karma/karma-gap-sdk.git",
+        "type": "git"
+    },
+    "scripts": {
+        "deploy": "npx ts-node ./core/scripts/deploy.ts",
+        "csv-upload": "npx ts-node ./csv-upload/scripts/run.ts",
+        "test-file": "npx ts-node ./test-file-indexer-api.ts",
+        "test-milestone": "npx ts-node ./milestone-workflow-example.ts",
+        "create-community": "npx ts-node ./create-community-example.ts",
+        "publish-npm": "npm version patch && tsc && cd .dist && npm publish --scope=@show-karma/karma-gap-sdk --access public"
+    },
+    "dependencies": {
+        "@allo-team/allo-v2-sdk": "^1.0.63",
+        "@ethereum-attestation-service/eas-sdk": "1.4.2",
+        "@gelatonetwork/relay-sdk": "^5.6.0",
+        "@types/sha256": "^0.2.0",
+        "axios": "^1.7.9",
+        "dotenv": "^17.2.3",
+        "ethers": "6.11.0",
+        "sha256": "^0.2.0",
+        "simple-ts-job-runner": "^1.0.12"
+    },
+    "overrides": {
+        "ws": ">=8.17.1",
+        "cookie": ">=0.7.0"
+    },
+    "devDependencies": {
+        "@types/node": "^20.5.0",
+        "eslint": "^8.47.0",
+        "fast-csv": "^4.3.6",
+        "husky": "^8.0.3",
+        "prettier": "^3.0.1",
+        "typescript": "^5.1.6"
+    }
 }

package/.cursorrules

@@ -1,43 +0,0 @@
-# Karma GAP SDK - Cursor Rules
-
-## Project Overview
-The Karma GAP SDK is a library for easy integration with the Grantee Accountability Protocol. It provides tools to fetch and display Communities, Projects, Members, Grants, Milestones, and their dependencies, as well as create, update, and delete these entities. The SDK also supports gasless transactions with Gelato Relay and custom API endpoints for faster queries.
-
-## Architecture Guidelines
-When working with this codebase, understand that it follows a modular architecture with these key components:
-
-1. **GAP Facade** - Centralizes resources within the SDK, providing tools and methods to retrieve attestations and convert them into concrete objects.
-2. **Attestations** - Base module for handling various types of attestations available at EAS. Can be inherited for specific attestation types.
-3. **Schemas** - Abstract module that establishes connection with the EAS infrastructure. Contains parameters, methods, and interactions for blockchain communication.
-4. **Entities** - Represents specific attestation types customized for specific requirements. Always extends the Attestation module.
-5. **Fetcher** - Abstract module for interacting with EAS or custom API to retrieve attestations and transform them into Attestation instances.
-6. **Contract** - Custom intermediary contract to add an abstraction layer to the original EAS contracts.
-
-## Entity Types
-The SDK supports various entity types that represent different attestation types in the Grantee Accountability Protocol: Use the `gap-schema.yaml` file to understand the different types of attestations and their relationships.
-
-## Code Style Guidelines
-- Use TypeScript for all new code
-- Follow the existing module pattern when adding new features
-- Maintain proper inheritance hierarchy for new entities (extend from Attestation)
-- Document all public methods and classes with JSDoc comments
-- Use async/await for asynchronous operations
-- Implement proper error handling with custom error classes
-
-## Integration Features
-The SDK includes several integration features:
-
-- **Gelato Integration** - For gasless transactions
-- **GraphQL** - For data fetching
-- **Remote Storage** - For storing data remotely
-- **Karma Indexer** - For efficient data retrieval
-
-## Testing Guidelines
-- Write unit tests for all new functionality
-- Ensure backward compatibility when modifying existing code
-- Test with both custom API and direct blockchain access
-
-## Documentation
-- Update the README.md when adding new features
-- Include examples for new functionality
-- Document any breaking changes 

package/core/abi/index.ts

@@ -1,21 +0,0 @@
-import AirdropNFT from "./AirdropNFT.json";
-import Allo from "./Allo.json";
-import AlloRegistry from "./AlloRegistry.json";
-import CommunityResolverABI from "./CommunityResolverABI.json";
-import Donations from "./Donations.json";
-import EAS from "./EAS.json";
-import MultiAttester from "./MultiAttester.json";
-import ProjectResolver from "./ProjectResolver.json";
-import SchemaRegistry from "./SchemaRegistry.json";
-
-export const abis = {
-    AirdropNFT,
-    Allo,
-    AlloRegistry,
-    CommunityResolverABI,
-    Donations,
-    EAS,
-    MultiAttester,
-    ProjectResolver,
-    SchemaRegistry,
-};

package/core/class/AllGapSchemas.ts

@@ -1,21 +0,0 @@
-import { MountEntities, Networks } from "../../core/consts";
-import { SchemaInterface, TNetwork, TSchemaName } from "../types";
-import { GAP } from "./GAP";
-import { GapSchema } from "./GapSchema";
-
-export class AllGapSchemas {
-  public allSchemas: { [network: string]: SchemaInterface<TSchemaName>[] } = {};
-
-  constructor() {
-    Object.keys(Networks).forEach((network) => {
-      this.allSchemas[network] = Object.values(
-        MountEntities(Networks[network])
-      );
-    });
-  }
-
-  findSchema(name: TSchemaName, network: TNetwork) {
-    const schema = this.allSchemas[network].find((s) => s.name === name);
-    return new GapSchema(schema, GAP.getInstance({ network }), false, false);
-  }
-}

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,
-    });
-  }
-}