@show-karma/karma-gap-sdk 0.4.9 → 0.4.12

package/core/class/AllGapSchemas.d.ts

@@ -1,5 +1,5 @@
-import { SchemaInterface, TNetwork, TSchemaName } from '../types';
-import { GapSchema } from './GapSchema';
+import { SchemaInterface, TNetwork, TSchemaName } from "../types";
+import { GapSchema } from "./GapSchema";
 export declare class AllGapSchemas {
     allSchemas: {
         [network: string]: SchemaInterface<TSchemaName>[];

package/core/class/AllGapSchemas.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AllGapSchemas = void 0;
 const consts_1 = require("../../core/consts");
-const GapSchema_1 = require("./GapSchema");
 const GAP_1 = require("./GAP");
+const GapSchema_1 = require("./GapSchema");
 class AllGapSchemas {
     constructor() {
         this.allSchemas = {};
@@ -12,8 +12,8 @@ class AllGapSchemas {
         });
     }
     findSchema(name, network) {
-        const schema = this.allSchemas[network].find(s => s.name === name);
-        return new GapSchema_1.GapSchema(schema, new GAP_1.GAP({ network: network }), false, false);
+        const schema = this.allSchemas[network].find((s) => s.name === name);
+        return new GapSchema_1.GapSchema(schema, GAP_1.GAP.getInstance({ network }), false, false);
     }
 }
 exports.AllGapSchemas = AllGapSchemas;

package/core/class/GAP.d.ts

@@ -1,7 +1,7 @@
-import { AttestArgs, Facade, SchemaInterface, TNetwork, TSchemaName, SignerOrProvider } from "../types";
-import { GapSchema } from "./GapSchema";
 import { ethers } from "ethers";
+import { AttestArgs, Facade, SchemaInterface, SignerOrProvider, TNetwork, TSchemaName } from "../types";
 import { Fetcher } from "./Fetcher";
+import { GapSchema } from "./GapSchema";
 import { RemoteStorage } from "./remote-storage/RemoteStorage";
 interface GAPArgs {
     network: TNetwork;
@@ -101,7 +101,8 @@ interface GAPArgs {
  *
  * This is the main class that is used to interact with the GAP SDK.
  *
- * This class can behave as a singleton or as a regular class.
+ * This class implements the singleton pattern to ensure only one instance exists
+ * throughout the application lifecycle.
  *
  * Using this class, the user will be able to:
  *
@@ -136,12 +137,16 @@ interface GAPArgs {
  *
  * const schemas = MountEntities(Networks.sepolia);
  *
- * const gap = new GAP({
+ * // Initialize the singleton instance
+ * const gap = GAP.getInstance({
  *   network: "sepolia",
  *   owner: "0xd7d1DB401EA825b0325141Cd5e6cd7C2d01825f2",
  *   schemas: Object.values(schemas),
  * });
  *
+ * // Later in the code, get the same instance
+ * const sameGap = GAP.getInstance();
+ *
  * gap.fetcher
  *   .fetchProjects()
  *   .then((res) => {
@@ -152,10 +157,23 @@ interface GAPArgs {
  */
 export declare class GAP extends Facade {
     private static remoteStorage?;
+    private static instances;
     readonly fetch: Fetcher;
     readonly network: TNetwork;
     private _schemas;
     private static _gelatoOpts;
+    /**
+     * Get the singleton instance of GAP for a specific network.
+     * If no instance exists for the network, creates one with the provided args.
+     * @param args Optional initialization arguments
+     * @returns The singleton instance of GAP for the specified network
+     */
+    static getInstance(args?: GAPArgs): GAP;
+    /**
+     * Creates a new instance of GAP.
+     * You can either use this constructor directly or use the singleton pattern via getInstance().
+     * @param args Initialization arguments
+     */
     constructor(args: GAPArgs);
     private assertGelatoOpts;
     /**

package/core/class/GAP.js

@@ -4,24 +4,25 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GAP = void 0;
+const CommunityResolverABI_json_1 = __importDefault(require("../abi/CommunityResolverABI.json"));
 const MultiAttester_json_1 = __importDefault(require("../abi/MultiAttester.json"));
 const ProjectResolver_json_1 = __importDefault(require("../abi/ProjectResolver.json"));
-const CommunityResolverABI_json_1 = __importDefault(require("../abi/CommunityResolverABI.json"));
-const types_1 = require("../types");
-const Schema_1 = require("./Schema");
-const GapSchema_1 = require("./GapSchema");
 const eas_sdk_1 = require("@ethereum-attestation-service/eas-sdk");
-const consts_1 = require("../consts");
 const ethers_1 = require("ethers");
 const package_json_1 = require("../../package.json");
-const GraphQL_1 = require("./GraphQL");
+const consts_1 = require("../consts");
+const types_1 = require("../types");
 const get_web3_provider_1 = require("../utils/get-web3-provider");
+const GapSchema_1 = require("./GapSchema");
+const GraphQL_1 = require("./GraphQL");
+const Schema_1 = require("./Schema");
 /**
  * GAP SDK Facade.
  *
  * This is the main class that is used to interact with the GAP SDK.
  *
- * This class can behave as a singleton or as a regular class.
+ * This class implements the singleton pattern to ensure only one instance exists
+ * throughout the application lifecycle.
  *
  * Using this class, the user will be able to:
  *
@@ -56,12 +57,16 @@ const get_web3_provider_1 = require("../utils/get-web3-provider");
  *
  * const schemas = MountEntities(Networks.sepolia);
  *
- * const gap = new GAP({
+ * // Initialize the singleton instance
+ * const gap = GAP.getInstance({
  *   network: "sepolia",
  *   owner: "0xd7d1DB401EA825b0325141Cd5e6cd7C2d01825f2",
  *   schemas: Object.values(schemas),
  * });
  *
+ * // Later in the code, get the same instance
+ * const sameGap = GAP.getInstance();
+ *
  * gap.fetcher
  *   .fetchProjects()
  *   .then((res) => {
@@ -71,6 +76,32 @@ const get_web3_provider_1 = require("../utils/get-web3-provider");
  * ```
  */
 class GAP extends types_1.Facade {
+    /**
+     * Get the singleton instance of GAP for a specific network.
+     * If no instance exists for the network, creates one with the provided args.
+     * @param args Optional initialization arguments
+     * @returns The singleton instance of GAP for the specified network
+     */
+    static getInstance(args) {
+        if (!args) {
+            throw new Error("Network must be specified when getting GAP instance");
+        }
+        const existingInstance = GAP.instances.get(args.network);
+        if (existingInstance) {
+            return existingInstance;
+        }
+        if (!args) {
+            throw new Error("Initialization arguments required for first instance");
+        }
+        const newInstance = new GAP(args);
+        GAP.instances.set(args.network, newInstance);
+        return newInstance;
+    }
+    /**
+     * Creates a new instance of GAP.
+     * You can either use this constructor directly or use the singleton pattern via getInstance().
+     * @param args Initialization arguments
+     */
     constructor(args) {
         super();
         /**
@@ -82,13 +113,13 @@ class GAP extends types_1.Facade {
             let slug = text
                 .toLowerCase()
                 // Remove emojis
-                .replace(/([\uE000-\uF8FF]|\uD83C[\uDF00-\uDFFF]|\uD83D[\uDC00-\uDDFF])/g, '')
+                .replace(/([\uE000-\uF8FF]|\uD83C[\uDF00-\uDFFF]|\uD83D[\uDC00-\uDDFF])/g, "")
                 // Remove basic text emoticons
-                .replace(/[:;=][()DP]/g, '')
+                .replace(/[:;=][()DP]/g, "")
                 .replace(/ /g, "-")
                 .replace(/[^\w-]+/g, "")
                 .trim()
-                .replace(/^-+|-+$/g, ''); // Remove leading and trailing hyphens
+                .replace(/^-+|-+$/g, ""); // Remove leading and trailing hyphens
             const checkSlug = async (currentSlug, counter = 0) => {
                 const slugToCheck = counter === 0 ? currentSlug : `${currentSlug}-${counter}`;
                 const slugExists = await this.fetch.slugExists(slugToCheck);
@@ -114,6 +145,7 @@ class GAP extends types_1.Facade {
         this._schemas = schemas.map((schema) => new GapSchema_1.GapSchema(schema, this, false, args.globalSchemas ? !args.globalSchemas : false));
         Schema_1.Schema.validate(this.network);
         console.info(`Loaded GAP SDK v${package_json_1.version} for network ${this.network}`);
+        GAP.instances.set(this.network, this);
     }
     assertGelatoOpts(args) {
         if (args.gelatoOpts &&
@@ -253,4 +285,5 @@ class GAP extends types_1.Facade {
     }
 }
 exports.GAP = GAP;
+GAP.instances = new Map();
 GAP._gelatoOpts = null;

package/core/class/Schema.js

@@ -483,4 +483,5 @@ Schema.schemas = {
     sei: [],
     "sei-testnet": [],
     "base-sepolia": [],
+    lisk: [],
 };

package/core/class/entities/ContributorProfile.d.ts

@@ -8,6 +8,7 @@ export interface IContributorProfile {
     github?: string;
     twitter?: string;
     linkedin?: string;
+    farcaster?: string;
 }
 export declare class ContributorProfile extends Attestation<IContributorProfile> implements IContributorProfile {
     name: string;
@@ -15,6 +16,7 @@ export declare class ContributorProfile extends Attestation<IContributorProfile>
     github?: string;
     twitter?: string;
     linkedin?: string;
+    farcaster?: string;
     constructor(data: AttestationArgs<IContributorProfile, GapSchema>);
     /**
      * Creates the payload for a multi-attestation.

package/core/class/entities/Grant.d.ts

@@ -4,16 +4,11 @@ import { IMilestone, Milestone } from "./Milestone";
 import { GapSchema } from "../GapSchema";
 import { Hex, MultiAttestPayload, SignerOrProvider, TNetwork } from "core/types";
 import { Community } from "./Community";
-import { IGrantResponse } from "../karma-indexer/api/types";
+import { IGrantResponse, IProjectResponse, ISummaryProject } from "../karma-indexer/api/types";
 import { GrantUpdate, IGrantUpdate } from "./GrantUpdate";
 export interface IGrant {
     communityUID: Hex;
 }
-export interface ISummaryProject {
-    title: string;
-    slug?: string;
-    uid: Hex;
-}
 export declare class Grant extends Attestation<IGrant> {
     details?: GrantDetails;
     communityUID: Hex;
@@ -24,7 +19,7 @@ export declare class Grant extends Attestation<IGrant> {
     updates: GrantUpdate[];
     members: string[];
     completed?: GrantCompleted;
-    project?: ISummaryProject;
+    project?: IProjectResponse | ISummaryProject;
     categories?: string[];
     verify(signer: SignerOrProvider): Promise<void>;
     /**

package/core/class/entities/GrantUpdate.d.ts

@@ -1,13 +1,11 @@
+import { IGrantUpdateBase } from "core/shared/types";
+import { Transaction } from "ethers";
 import { SignerOrProvider, TNetwork } from "../../../core/types";
 import { Attestation } from "../Attestation";
-import { Transaction } from "ethers";
 export interface _IGrantUpdate extends GrantUpdate {
 }
-export interface IGrantUpdate {
-    title: string;
-    text: string;
+export interface IGrantUpdate extends IGrantUpdateBase {
     type?: string;
-    proofOfWork?: string;
 }
 type IStatus = "verified";
 export interface IGrantUpdateStatus {

package/core/class/entities/GrantUpdate.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GrantUpdate = exports.GrantUpdateStatus = void 0;
+const consts_1 = require("../../../core/consts");
+const AllGapSchemas_1 = require("../AllGapSchemas");
 const Attestation_1 = require("../Attestation");
 const SchemaError_1 = require("../SchemaError");
-const AllGapSchemas_1 = require("../AllGapSchemas");
-const consts_1 = require("../../../core/consts");
 class GrantUpdateStatus extends Attestation_1.Attestation {
 }
 exports.GrantUpdateStatus = GrantUpdateStatus;

package/core/class/entities/Milestone.d.ts

@@ -1,5 +1,5 @@
 import { Transaction } from "ethers";
-import { MultiAttestPayload, SignerOrProvider, TNetwork } from "../../types";
+import { Hex, MultiAttestPayload, MultiRevokeArgs, SignerOrProvider, TNetwork } from "../../types";
 import { Attestation } from "../Attestation";
 import { GapSchema } from "../GapSchema";
 import { IMilestoneResponse } from "../karma-indexer/api/types";
@@ -12,6 +12,16 @@ export interface IMilestone {
     type?: string;
     priority?: number;
 }
+/**
+ * Milestone class represents a milestone that can be attested to one or multiple grants.
+ *
+ * It provides methods to:
+ * - Create, complete, approve, reject, and verify milestones
+ * - Attest a milestone to a single grant
+ * - Attest a milestone to multiple grants in a single transaction
+ * - Complete, approve, and verify milestones across multiple grants
+ * - Revoke multiple milestone attestations at once
+ */
 export declare class Milestone extends Attestation<IMilestone> implements IMilestone {
     title: string;
     startsAt?: number;
@@ -30,6 +40,16 @@ export declare class Milestone extends Attestation<IMilestone> implements IMiles
      * @param reason
      */
     approve(signer: SignerOrProvider, data?: IMilestoneCompleted, callback?: Function): Promise<void>;
+    /**
+     * Approves this milestone across multiple grants. If the milestones are not completed,
+     * it will throw an error.
+     * @param signer - The signer to use for attestation
+     * @param milestoneUIDs - Array of milestone UIDs to approve
+     * @param data - Optional approval data
+     * @param callback - Optional callback function for status updates
+     * @returns Promise with transaction and UIDs
+     */
+    approveMultipleGrants(signer: SignerOrProvider, milestoneUIDs: Hex[], data?: IMilestoneCompleted, callback?: Function): Promise<AttestationWithTx>;
     /**
      * Revokes the approved status of the milestone. If the milestone is not approved,
      * it will throw an error.
@@ -52,6 +72,16 @@ export declare class Milestone extends Attestation<IMilestone> implements IMiles
         tx: Transaction[];
         uids: `0x${string}`[];
     }>;
+    /**
+     * Revokes multiple milestone attestations at once.
+     * This method can be used to revoke multiple milestone attestations in a single transaction.
+     *
+     * @param signer - The signer to use for revocation
+     * @param attestationsToRevoke - Array of objects containing schemaId and uid of attestations to revoke
+     * @param callback - Optional callback function for status updates
+     * @returns Promise with transaction and UIDs of revoked attestations
+     */
+    revokeMultipleAttestations(signer: SignerOrProvider, attestationsToRevoke: MultiRevokeArgs[], callback?: Function): Promise<AttestationWithTx>;
     /**
      * Marks a milestone as completed. If the milestone is already completed,
      * it will throw an error.
@@ -59,6 +89,16 @@ export declare class Milestone extends Attestation<IMilestone> implements IMiles
      * @param reason
      */
     complete(signer: SignerOrProvider, data?: IMilestoneCompleted, callback?: Function): Promise<AttestationWithTx>;
+    /**
+     * Marks a milestone as completed across multiple grants. If the milestone is already completed,
+     * it will throw an error.
+     * @param signer - The signer to use for attestation
+     * @param grantIndices - Array of grant indices to attest this milestone to, or array of milestone UIDs
+     * @param data - Optional completion data
+     * @param callback - Optional callback function for status updates
+     * @returns Promise with transaction and UIDs
+     */
+    completeForMultipleGrants(signer: SignerOrProvider, grantIndicesOrMilestoneUIDs?: number[] | Hex[], data?: IMilestoneCompleted, callback?: Function): Promise<AttestationWithTx>;
     /**
      * Revokes the completed status of the milestone. If the milestone is not completed,
      * it will throw an error.
@@ -79,6 +119,26 @@ export declare class Milestone extends Attestation<IMilestone> implements IMiles
      * @param grantIdx
      */
     multiAttestPayload(currentPayload?: MultiAttestPayload, grantIdx?: number): Promise<[Attestation<unknown, GapSchema>, import("../../types").RawMultiAttestPayload][]>;
+    /**
+     * Creates the payload for a multi-attestation across multiple grants.
+     *
+     * This method allows for the same milestone to be attested to multiple grants
+     * in a single transaction.
+     *
+     * @param currentPayload - Current payload to append to
+     * @param grantIndices - Array of grant indices to attest this milestone to
+     * @returns The multi-attest payload with all grant attestations
+     */
+    multiGrantAttestPayload(currentPayload?: MultiAttestPayload, grantIndices?: number[]): Promise<[Attestation<unknown, GapSchema>, import("../../types").RawMultiAttestPayload][]>;
+    /**
+     * Attests this milestone to multiple grants in a single transaction.
+     *
+     * @param signer - The signer to use for attestation
+     * @param grantIndices - Array of grant indices to attest this milestone to, or array of grant UIDs
+     * @param callback - Optional callback function for status updates
+     * @returns Promise with transaction and UIDs
+     */
+    attestToMultipleGrants(signer: SignerOrProvider, grantIndices?: number[] | Hex[], callback?: Function): Promise<AttestationWithTx>;
     /**
      * @inheritdoc
      */
@@ -95,4 +155,14 @@ export declare class Milestone extends Attestation<IMilestone> implements IMiles
      * @param reason
      */
     verify(signer: SignerOrProvider, data?: IMilestoneCompleted, callback?: Function): Promise<AttestationWithTx>;
+    /**
+     * Verifies this milestone across multiple grants. If the milestones are not completed,
+     * it will throw an error.
+     * @param signer - The signer to use for attestation
+     * @param milestoneUIDs - Array of milestone UIDs to verify
+     * @param data - Optional verification data
+     * @param callback - Optional callback function for status updates
+     * @returns Promise with transaction and UIDs
+     */
+    verifyMultipleGrants(signer: SignerOrProvider, milestoneUIDs: Hex[], data?: IMilestoneCompleted, callback?: Function): Promise<AttestationWithTx>;
 }

package/core/class/entities/Milestone.js

@@ -7,6 +7,16 @@ const Attestation_1 = require("../Attestation");
 const SchemaError_1 = require("../SchemaError");
 const GapContract_1 = require("../contract/GapContract");
 const attestations_1 = require("../types/attestations");
+/**
+ * Milestone class represents a milestone that can be attested to one or multiple grants.
+ *
+ * It provides methods to:
+ * - Create, complete, approve, reject, and verify milestones
+ * - Attest a milestone to a single grant
+ * - Attest a milestone to multiple grants in a single transaction
+ * - Complete, approve, and verify milestones across multiple grants
+ * - Revoke multiple milestone attestations at once
+ */
 class Milestone extends Attestation_1.Attestation {
     constructor() {
         super(...arguments);
@@ -45,6 +55,66 @@ class Milestone extends Attestation_1.Attestation {
             recipient: this.recipient,
         });
     }
+    /**
+     * Approves this milestone across multiple grants. If the milestones are not completed,
+     * it will throw an error.
+     * @param signer - The signer to use for attestation
+     * @param milestoneUIDs - Array of milestone UIDs to approve
+     * @param data - Optional approval data
+     * @param callback - Optional callback function for status updates
+     * @returns Promise with transaction and UIDs
+     */
+    async approveMultipleGrants(signer, milestoneUIDs, data, callback) {
+        // Validate that all milestones are completed
+        if (!this.completed)
+            throw new SchemaError_1.AttestationError("ATTEST_ERROR", "Milestone is not completed");
+        const schema = this.schema.gap.findSchema("MilestoneCompleted");
+        if (this.schema.isJsonSchema()) {
+            schema.setValue("json", JSON.stringify({
+                type: "approved",
+                ...data,
+            }));
+        }
+        else {
+            schema.setValue("type", "approved");
+            schema.setValue("reason", data?.reason || "");
+            schema.setValue("proofOfWork", data?.proofOfWork || "");
+        }
+        // Create approval attestations for each milestone
+        const approvalPayloads = [];
+        for (const milestoneUID of milestoneUIDs) {
+            const approved = new attestations_1.MilestoneCompleted({
+                data: {
+                    type: "approved",
+                    ...data,
+                },
+                refUID: milestoneUID,
+                schema,
+                recipient: this.recipient,
+            });
+            // Add approval to the payload
+            approvalPayloads.push([
+                approved,
+                await approved.payloadFor(0), // Index doesn't matter for approval
+            ]);
+        }
+        // Attest all approvals at once
+        const result = await GapContract_1.GapContract.multiAttest(signer, approvalPayloads.map((p) => p[1]), callback);
+        // Save the first approval to this milestone instance
+        if (result.uids.length > 0) {
+            this.approved = new attestations_1.MilestoneCompleted({
+                data: {
+                    type: "approved",
+                    ...data,
+                },
+                refUID: milestoneUIDs[0],
+                uid: result.uids[0],
+                schema,
+                recipient: this.recipient,
+            });
+        }
+        return result;
+    }
     /**
      * Revokes the approved status of the milestone. If the milestone is not approved,
      * it will throw an error.
@@ -99,6 +169,42 @@ class Milestone extends Attestation_1.Attestation {
         ]);
         return { tx, uids };
     }
+    /**
+     * Revokes multiple milestone attestations at once.
+     * This method can be used to revoke multiple milestone attestations in a single transaction.
+     *
+     * @param signer - The signer to use for revocation
+     * @param attestationsToRevoke - Array of objects containing schemaId and uid of attestations to revoke
+     * @param callback - Optional callback function for status updates
+     * @returns Promise with transaction and UIDs of revoked attestations
+     */
+    async revokeMultipleAttestations(signer, attestationsToRevoke, callback) {
+        if (attestationsToRevoke.length === 0) {
+            throw new SchemaError_1.AttestationError("ATTEST_ERROR", "No attestations specified for revocation");
+        }
+        // Group the attestations by schema ID
+        const groupedAttestations = attestationsToRevoke.reduce((acc, { schemaId, uid }) => {
+            if (!acc[schemaId]) {
+                acc[schemaId] = [];
+            }
+            acc[schemaId].push(uid);
+            return acc;
+        }, {});
+        // Convert to the format expected by GapContract.multiRevoke
+        const revocationPayload = Object.entries(groupedAttestations).map(([schemaId, uids]) => ({
+            schema: schemaId,
+            data: uids.map((uid) => ({
+                uid,
+                value: 0n, // EAS contract requires a value field as BigInt
+            })),
+        }));
+        // Use GapContract.multiRevoke directly with the correct payload format
+        const result = await GapContract_1.GapContract.multiRevoke(signer, revocationPayload);
+        if (callback) {
+            callback("confirmed");
+        }
+        return result;
+    }
     /**
      * Marks a milestone as completed. If the milestone is already completed,
      * it will throw an error.
@@ -130,6 +236,87 @@ class Milestone extends Attestation_1.Attestation {
         });
         return { tx, uids };
     }
+    /**
+     * Marks a milestone as completed across multiple grants. If the milestone is already completed,
+     * it will throw an error.
+     * @param signer - The signer to use for attestation
+     * @param grantIndices - Array of grant indices to attest this milestone to, or array of milestone UIDs
+     * @param data - Optional completion data
+     * @param callback - Optional callback function for status updates
+     * @returns Promise with transaction and UIDs
+     */
+    async completeForMultipleGrants(signer, grantIndicesOrMilestoneUIDs = [0], data, callback) {
+        // Check if we're dealing with UIDs instead of indices
+        const isUids = grantIndicesOrMilestoneUIDs.length > 0 &&
+            typeof grantIndicesOrMilestoneUIDs[0] === "string";
+        let milestoneUIDs = [];
+        if (isUids) {
+            // We already have milestone UIDs
+            milestoneUIDs = grantIndicesOrMilestoneUIDs;
+        }
+        else {
+            // First attest the milestone to multiple grants if not already attested
+            const attestResult = await this.attestToMultipleGrants(signer, grantIndicesOrMilestoneUIDs, callback);
+            milestoneUIDs = attestResult.uids;
+        }
+        // Now complete the milestone for each attested milestone
+        const schema = this.schema.gap.findSchema("MilestoneCompleted");
+        if (this.schema.isJsonSchema()) {
+            schema.setValue("json", JSON.stringify({
+                type: "completed",
+                ...data,
+            }));
+        }
+        else {
+            schema.setValue("type", "completed");
+            schema.setValue("reason", data?.reason || "");
+            schema.setValue("proofOfWork", data?.proofOfWork || "");
+        }
+        // Create completion attestations for each milestone
+        const completionPayloads = [];
+        for (let i = 0; i < milestoneUIDs.length; i++) {
+            const milestoneUID = milestoneUIDs[i];
+            // Only set this.uid if we're dealing with indices and need to update the current milestone
+            if (!isUids) {
+                this.uid = milestoneUID; // Set the current UID to the milestone being completed
+            }
+            const completed = new attestations_1.MilestoneCompleted({
+                data: {
+                    type: "completed",
+                    ...data,
+                },
+                refUID: milestoneUID,
+                schema,
+                recipient: this.recipient,
+            });
+            // Add completed status to the payload
+            completionPayloads.push([completed, await completed.payloadFor(i)]);
+        }
+        // Attest all completions at once
+        const completionResult = await GapContract_1.GapContract.multiAttest(signer, completionPayloads.map((p) => p[1]), callback);
+        // Save the first completion to this milestone instance
+        if (completionResult.uids.length > 0 && !isUids) {
+            this.completed = new attestations_1.MilestoneCompleted({
+                data: {
+                    type: "completed",
+                    ...data,
+                },
+                refUID: milestoneUIDs[0],
+                uid: completionResult.uids[0],
+                schema,
+                recipient: this.recipient,
+            });
+        }
+        return isUids
+            ? completionResult // If we're using UIDs directly, just return completion result
+            : {
+                tx: [
+                    ...(milestoneUIDs.length ? [{ hash: "" }] : []),
+                    ...completionResult.tx,
+                ],
+                uids: [...milestoneUIDs, ...completionResult.uids],
+            };
+    }
     /**
      * Revokes the completed status of the milestone. If the milestone is not completed,
      * it will throw an error.
@@ -176,6 +363,92 @@ class Milestone extends Attestation_1.Attestation {
         }
         return payload.slice(currentPayload.length, payload.length);
     }
+    /**
+     * Creates the payload for a multi-attestation across multiple grants.
+     *
+     * This method allows for the same milestone to be attested to multiple grants
+     * in a single transaction.
+     *
+     * @param currentPayload - Current payload to append to
+     * @param grantIndices - Array of grant indices to attest this milestone to
+     * @returns The multi-attest payload with all grant attestations
+     */
+    async multiGrantAttestPayload(currentPayload = [], grantIndices = [0]) {
+        this.assertPayload();
+        const payload = [...currentPayload];
+        const milestoneIndices = [];
+        // Create milestone attestation for each grant
+        for (const grantIdx of grantIndices) {
+            const milestoneIdx = payload.push([this, await this.payloadFor(grantIdx)]) - 1;
+            milestoneIndices.push(milestoneIdx);
+        }
+        // Add completed status if exists for each milestone
+        if (this.completed) {
+            for (const milestoneIdx of milestoneIndices) {
+                payload.push([
+                    this.completed,
+                    await this.completed.payloadFor(milestoneIdx),
+                ]);
+            }
+        }
+        // Add verifications if exist for each milestone
+        if (this.verified.length > 0) {
+            for (const milestoneIdx of milestoneIndices) {
+                await Promise.all(this.verified.map(async (m) => {
+                    const payloadForMilestone = await m.payloadFor(milestoneIdx);
+                    if (Array.isArray(payloadForMilestone)) {
+                        payloadForMilestone.forEach((item) => payload.push(item));
+                    }
+                }));
+            }
+        }
+        return payload.slice(currentPayload.length, payload.length);
+    }
+    /**
+     * Attests this milestone to multiple grants in a single transaction.
+     *
+     * @param signer - The signer to use for attestation
+     * @param grantIndices - Array of grant indices to attest this milestone to, or array of grant UIDs
+     * @param callback - Optional callback function for status updates
+     * @returns Promise with transaction and UIDs
+     */
+    async attestToMultipleGrants(signer, grantIndices = [0], callback) {
+        this.assertPayload();
+        // Check if we're dealing with Hex UIDs instead of indices
+        const isUids = grantIndices.length > 0 && typeof grantIndices[0] === "string";
+        if (isUids) {
+            // Direct approach - create individual milestone instances for each grant UID
+            const grantUIDs = grantIndices;
+            const allPayloads = [];
+            for (const grantUID of grantUIDs) {
+                // Create a new milestone for each grant with direct reference
+                const grantMilestone = new Milestone({
+                    schema: this.schema,
+                    recipient: this.recipient,
+                    data: this.data,
+                    refUID: grantUID,
+                });
+                // Generate payload for this grant
+                const payload = await grantMilestone.multiAttestPayload();
+                // Add each item from payload to allPayloads
+                payload.forEach((item) => allPayloads.push(item));
+            }
+            // Attest all milestones in a single transaction
+            const result = await GapContract_1.GapContract.multiAttest(signer, allPayloads.map((p) => p[1]), callback);
+            return result;
+        }
+        else {
+            // Original implementation using grantIndices
+            const payload = await this.multiGrantAttestPayload([], grantIndices);
+            const { uids, tx } = await GapContract_1.GapContract.multiAttest(signer, payload.map((p) => p[1]), callback);
+            if (Array.isArray(uids)) {
+                uids.forEach((uid, index) => {
+                    payload[index][0].uid = uid;
+                });
+            }
+            return { tx, uids };
+        }
+    }
     /**
      * @inheritdoc
      */
@@ -318,5 +591,67 @@ class Milestone extends Attestation_1.Attestation {
         }));
         return { tx, uids };
     }
+    /**
+     * Verifies this milestone across multiple grants. If the milestones are not completed,
+     * it will throw an error.
+     * @param signer - The signer to use for attestation
+     * @param milestoneUIDs - Array of milestone UIDs to verify
+     * @param data - Optional verification data
+     * @param callback - Optional callback function for status updates
+     * @returns Promise with transaction and UIDs
+     */
+    async verifyMultipleGrants(signer, milestoneUIDs, data, callback) {
+        // Validate that all milestones are completed
+        if (!this.completed)
+            throw new SchemaError_1.AttestationError("ATTEST_ERROR", "Milestone is not completed");
+        const schema = this.schema.gap.findSchema("MilestoneCompleted");
+        if (this.schema.isJsonSchema()) {
+            schema.setValue("json", JSON.stringify({
+                type: "verified",
+                ...data,
+            }));
+        }
+        else {
+            schema.setValue("type", "verified");
+            schema.setValue("reason", data?.reason || "");
+            schema.setValue("proofOfWork", data?.proofOfWork || "");
+        }
+        // Create verification attestations for each milestone
+        const verificationPayloads = [];
+        for (const milestoneUID of milestoneUIDs) {
+            const verified = new attestations_1.MilestoneCompleted({
+                data: {
+                    type: "verified",
+                    ...data,
+                },
+                refUID: milestoneUID,
+                schema,
+                recipient: this.recipient,
+            });
+            // Add verification to the payload
+            verificationPayloads.push([
+                verified,
+                await verified.payloadFor(0), // Index doesn't matter for verification
+            ]);
+        }
+        // Attest all verifications at once
+        const result = await GapContract_1.GapContract.multiAttest(signer, verificationPayloads.map((p) => p[1]), callback);
+        // Save the verifications to this milestone instance
+        if (result.uids.length > 0) {
+            for (let i = 0; i < result.uids.length; i++) {
+                this.verified.push(new attestations_1.MilestoneCompleted({
+                    data: {
+                        type: "verified",
+                        ...data,
+                    },
+                    refUID: milestoneUIDs[i],
+                    uid: result.uids[i],
+                    schema,
+                    recipient: this.recipient,
+                }));
+            }
+        }
+        return result;
+    }
 }
 exports.Milestone = Milestone;

package/core/class/entities/Project.js

@@ -206,13 +206,14 @@ class Project extends Attestation_1.Attestation {
         this.members.splice(0, this.members.length);
     }
     static from(attestations, network) {
+        const allSchemas = new AllGapSchemas_1.AllGapSchemas();
         return attestations.map((attestation) => {
             const project = new Project({
                 ...attestation,
                 data: {
                     project: true,
                 },
-                schema: new AllGapSchemas_1.AllGapSchemas().findSchema("Project", consts_1.chainIdToNetwork[attestation.chainID]),
+                schema: allSchemas.findSchema("Project", consts_1.chainIdToNetwork[attestation.chainID]),
                 chainID: attestation.chainID,
             });
             if (attestation.details) {
@@ -222,7 +223,7 @@ class Project extends Attestation_1.Attestation {
                     data: {
                         ...details.data,
                     },
-                    schema: new AllGapSchemas_1.AllGapSchemas().findSchema("ProjectDetails", consts_1.chainIdToNetwork[attestation.chainID]),
+                    schema: allSchemas.findSchema("ProjectDetails", consts_1.chainIdToNetwork[attestation.chainID]),
                     chainID: attestation.chainID,
                 });
                 project.details.links = details.data.links || [];
@@ -241,7 +242,7 @@ class Project extends Attestation_1.Attestation {
                         data: {
                             memberOf: true,
                         },
-                        schema: new AllGapSchemas_1.AllGapSchemas().findSchema("MemberOf", consts_1.chainIdToNetwork[attestation.chainID]),
+                        schema: allSchemas.findSchema("MemberOf", consts_1.chainIdToNetwork[attestation.chainID]),
                         chainID: attestation.chainID,
                     });
                     if (m.details) {
@@ -251,7 +252,7 @@ class Project extends Attestation_1.Attestation {
                             data: {
                                 ...details.data,
                             },
-                            schema: new AllGapSchemas_1.AllGapSchemas().findSchema("MemberDetails", consts_1.chainIdToNetwork[attestation.chainID]),
+                            schema: allSchemas.findSchema("MemberDetails", consts_1.chainIdToNetwork[attestation.chainID]),
                             chainID: attestation.chainID,
                         });
                     }
@@ -280,7 +281,7 @@ class Project extends Attestation_1.Attestation {
                         data: {
                             ...pi.data,
                         },
-                        schema: new AllGapSchemas_1.AllGapSchemas().findSchema("ProjectDetails", consts_1.chainIdToNetwork[attestation.chainID]),
+                        schema: allSchemas.findSchema("ProjectDetails", consts_1.chainIdToNetwork[attestation.chainID]),
                         chainID: attestation.chainID,
                     });
                     return endorsement;

package/core/class/entities/Track.d.ts

@@ -0,0 +1,16 @@
+import { TNetwork } from "core/types";
+import { ITrackResponse } from "../karma-indexer/api/types";
+export declare class Track {
+    id: string;
+    name: string;
+    description?: string;
+    communityUID: string;
+    isArchived: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+    programId?: string;
+    isActive?: boolean;
+    network: TNetwork;
+    constructor(data: any, network: TNetwork);
+    static from(data: ITrackResponse[], network: TNetwork): Track[];
+}

package/core/class/entities/Track.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Track = void 0;
+class Track {
+    constructor(data, network) {
+        this.id = data.id;
+        this.name = data.name;
+        this.description = data.description;
+        this.communityUID = data.communityUID;
+        this.isArchived = data.isArchived ?? false;
+        this.createdAt = new Date(data.createdAt);
+        this.updatedAt = new Date(data.updatedAt);
+        this.programId = data.programId;
+        this.isActive = data.isActive;
+        this.network = network;
+    }
+    static from(data, network) {
+        return data.map((item) => new Track(item, network));
+    }
+}
+exports.Track = Track;

package/core/class/entities/index.d.ts

@@ -7,3 +7,4 @@ export * from "./GrantUpdate";
 export * from "./ProjectUpdate";
 export * from "./ProjectPointer";
 export * from "./ContributorProfile";
+export * from "./Track";

package/core/class/entities/index.js

@@ -23,3 +23,4 @@ __exportStar(require("./GrantUpdate"), exports);
 __exportStar(require("./ProjectUpdate"), exports);
 __exportStar(require("./ProjectPointer"), exports);
 __exportStar(require("./ContributorProfile"), exports);
+__exportStar(require("./Track"), exports);

package/core/class/karma-indexer/GapIndexerClient.d.ts

@@ -2,7 +2,7 @@ import { TSchemaName, IAttestation, Hex } from "core/types";
 import { Attestation } from "../Attestation";
 import { GapSchema } from "../GapSchema";
 import { Fetcher } from "../Fetcher";
-import { Community, Project, Grant, Milestone, MemberOf } from "../entities";
+import { Community, Project, Grant, Milestone, MemberOf, Track } from "../entities";
 import { Grantee } from "../types/attestations";
 import { ICommunityAdminsResponse } from "./api/types";
 import { ProjectMilestone } from "../entities/ProjectMilestone";
@@ -40,4 +40,27 @@ export declare class GapIndexerClient extends Fetcher {
     milestonesOf(grants: Grant[]): Promise<Milestone[]>;
     membersOf(projects: Project[]): Promise<MemberOf[]>;
     slugExists(slug: string): Promise<boolean>;
+    /**
+     * Track related methods
+     */
+    getTracks(communityUID: string, includeArchived?: boolean): Promise<Track[]>;
+    getTrackById(id: string): Promise<Track>;
+    createTrack(trackData: {
+        name: string;
+        description?: string;
+        communityUID: string;
+    }): Promise<Track>;
+    updateTrack(id: string, trackData: {
+        name?: string;
+        description?: string;
+        communityUID?: string;
+    }): Promise<Track>;
+    archiveTrack(id: string): Promise<Track>;
+    assignTracksToProgram(programId: string, trackIds: string[]): Promise<any[]>;
+    unassignTrackFromProgram(programId: string, trackId: string): Promise<any>;
+    getTracksForProgram(programId: string): Promise<Track[]>;
+    getTracksForProject(projectId: string, programId: string, activeOnly?: boolean): Promise<Track[]>;
+    assignTracksToProject(projectId: string, programId: string, trackIds: string[]): Promise<any[]>;
+    unassignTracksFromProject(projectId: string, programId: string, trackIds: string[]): Promise<any[]>;
+    getProjectsByTrack(communityId: string, programId: string, trackId?: string): Promise<any[]>;
 }

package/core/class/karma-indexer/GapIndexerClient.js

@@ -152,5 +152,56 @@ class GapIndexerClient extends Fetcher_1.Fetcher {
     async slugExists(slug) {
         return await this.apiClient.slugExists(slug);
     }
+    /**
+     * Track related methods
+     */
+    async getTracks(communityUID, includeArchived = false) {
+        const { data } = await this.apiClient.getTracks(communityUID, includeArchived);
+        return entities_1.Track.from(data, this.gap.network);
+    }
+    async getTrackById(id) {
+        const { data } = await this.apiClient.getTrackById(id);
+        return entities_1.Track.from([data], this.gap.network)[0];
+    }
+    async createTrack(trackData) {
+        const { data } = await this.apiClient.createTrack(trackData);
+        return entities_1.Track.from([data], this.gap.network)[0];
+    }
+    async updateTrack(id, trackData) {
+        const { data } = await this.apiClient.updateTrack(id, trackData);
+        return entities_1.Track.from([data], this.gap.network)[0];
+    }
+    async archiveTrack(id) {
+        const { data } = await this.apiClient.archiveTrack(id);
+        return entities_1.Track.from([data], this.gap.network)[0];
+    }
+    async assignTracksToProgram(programId, trackIds) {
+        const { data } = await this.apiClient.assignTracksToProgram(programId, trackIds);
+        return data;
+    }
+    async unassignTrackFromProgram(programId, trackId) {
+        const { data } = await this.apiClient.unassignTrackFromProgram(programId, trackId);
+        return data;
+    }
+    async getTracksForProgram(programId) {
+        const { data } = await this.apiClient.getTracksForProgram(programId);
+        return entities_1.Track.from(data, this.gap.network);
+    }
+    async getTracksForProject(projectId, programId, activeOnly = true) {
+        const { data } = await this.apiClient.getTracksForProject(projectId, programId, activeOnly);
+        return entities_1.Track.from(data, this.gap.network);
+    }
+    async assignTracksToProject(projectId, programId, trackIds) {
+        const { data } = await this.apiClient.assignTracksToProject(projectId, programId, trackIds);
+        return data;
+    }
+    async unassignTracksFromProject(projectId, programId, trackIds) {
+        const { data } = await this.apiClient.unassignTracksFromProject(projectId, programId, trackIds);
+        return data;
+    }
+    async getProjectsByTrack(communityId, programId, trackId) {
+        const { data } = await this.apiClient.getProjectsByTrack(communityId, programId, trackId);
+        return data;
+    }
 }
 exports.GapIndexerClient = GapIndexerClient;

package/core/class/karma-indexer/api/GapIndexerApi.d.ts

@@ -1,5 +1,5 @@
 import { AxiosGQL } from "../../GraphQL/AxiosGQL";
-import { Hex, IAttestationResponse, ICommunityResponse, ICommunityAdminsResponse, IGrantResponse, IProjectResponse, ISearchResponse, IProjectMilestoneResponse } from "./types";
+import { Hex, IAttestationResponse, ICommunityResponse, ICommunityAdminsResponse, IGrantResponse, IProjectResponse, ISearchResponse, IProjectMilestoneResponse, ITrackResponse, ITrackAssignmentResponse, IProjectTrackResponse } from "./types";
 export declare class GapIndexerApi extends AxiosGQL {
     constructor(url: string);
     attestation(uid: Hex): Promise<import("axios").AxiosResponse<IAttestationResponse, any>>;
@@ -47,4 +47,27 @@ export declare class GapIndexerApi extends AxiosGQL {
      */
     milestonesOf(uid: Hex): Promise<import("axios").AxiosResponse<any, any>>;
     slugExists(slug: string): Promise<boolean>;
+    /**
+     * Tracks
+     */
+    getTracks(communityUID: string, includeArchived?: boolean): Promise<import("axios").AxiosResponse<ITrackResponse[], any>>;
+    getTrackById(id: string): Promise<import("axios").AxiosResponse<ITrackResponse, any>>;
+    createTrack(data: {
+        name: string;
+        description?: string;
+        communityUID: string;
+    }): Promise<import("axios").AxiosResponse<ITrackResponse, any>>;
+    updateTrack(id: string, data: {
+        name?: string;
+        description?: string;
+        communityUID?: string;
+    }): Promise<import("axios").AxiosResponse<ITrackResponse, any>>;
+    archiveTrack(id: string): Promise<import("axios").AxiosResponse<ITrackResponse, any>>;
+    assignTracksToProgram(programId: string, trackIds: string[]): Promise<import("axios").AxiosResponse<ITrackAssignmentResponse[], any>>;
+    unassignTrackFromProgram(programId: string, trackId: string): Promise<import("axios").AxiosResponse<ITrackAssignmentResponse, any>>;
+    getTracksForProgram(programId: string): Promise<import("axios").AxiosResponse<ITrackResponse[], any>>;
+    getTracksForProject(projectId: string, programId: string, activeOnly?: boolean): Promise<import("axios").AxiosResponse<ITrackResponse[], any>>;
+    assignTracksToProject(projectId: string, programId: string, trackIds: string[]): Promise<import("axios").AxiosResponse<any[], any>>;
+    unassignTracksFromProject(projectId: string, programId: string, trackIds: string[]): Promise<import("axios").AxiosResponse<any[], any>>;
+    getProjectsByTrack(communityId: string, programId: string, trackId?: string): Promise<import("axios").AxiosResponse<IProjectTrackResponse[], any>>;
 }

package/core/class/karma-indexer/api/GapIndexerApi.js

@@ -28,6 +28,7 @@ const Endpoints = {
     },
     project: {
         all: () => "/projects",
+        checkSlug: (slug) => `/projects/check-slug/${slug}`,
         byUidOrSlug: (uidOrSlug) => `/projects/${uidOrSlug}`,
         grants: (uidOrSlug) => `/projects/${uidOrSlug}/grants`,
         milestones: (uidOrSlug) => `/projects/${uidOrSlug}/milestones`,
@@ -36,6 +37,26 @@ const Endpoints = {
     search: {
         all: () => "/search",
     },
+    tracks: {
+        all: () => "/tracks",
+        byId: (id) => `/tracks/${id}`,
+        byCommunity: (communityUID, includeArchived = false) => `/tracks?communityUID=${communityUID}${includeArchived ? "&includeArchived=true" : ""}`,
+    },
+    programs: {
+        tracks: {
+            all: (programId) => `/programs/${programId}/tracks`,
+            assign: (programId) => `/programs/${programId}/tracks`,
+            remove: (programId, trackId) => `/programs/${programId}/tracks/${trackId}`,
+        },
+    },
+    projectTracks: {
+        all: (projectId, programId, activeOnly = true) => `/programs/${programId}/projects/${projectId}/tracks${activeOnly ? "" : "?activeOnly=false"}`,
+        assign: (projectId) => `/projects/${projectId}/tracks`,
+        remove: (programId, projectId) => `/programs/${programId}/project/${projectId}/tracks`,
+    },
+    community: {
+        programProjects: (communityId, programId, trackId) => `/community/${communityId}/program/${programId}/projects${trackId ? `?trackId=${trackId}` : ""}`,
+    },
 };
 class GapIndexerApi extends AxiosGQL_1.AxiosGQL {
     constructor(url) {
@@ -173,12 +194,63 @@ class GapIndexerApi extends AxiosGQL_1.AxiosGQL {
     }
     async slugExists(slug) {
         try {
-            await this.client.get(Endpoints.project.byUidOrSlug(slug));
+            await this.client.get(Endpoints.project.checkSlug(slug));
             return true;
         }
         catch (err) {
             return false;
         }
     }
+    /**
+     * Tracks
+     */
+    async getTracks(communityUID, includeArchived = false) {
+        const response = await this.client.get(Endpoints.tracks.byCommunity(communityUID, includeArchived));
+        return response;
+    }
+    async getTrackById(id) {
+        const response = await this.client.get(Endpoints.tracks.byId(id));
+        return response;
+    }
+    async createTrack(data) {
+        const response = await this.client.post(Endpoints.tracks.all(), data);
+        return response;
+    }
+    async updateTrack(id, data) {
+        const response = await this.client.put(Endpoints.tracks.byId(id), data);
+        return response;
+    }
+    async archiveTrack(id) {
+        const response = await this.client.delete(Endpoints.tracks.byId(id));
+        return response;
+    }
+    async assignTracksToProgram(programId, trackIds) {
+        const response = await this.client.post(Endpoints.programs.tracks.assign(programId), { trackIds });
+        return response;
+    }
+    async unassignTrackFromProgram(programId, trackId) {
+        const response = await this.client.delete(Endpoints.programs.tracks.remove(programId, trackId));
+        return response;
+    }
+    async getTracksForProgram(programId) {
+        const response = await this.client.get(Endpoints.programs.tracks.all(programId));
+        return response;
+    }
+    async getTracksForProject(projectId, programId, activeOnly = true) {
+        const response = await this.client.get(Endpoints.projectTracks.all(projectId, programId, activeOnly));
+        return response;
+    }
+    async assignTracksToProject(projectId, programId, trackIds) {
+        const response = await this.client.post(Endpoints.projectTracks.assign(projectId), { trackIds, programId });
+        return response;
+    }
+    async unassignTracksFromProject(projectId, programId, trackIds) {
+        const response = await this.client.delete(Endpoints.projectTracks.remove(programId, projectId), { data: { trackIds } });
+        return response;
+    }
+    async getProjectsByTrack(communityId, programId, trackId) {
+        const response = await this.client.get(Endpoints.community.programProjects(communityId, programId, trackId));
+        return response;
+    }
 }
 exports.GapIndexerApi = GapIndexerApi;

package/core/class/karma-indexer/api/types.d.ts

@@ -1,3 +1,4 @@
+import { IGrantUpdateBase } from "core/shared/types";
 export type Hex = `0x${string}`;
 export type JSONStr = string;
 export type ExternalLink = {
@@ -63,11 +64,8 @@ export interface IGrantUpdateStatus extends IAttestationResponse {
     };
 }
 export interface IGrantUpdate extends IAttestationResponse {
-    data: {
-        text: string;
-        title: string;
+    data: IGrantUpdateBase & {
         type: "grant-update";
-        proofOfWork?: string;
     };
     verified?: IGrantUpdateStatus[];
 }
@@ -140,6 +138,7 @@ export interface IGrantDetails extends IAttestationResponse {
         programId?: string;
         type: "grant-details";
         fundUsage?: string;
+        selectedTrackIds?: string[];
     };
 }
 export interface IGrantResponse extends IAttestationResponse {
@@ -150,7 +149,7 @@ export interface IGrantResponse extends IAttestationResponse {
     details?: IGrantDetails;
     milestones: IMilestoneResponse[];
     completed?: IGrantUpdate;
-    project: ISummaryProject;
+    project: IProjectResponse;
     updates: IGrantUpdate[];
     community: ICommunityResponse;
     members: Hex[];
@@ -263,4 +262,34 @@ export interface ISearchResponse {
     projects: IProjectResponse[];
     communities: ICommunityResponse[];
 }
+export interface ITrackResponse {
+    id: string;
+    name: string;
+    description?: string;
+    communityUID: string;
+    isArchived: boolean;
+    createdAt: string;
+    updatedAt: string;
+    programId?: string;
+    isActive?: boolean;
+    chainID?: number;
+}
+export interface ITrackAssignmentResponse {
+    id: string;
+    programId: string;
+    chainID: number;
+    trackId: string;
+    track: ITrackResponse;
+}
+export interface IProjectTrackResponse {
+    projectUID: string;
+    chainID: number;
+    programId: string;
+    track: ITrackResponse;
+    project: {
+        uid: string;
+        chainID: number;
+        details: any;
+    };
+}
 export {};

package/core/class/types/attestations.d.ts

@@ -45,6 +45,7 @@ export interface IGrantDetails {
     startDate?: number;
     programId?: string;
     fundUsage?: string;
+    selectedTrackIds?: string[];
 }
 export declare class GrantDetails extends Attestation<IGrantDetails> implements IGrantDetails {
     title: string;
@@ -60,6 +61,7 @@ export declare class GrantDetails extends Attestation<IGrantDetails> implements
     type: string;
     startDate?: number;
     fundUsage?: string;
+    selectedTrackIds?: string[];
 }
 export interface IGrantRound {
     name: string;

package/core/consts.d.ts

@@ -13,6 +13,7 @@ export declare const chainIdToNetwork: {
     42220: string;
     1328: string;
     1329: string;
+    1135: string;
 };
 export declare const nullRef = "0x0000000000000000000000000000000000000000000000000000000000000000";
 export declare const nullResolver = "0x0000000000000000000000000000000000000000";

package/core/consts.js

@@ -26,6 +26,7 @@ exports.chainIdToNetwork = {
     42220: "celo",
     1328: "sei-testnet",
     1329: "sei",
+    1135: "lisk",
 };
 exports.nullRef = "0x0000000000000000000000000000000000000000000000000000000000000000";
 // TODO: Remove null resolver and change usage to zero address
@@ -396,6 +397,34 @@ exports.Networks = {
             ContributorProfile: "0x"
         },
     },
+    lisk: {
+        chainId: 1135,
+        url: "https://arbitrum.easscan.org/graphql",
+        rpcUrl: "https://arb-mainnet.g.alchemy.com/v2/okcKBSKXvLuSCbas6QWGvKuh-IcHHSOr",
+        contracts: {
+            eas: "0x4200000000000000000000000000000000000021",
+            schema: "0x4200000000000000000000000000000000000020",
+            multicall: "0x28BE0b0515be8BB8822aF1467A6613795E74717b",
+            projectResolver: "0x6dC1D6b864e8BEf815806f9e4677123496e12026",
+            communityResolver: "0xfddb660F2F1C27d219372210745BB9f73431856E",
+            donations: "0x28BE0b0515be8BB8822aF1467A6613795E74717b",
+            airdropNFT: null,
+        },
+        schemas: {
+            Community: "0x3c2231024f4f17f3718b5bd9ed9ff29cc323dea5449f9ceba11a9888bfbdd0e1",
+            Details: "0x16bfe4783b7a9c743c401222c56a07ecb77ed42afc84b61ff1f62f5936c0b9d7",
+            Grant: "0xea02ab33f9f4c92ba02c9bb21614b7410b98c940a0d8eb8ad3a20204d8b4bda5",
+            GrantVerified: "0xd88faddf8df50a07a4130fbe2131354831261440b2ca695c4e9b8f2ca9985346",
+            MemberOf: "0x5f430aec9d04f0dcb3729775c5dfe10752e436469a7607f8c64ae44ef996e477",
+            MilestoneApproved: "0xd88faddf8df50a07a4130fbe2131354831261440b2ca695c4e9b8f2ca9985346",
+            MilestoneCompleted: "0xd88faddf8df50a07a4130fbe2131354831261440b2ca695c4e9b8f2ca9985346",
+            GrantUpdateStatus: "0xd88faddf8df50a07a4130fbe2131354831261440b2ca695c4e9b8f2ca9985346",
+            Project: "0xf3f753b41e04d1052b5a5ec7624d1dfdb6c2da288a985120e477ddbcac071022",
+            ProjectUpdateStatus: "0xd88faddf8df50a07a4130fbe2131354831261440b2ca695c4e9b8f2ca9985346",
+            ProjectMilestoneStatus: "0xd88faddf8df50a07a4130fbe2131354831261440b2ca695c4e9b8f2ca9985346",
+            ContributorProfile: "0x80f0701853e862d920f87e8ae5b359a1625ad417a9523af2ed12bc3504b04088"
+        },
+    },
 };
 const DetailsSchema = [{ type: "string", name: "json", value: null }];
 /**

package/core/shared/types.d.ts

@@ -0,0 +1,6 @@
+export interface IGrantUpdateBase {
+    title: string;
+    text: string;
+    proofOfWork?: string;
+    completionPercentage?: string;
+}

package/core/shared/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/core/types.d.ts

@@ -29,8 +29,8 @@ export interface AttestArgs<T = unknown> {
 }
 export type TSchemaName = "Community" | "CommunityDetails" | "Grant" | "GrantDetails" | "GrantVerified" | "MemberOf" | "MemberDetails" | "Milestone" | "MilestoneCompleted" | "MilestoneApproved" | "Project" | "ProjectDetails" | "Details" | "ProjectImpact" | "ProjectUpdate" | "ProjectUpdateStatus" | "ProjectPointer" | "GrantUpdate" | "GrantUpdateStatus" | "ProjectEndorsement" | "ProjectMilestone" | "ProjectMilestoneStatus" | "ContributorProfile";
 export type TResolvedSchemaNames = "Community" | "Grant" | "GrantVerified" | "MemberOf" | "MilestoneCompleted" | "MilestoneApproved" | "Project" | "Details" | "ProjectUpdateStatus" | "GrantUpdateStatus" | "ProjectUpdateStatus" | "ProjectMilestoneStatus" | "ContributorProfile";
-export type TExternalLink = "twitter" | "github" | "website" | "linkedin" | "discord";
-export type TNetwork = "optimism" | "celo" | "optimism-sepolia" | "arbitrum" | "sepolia" | "sei" | "sei-testnet" | "base-sepolia";
+export type TExternalLink = "twitter" | "github" | "website" | "linkedin" | "discord" | "pitchDeck" | "demoVideo" | "farcaster";
+export type TNetwork = "optimism" | "celo" | "optimism-sepolia" | "arbitrum" | "sepolia" | "sei" | "sei-testnet" | "base-sepolia" | "lisk";
 /**
  * Generic GAP Facade interface.
  * This supplies the GAP class with the necessary properties.

package/package.json

@@ -3,7 +3,7 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "0.4.9",
+    "version": "0.4.12",
     "description": "Simple and easy interface between EAS and Karma GAP.",
     "main": "./index.js",
     "author": "KarmaHQ",
@@ -16,6 +16,8 @@
     "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",
         "publish-npm": "npm version patch && tsc && cd .dist && npm publish --scope=@show-karma/karma-gap-sdk --access public"
     },
     "dependencies": {