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

package/core/abi/AlloCaller.json

@@ -0,0 +1,117 @@
+[
+    {
+        "inputs": [
+            {
+                "internalType": "bytes32",
+                "name": "_profileId",
+                "type": "bytes32"
+            },
+            {
+                "internalType": "address",
+                "name": "_strategy",
+                "type": "address"
+            },
+            {
+                "internalType": "bytes",
+                "name": "_initStrategyData",
+                "type": "bytes"
+            },
+            {
+                "internalType": "address",
+                "name": "_token",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "_amount",
+                "type": "uint256"
+            },
+            {
+                "components": [
+                    {
+                        "internalType": "uint256",
+                        "name": "protocol",
+                        "type": "uint256"
+                    },
+                    {
+                        "internalType": "string",
+                        "name": "pointer",
+                        "type": "string"
+                    }
+                ],
+                "internalType": "struct IAllo.Metadata",
+                "name": "_metadata",
+                "type": "tuple"
+            },
+            {
+                "internalType": "address[]",
+                "name": "_managers",
+                "type": "address[]"
+            }
+        ],
+        "name": "createPool",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "poolId",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "payable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint256",
+                "name": "_poolId",
+                "type": "uint256"
+            },
+            {
+                "components": [
+                    {
+                        "internalType": "uint256",
+                        "name": "protocol",
+                        "type": "uint256"
+                    },
+                    {
+                        "internalType": "string",
+                        "name": "pointer",
+                        "type": "string"
+                    }
+                ],
+                "internalType": "struct IAllo.Metadata",
+                "name": "_metadata",
+                "type": "tuple"
+            }
+        ],
+        "name": "updatePoolMetadata",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "_alloAddress",
+                "type": "address"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "constructor"
+    },
+    {
+        "inputs": [],
+        "name": "allo",
+        "outputs": [
+            {
+                "internalType": "contract IAllo",
+                "name": "",
+                "type": "address"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    }
+]

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

@@ -30,7 +30,7 @@ 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" | "pitchDeck" | "demoVideo" | "farcaster";
-export type TNetwork = "optimism" | "celo" | "optimism-sepolia" | "arbitrum" | "sepolia" | "sei" | "sei-testnet" | "base-sepolia";
+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.11",
+    "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": {