@show-karma/karma-gap-sdk 0.1.41 → 0.2.2

package/core/class/Attestation.d.ts

@@ -134,10 +134,10 @@ export declare class Attestation<T = unknown, S extends Schema = GapSchema> impl
      * @param refIdx
      * @returns [Encoded payload, Raw payload]
      */
-    payloadFor(refIdx: number): {
+    payloadFor(refIdx: number): Promise<{
         payload: MultiAttestData;
         raw: MultiAttestData;
-    };
+    }>;
     /**
      * Returns an Attestation instance from a JSON decoded schema.
      * @param data

package/core/class/Attestation.js

@@ -4,6 +4,7 @@ exports.Attestation = void 0;
 const Schema_1 = require("./Schema");
 const SchemaError_1 = require("./SchemaError");
 const get_date_1 = require("../utils/get-date");
+const GAP_1 = require("./GAP");
 const consts_1 = require("../consts");
 const GapContract_1 = require("./contract/GapContract");
 /**
@@ -184,8 +185,16 @@ class Attestation {
      * @param refIdx
      * @returns [Encoded payload, Raw payload]
      */
-    payloadFor(refIdx) {
+    async payloadFor(refIdx) {
         this.assertPayload();
+        if (this.schema.isJsonSchema()) {
+            const { remoteClient } = GAP_1.GAP;
+            if (remoteClient) {
+                const cid = await remoteClient.save(this._data, this.schema.name);
+                const encodedData = remoteClient.encode(cid);
+                this.schema.setValue('json', JSON.stringify(encodedData));
+            }
+        }
         const payload = (encode = true) => ({
             uid: consts_1.nullRef,
             refIdx,

package/core/class/AttestationIPFS.d.ts

@@ -0,0 +1,7 @@
+import { IPFS } from './IPFS/IPFS';
+export declare class AttestationIPFS extends IPFS {
+    encode(data: string, storageType: number): {
+        ipfsHash: string;
+        type: number;
+    };
+}

package/core/class/AttestationIPFS.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttestationIPFS = void 0;
+const IPFS_1 = require("./IPFS/IPFS");
+class AttestationIPFS extends IPFS_1.IPFS {
+    encode(data, storageType) {
+        return { ipfsHash: data, type: storageType };
+    }
+}
+exports.AttestationIPFS = AttestationIPFS;

package/core/class/GAP.d.ts

@@ -1,7 +1,8 @@
-import { AttestArgs, Facade, SchemaInterface, TNetwork, TSchemaName, SignerOrProvider } from "../types";
-import { GapSchema } from "./GapSchema";
-import { ethers } from "ethers";
-import { Fetcher } from "./Fetcher";
+import { AttestArgs, Facade, SchemaInterface, TNetwork, TSchemaName, SignerOrProvider } from '../types';
+import { GapSchema } from './GapSchema';
+import { ethers } from 'ethers';
+import { Fetcher } from './Fetcher';
+import { RemoteStorage } from './remote-storage/RemoteStorage';
 interface GAPArgs {
     network: TNetwork;
     globalSchemas?: boolean;
@@ -88,6 +89,12 @@ interface GAPArgs {
          */
         useGasless?: boolean;
     };
+    /**
+     * Defines a remote storage client to be used to store data.
+     * If defined, all the details data from an attestation will
+     * be stored in the remote storage, e.g. IPFS.
+     */
+    remoteStorage?: RemoteStorage;
 }
 /**
  * GAP SDK Facade.
@@ -146,12 +153,13 @@ interface GAPArgs {
  */
 export declare class GAP extends Facade {
     private static client;
+    private static remoteStorage?;
     readonly fetch: Fetcher;
     readonly network: TNetwork;
     private _schemas;
     private static _gelatoOpts;
     constructor(args: GAPArgs);
-    private assert;
+    private assertGelatoOpts;
     /**
      * Creates the attestation payload using a specific schema.
      * @param from
@@ -206,7 +214,8 @@ export declare class GAP extends Facade {
      * In case of true, the transactions will be sent through [Gelato](https://gelato.network)
      * and an API key is needed.
      */
-    static get gelatoOpts(): GAPArgs["gelatoOpts"];
+    static get gelatoOpts(): GAPArgs['gelatoOpts'];
     static set useGasLess(useGasLess: boolean);
+    static get remoteClient(): RemoteStorage<unknown>;
 }
 export {};

package/core/class/GAP.js

@@ -79,13 +79,13 @@ class GAP extends types_1.Facade {
         this.generateSlug = async (text) => {
             let slug = text
                 .toLowerCase()
-                .replace(/ /g, "-")
-                .replace(/[^\w-]+/g, "");
+                .replace(/ /g, '-')
+                .replace(/[^\w-]+/g, '');
             const slugExists = await this.fetch.slugExists(slug);
             if (slugExists) {
-                const parts = slug.split("-");
+                const parts = slug.split('-');
                 const counter = parts.pop();
-                slug = /\d+/g.test(counter) ? parts.join("-") : slug;
+                slug = /\d+/g.test(counter) ? parts.join('-') : slug;
                 // eslint-disable-next-line no-param-reassign
                 const nextSlug = `${slug}-${counter && /\d+/g.test(counter) ? +counter + 1 : 1}`;
                 console.log({ nextSlug, counter, slug });
@@ -97,27 +97,28 @@ class GAP extends types_1.Facade {
         this.network = args.network;
         GAP._eas = new eas_sdk_1.EAS(consts_1.Networks[args.network].contracts.eas);
         this.fetch = args.apiClient || new GapEasClient_1.GapEasClient({ network: args.network });
-        this.assert(args);
+        this.assertGelatoOpts(args);
         GAP._gelatoOpts = args.gelatoOpts;
+        GAP.remoteStorage = args.remoteStorage;
         this._schemas = schemas.map((schema) => new GapSchema_1.GapSchema(schema, false, args.globalSchemas ? !args.globalSchemas : false));
         Schema_1.Schema.validate();
         console.info(`Loaded GAP SDK v${package_json_1.version}`);
     }
-    assert(args) {
+    assertGelatoOpts(args) {
         if (args.gelatoOpts &&
             !(args.gelatoOpts.sponsorUrl || args.gelatoOpts.apiKey)) {
-            throw new Error("You must provide a `sponsorUrl` or an `apiKey`.");
+            throw new Error('You must provide a `sponsorUrl` or an `apiKey`.');
         }
         if (args.gelatoOpts?.sponsorUrl &&
             args.gelatoOpts?.contained &&
             !args.gelatoOpts.env_gelatoApiKey) {
-            throw new Error("You must provide `env_gelatoApiKey` to be able to use it in a backend handler.");
+            throw new Error('You must provide `env_gelatoApiKey` to be able to use it in a backend handler.');
         }
         if ((args.gelatoOpts?.env_gelatoApiKey ||
             args.gelatoOpts?.apiKey ||
             args.gelatoOpts?.sponsorUrl) &&
             !args.gelatoOpts?.useGasless) {
-            console.warn("GAP::You are using gelatoOpts but not setting useGasless to true. This will send transactions through the normal provider.");
+            console.warn('GAP::You are using gelatoOpts but not setting useGasless to true. This will send transactions through the normal provider.');
         }
     }
     /**
@@ -176,11 +177,11 @@ class GAP extends types_1.Facade {
      * and an API key is needed.
      */
     static set gelatoOpts(gelatoOpts) {
-        if (typeof this._gelatoOpts === "undefined") {
+        if (typeof this._gelatoOpts === 'undefined') {
             this._gelatoOpts = gelatoOpts;
         }
         else {
-            throw new Error("Cannot change a readonly value gelatoOpts.");
+            throw new Error('Cannot change a readonly value gelatoOpts.');
         }
     }
     /**
@@ -197,10 +198,13 @@ class GAP extends types_1.Facade {
             !this._gelatoOpts?.apiKey &&
             !this._gelatoOpts?.sponsorUrl &&
             !this._gelatoOpts?.env_gelatoApiKey) {
-            throw new Error("You must provide a `sponsorUrl` or an `apiKey` before using gasless transactions.");
+            throw new Error('You must provide a `sponsorUrl` or an `apiKey` before using gasless transactions.');
         }
         this._gelatoOpts.useGasless = useGasLess;
     }
+    static get remoteClient() {
+        return this.remoteStorage;
+    }
 }
 exports.GAP = GAP;
 GAP._gelatoOpts = null;

package/core/class/IPFS/IPFS.d.ts

@@ -0,0 +1,13 @@
+import { NFTStorage } from "nft.storage";
+export declare abstract class IPFS {
+    protected client: NFTStorage;
+    constructor(ipfsKey: string);
+    /**
+    * Insert the data in the IPFS and return the cid.
+    */
+    save<T = unknown>(data: T): Promise<string>;
+    /**
+    * Encode Attestation data using IPFS cid
+    */
+    protected abstract encode(data: string, storageType: number): any;
+}

package/core/class/IPFS/IPFS.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IPFS = void 0;
+const nft_storage_1 = require("nft.storage");
+const SchemaError_1 = require("../SchemaError");
+class IPFS {
+    constructor(ipfsKey) {
+        this.client = new nft_storage_1.NFTStorage({ token: ipfsKey });
+    }
+    /**
+    * Insert the data in the IPFS and return the cid.
+    */
+    async save(data) {
+        try {
+            const blob = new nft_storage_1.Blob([JSON.stringify(data)], { type: 'application/json' });
+            const cid = await this.client.storeBlob(blob);
+            return cid;
+        }
+        catch (error) {
+            throw new SchemaError_1.AttestationError('IPFS_UPLOAD', `Error adding data to IPFS`);
+        }
+    }
+}
+exports.IPFS = IPFS;

package/core/class/Schema.d.ts

@@ -1,6 +1,6 @@
-import { SchemaEncoder, SchemaItem, SchemaValue } from "@ethereum-attestation-service/eas-sdk";
-import { AttestArgs, Hex, MultiRevokeArgs, SchemaInterface, SignerOrProvider } from "../types";
-import { Attestation } from "./Attestation";
+import { SchemaEncoder, SchemaItem, SchemaValue } from '@ethereum-attestation-service/eas-sdk';
+import { AttestArgs, Hex, MultiRevokeArgs, SchemaInterface, SignerOrProvider } from '../types';
+import { Attestation } from './Attestation';
 /**
  * Represents the EAS Schema and provides methods to encode and decode the schema,
  * and validate the schema references.
@@ -125,9 +125,18 @@ export declare abstract class Schema<T extends string = string> implements Schem
      */
     multiRevokeOffchain(uids: Hex[], signer: SignerOrProvider): Promise<import("@ethereum-attestation-service/eas-sdk/dist/transaction").Transaction<bigint[]>>;
     /**
-     * Attest for a schema.
-     * @param param0
-     * @returns
+     * Validates and attests a given schema.
+     *
+     * This function checks a schema against predefined standards or rules. If the 'ipfsKey' parameter is enabled,
+     * it uploads the data to the IPFS (InterPlanetary File System). Upon successful upload, the function
+     * returns the CID (Content Identifier) within the Attestation Body, providing a reference to the data on IPFS.
+     *
+     * Usage:
+     * - Ensure that the schema to be attested conforms to the required format.
+     * - Enable 'ipfsKey' if you wish to store the data on IPFS and retrieve its CID.
+     *
+     * @param {Object} param0 - An object containing the schema and other optional settings.
+     * @returns {Object} An object containing the attestation results, including the CID if 'ipfsKey' is enabled.
      */
     attest<T>({ data, to, signer, refUID }: AttestArgs<T>): Promise<Hex>;
     /**

package/core/class/Schema.js

@@ -104,7 +104,7 @@ class Schema {
     setValue(key, value) {
         const idx = this._schema.findIndex((item) => item.name === key);
         if (!~idx)
-            throw new SchemaError_1.SchemaError("INVALID_SCHEMA_FIELD", `Field ${key} not found in schema ${this.name}`);
+            throw new SchemaError_1.SchemaError('INVALID_SCHEMA_FIELD', `Field ${key} not found in schema ${this.name}`);
         this.assertField(this._schema[idx], value);
         this._schema[idx].value = value;
     }
@@ -114,35 +114,35 @@ class Schema {
      * @returns boolean
      */
     isJsonSchema() {
-        return !!this.schema.find((s) => s.name === "json" && s.type === "string");
+        return !!this.schema.find((s) => s.name === 'json' && s.type === 'string');
     }
     assertField(item, value) {
         const { type, name } = item;
-        if (type.includes("uint") && /\D/.test(value)) {
-            throw new SchemaError_1.SchemaError("INVALID_SCHEMA_FIELD", `Field ${name} is of type ${type} but value is not a number.`);
+        if (type.includes('uint') && /\D/.test(value)) {
+            throw new SchemaError_1.SchemaError('INVALID_SCHEMA_FIELD', `Field ${name} is of type ${type} but value is not a number.`);
         }
-        if (type.includes("address") &&
+        if (type.includes('address') &&
             !ethers_1.ethers.utils.isAddress(value) &&
             value !== consts_1.zeroAddress) {
-            throw new SchemaError_1.SchemaError("INVALID_SCHEMA_FIELD", `Field ${name} is of type ${type} but value is not a valid address.`);
+            throw new SchemaError_1.SchemaError('INVALID_SCHEMA_FIELD', `Field ${name} is of type ${type} but value is not a valid address.`);
         }
-        if (type.includes("bytes") && !value.startsWith("0x")) {
-            throw new SchemaError_1.SchemaError("INVALID_SCHEMA_FIELD", `Field ${name} is of type ${type} but value is not a valid hex string.`);
+        if (type.includes('bytes') && !value.startsWith('0x')) {
+            throw new SchemaError_1.SchemaError('INVALID_SCHEMA_FIELD', `Field ${name} is of type ${type} but value is not a valid hex string.`);
         }
-        if (type.includes("bool") &&
-            (!["true", "false", true, false].includes(value) ||
-                typeof value !== "boolean")) {
-            throw new SchemaError_1.SchemaError("INVALID_SCHEMA_FIELD", `Field ${name} is of type ${type} but value is not a valid boolean.`);
+        if (type.includes('bool') &&
+            (!['true', 'false', true, false].includes(value) ||
+                typeof value !== 'boolean')) {
+            throw new SchemaError_1.SchemaError('INVALID_SCHEMA_FIELD', `Field ${name} is of type ${type} but value is not a valid boolean.`);
         }
-        if (type.includes("tuple") && !Array.isArray(value)) {
-            throw new SchemaError_1.SchemaError("INVALID_SCHEMA_FIELD", `Field ${name} is of type ${type} but value is not a valid array.`);
+        if (type.includes('tuple') && !Array.isArray(value)) {
+            throw new SchemaError_1.SchemaError('INVALID_SCHEMA_FIELD', `Field ${name} is of type ${type} but value is not a valid array.`);
         }
-        if (type === "string" && name === "json") {
+        if (type === 'string' && name === 'json') {
             try {
                 JSON.parse(value);
             }
             catch (error) {
-                throw new SchemaError_1.SchemaError("INVALID_SCHEMA_FIELD", `Field ${name} is of type ${type} but value is not a valid JSON string.`);
+                throw new SchemaError_1.SchemaError('INVALID_SCHEMA_FIELD', `Field ${name} is of type ${type} but value is not a valid JSON string.`);
             }
         }
     }
@@ -154,16 +154,16 @@ class Schema {
     assert(args, strict = false) {
         const { name, schema, uid, references } = args;
         if (!name) {
-            throw new SchemaError_1.SchemaError("MISSING_FIELD", "Schema name is required");
+            throw new SchemaError_1.SchemaError('MISSING_FIELD', 'Schema name is required');
         }
         if (!schema && !Array.isArray(schema)) {
-            throw new SchemaError_1.SchemaError("MISSING_FIELD", "Schema must be an array.");
+            throw new SchemaError_1.SchemaError('MISSING_FIELD', 'Schema must be an array.');
         }
         // if (!uid) {
         //   throw new SchemaError("MISSING_FIELD", "Schema uid is required");
         // }
         if (strict && references && !Schema.exists(references)) {
-            throw new SchemaError_1.SchemaError("INVALID_REFERENCE", `Schema ${name} references ${references} but it does not exist.`);
+            throw new SchemaError_1.SchemaError('INVALID_REFERENCE', `Schema ${name} references ${references} but it does not exist.`);
         }
     }
     /**
@@ -205,16 +205,31 @@ class Schema {
         return eas.multiRevokeOffchain(uids);
     }
     /**
-     * Attest for a schema.
-     * @param param0
-     * @returns
+     * Validates and attests a given schema.
+     *
+     * This function checks a schema against predefined standards or rules. If the 'ipfsKey' parameter is enabled,
+     * it uploads the data to the IPFS (InterPlanetary File System). Upon successful upload, the function
+     * returns the CID (Content Identifier) within the Attestation Body, providing a reference to the data on IPFS.
+     *
+     * Usage:
+     * - Ensure that the schema to be attested conforms to the required format.
+     * - Enable 'ipfsKey' if you wish to store the data on IPFS and retrieve its CID.
+     *
+     * @param {Object} param0 - An object containing the schema and other optional settings.
+     * @returns {Object} An object containing the attestation results, including the CID if 'ipfsKey' is enabled.
      */
     async attest({ data, to, signer, refUID }) {
         const eas = GAP_1.GAP.eas.connect(signer);
         if (this.references && !refUID)
-            throw new SchemaError_1.AttestationError("INVALID_REFERENCE", "Attestation schema references another schema but no reference UID was provided.");
+            throw new SchemaError_1.AttestationError('INVALID_REFERENCE', 'Attestation schema references another schema but no reference UID was provided.');
         if (this.isJsonSchema()) {
-            this.setValue("json", JSON.stringify(data));
+            const { remoteClient } = GAP_1.GAP;
+            if (remoteClient) {
+                const cid = await remoteClient.save(data, this.name);
+                const encodedData = remoteClient.encode(cid);
+                data = encodedData;
+            }
+            this.setValue('json', JSON.stringify(data));
         }
         else {
             Object.entries(data).forEach(([key, value]) => {
@@ -261,7 +276,7 @@ class Schema {
     async multiAttest(signer, entities = []) {
         entities.forEach((entity) => {
             if (this.references && !entity.refUID)
-                throw new SchemaError_1.SchemaError("INVALID_REF_UID", `Entity ${entity.schema.name} references another schema but no reference UID was provided.`);
+                throw new SchemaError_1.SchemaError('INVALID_REF_UID', `Entity ${entity.schema.name} references another schema but no reference UID was provided.`);
         });
         const eas = GAP_1.GAP.eas.connect(signer);
         const entityBySchema = entities.reduce((acc, entity) => {
@@ -323,7 +338,7 @@ class Schema {
             if (!this.exists(schema.name))
                 this.schemas.push(schema);
             else
-                throw new SchemaError_1.SchemaError("SCHEMA_ALREADY_EXISTS", `Schema ${schema.name} already exists.`);
+                throw new SchemaError_1.SchemaError('SCHEMA_ALREADY_EXISTS', `Schema ${schema.name} already exists.`);
         });
     }
     static getAll() {
@@ -332,7 +347,7 @@ class Schema {
     static get(name) {
         const schema = this.schemas.find((schema) => schema.name === name || schema.uid === name);
         if (!schema)
-            throw new SchemaError_1.SchemaError("SCHEMA_NOT_FOUND", `Schema ${name} not found. Available schemas: ${Schema.getNames()}`);
+            throw new SchemaError_1.SchemaError('SCHEMA_NOT_FOUND', `Schema ${name} not found. Available schemas: ${Schema.getNames()}`);
         return schema;
     }
     /**
@@ -357,7 +372,7 @@ class Schema {
             if (!schema.references || Schema.exists(schema.references))
                 return;
             else
-                errors.push(new SchemaError_1.SchemaError("INVALID_REFERENCE", `Schema ${schema.name} references ${schema.references} but it does not exist.`));
+                errors.push(new SchemaError_1.SchemaError('INVALID_REFERENCE', `Schema ${schema.name} references ${schema.references} but it does not exist.`));
         });
         if (errors.length)
             throw errors;
@@ -377,7 +392,7 @@ class Schema {
     static replaceOne(schema) {
         const idx = this.schemas.findIndex((item) => schema.name === item.name);
         if (!~idx)
-            throw new SchemaError_1.SchemaError("SCHEMA_NOT_FOUND", `Schema ${schema.name} not found.`);
+            throw new SchemaError_1.SchemaError('SCHEMA_NOT_FOUND', `Schema ${schema.name} not found.`);
         this.schemas[idx] = schema;
     }
     /**
@@ -392,9 +407,9 @@ class Schema {
      * @returns
      */
     static rawToObject(abi) {
-        const items = abi.trim().replace(/,\s+/gim, ",").split(",");
+        const items = abi.trim().replace(/,\s+/gim, ',').split(',');
         const schema = items.map((item) => {
-            const [type, name] = item.split(" ");
+            const [type, name] = item.split(' ');
             return { type, name, value: null };
         });
         return schema;
@@ -408,7 +423,7 @@ class Schema {
      * ```
      */
     get raw() {
-        return this.schema.map((item) => `${item.type} ${item.name}`).join(",");
+        return this.schema.map((item) => `${item.type} ${item.name}`).join(',');
     }
     get schema() {
         return this._schema;

package/core/class/SchemaError.d.ts

@@ -14,6 +14,7 @@ declare const SchemaErrorCodes: {
     INVALID_REF_UID: number;
     REVOKATION_ERROR: number;
     NOT_REVOCABLE: number;
+    REMOTE_STORAGE_UPLOAD: number;
 };
 export declare class SchemaError extends Error {
     readonly code: number;
@@ -23,4 +24,6 @@ export declare class SchemaError extends Error {
 }
 export declare class AttestationError extends SchemaError {
 }
+export declare class RemoteStorageError extends SchemaError {
+}
 export {};

package/core/class/SchemaError.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AttestationError = exports.SchemaError = void 0;
+exports.RemoteStorageError = exports.AttestationError = exports.SchemaError = void 0;
 const SchemaErrorCodes = {
     INVALID_SCHEMA: 50001,
     INVALID_SCHEMA_NAME: 50002,
@@ -17,11 +17,12 @@ const SchemaErrorCodes = {
     INVALID_REF_UID: 50013,
     REVOKATION_ERROR: 50014,
     NOT_REVOCABLE: 50015,
+    REMOTE_STORAGE_UPLOAD: 50016,
 };
 class SchemaError extends Error {
     constructor(code, append) {
-        super(`${code}${append ? `: ${append}` : ""}`);
-        this._message = append || code.replace(/_/g, " ");
+        super(`${code}${append ? `: ${append}` : ''}`);
+        this._message = append || code.replace(/_/g, ' ');
         this.code = SchemaErrorCodes[code];
     }
     get message() {
@@ -32,3 +33,6 @@ exports.SchemaError = SchemaError;
 class AttestationError extends SchemaError {
 }
 exports.AttestationError = AttestationError;
+class RemoteStorageError extends SchemaError {
+}
+exports.RemoteStorageError = RemoteStorageError;

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

@@ -22,7 +22,7 @@ export declare class Community extends Attestation<ICommunity> {
      * @param payload
      * @param refIdx
      */
-    multiAttestPayload(): MultiAttestPayload;
+    multiAttestPayload(): Promise<MultiAttestPayload>;
     /**
      * Attest a community with its details.
      *

package/core/class/entities/Community.js

@@ -23,15 +23,13 @@ class Community extends Attestation_1.Attestation {
      * @param payload
      * @param refIdx
      */
-    multiAttestPayload() {
-        const payload = [[this, this.payloadFor(0)]];
+    async multiAttestPayload() {
+        const payload = [[this, await this.payloadFor(0)]];
         if (this.details) {
-            payload.push([this.details, this.details.payloadFor(0)]);
+            payload.push([this.details, await this.details.payloadFor(0)]);
         }
         if (this.projects?.length) {
-            this.projects.forEach((p) => {
-                payload.push(...p.multiAttestPayload(payload, 0));
-            });
+            await Promise.all(this.projects.map(async (p) => payload.push(...(await p.multiAttestPayload(payload, 0)))));
         }
         return payload;
     }

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

@@ -42,7 +42,7 @@ export declare class Grant extends Attestation<IGrant> {
      * @param payload
      * @param projectIdx
      */
-    multiAttestPayload(currentPayload?: MultiAttestPayload, projectIdx?: number): [Attestation<unknown, GapSchema>, import("core/types").RawMultiAttestPayload][];
+    multiAttestPayload(currentPayload?: MultiAttestPayload, projectIdx?: number): Promise<[Attestation<unknown, GapSchema>, import("core/types").RawMultiAttestPayload][]>;
     /**
      * @inheritdoc
      */

package/core/class/entities/Grant.js

@@ -70,22 +70,18 @@ class Grant extends Attestation_1.Attestation {
      * @param payload
      * @param projectIdx
      */
-    multiAttestPayload(currentPayload = [], projectIdx = 0) {
+    async multiAttestPayload(currentPayload = [], projectIdx = 0) {
         this.assertPayload();
         const payload = [...currentPayload];
-        const grantIdx = payload.push([this, this.payloadFor(projectIdx)]) - 1;
+        const grantIdx = payload.push([this, await this.payloadFor(projectIdx)]) - 1;
         if (this.details) {
-            payload.push([this.details, this.details.payloadFor(grantIdx)]);
+            payload.push([this.details, await this.details.payloadFor(grantIdx)]);
         }
         if (this.milestones.length) {
-            this.milestones.forEach((m) => {
-                payload.push([m, m.payloadFor(grantIdx)]);
-            });
+            await Promise.all(this.milestones.map(async (m) => payload.push(...(await m.multiAttestPayload(currentPayload, grantIdx)))));
         }
         if (this.updates.length) {
-            this.updates.forEach((u) => {
-                payload.push([u, u.payloadFor(grantIdx)]);
-            });
+            await Promise.all(this.updates.map(async (u) => payload.push([u, await u.payloadFor(grantIdx)])));
         }
         return payload.slice(currentPayload.length, payload.length);
     }
@@ -94,7 +90,7 @@ class Grant extends Attestation_1.Attestation {
      */
     async attest(signer) {
         this.assertPayload();
-        const payload = this.multiAttestPayload();
+        const payload = await this.multiAttestPayload();
         const uids = await GapContract_1.GapContract.multiAttest(signer, payload.map((p) => p[1]));
         uids.forEach((uid, index) => {
             payload[index][0].uid = uid;

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

@@ -6,6 +6,6 @@ export interface IMemberOf {
 }
 export declare class MemberOf extends Attestation<IMemberOf> {
     details?: MemberDetails;
-    multiAttestPayload(currentPayload?: MultiAttestPayload, projectIdx?: number): [Attestation<unknown, import("..").GapSchema>, import("core/types").RawMultiAttestPayload][];
+    multiAttestPayload(currentPayload?: MultiAttestPayload, projectIdx?: number): Promise<[Attestation<unknown, import("..").GapSchema>, import("core/types").RawMultiAttestPayload][]>;
     attest(signer: SignerOrProvider): Promise<void>;
 }

package/core/class/entities/MemberOf.js

@@ -5,16 +5,16 @@ const Attestation_1 = require("../Attestation");
 const SchemaError_1 = require("../SchemaError");
 const GapContract_1 = require("../contract/GapContract");
 class MemberOf extends Attestation_1.Attestation {
-    multiAttestPayload(currentPayload = [], projectIdx = 0) {
+    async multiAttestPayload(currentPayload = [], projectIdx = 0) {
         const payload = [...currentPayload];
-        const memberIdx = payload.push([this, this.payloadFor(projectIdx)]) - 1;
+        const memberIdx = payload.push([this, await this.payloadFor(projectIdx)]) - 1;
         if (this.details) {
-            payload.push([this.details, this.details.payloadFor(memberIdx)]);
+            payload.push([this.details, await this.details.payloadFor(memberIdx)]);
         }
         return payload.slice(currentPayload.length, payload.length);
     }
     async attest(signer) {
-        const payload = this.multiAttestPayload();
+        const payload = await this.multiAttestPayload();
         try {
             const [memberUID, detailsUID] = await GapContract_1.GapContract.multiAttest(signer, payload.map((p) => p[1]));
             this.uid = memberUID;

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

@@ -1,5 +1,6 @@
-import { SignerOrProvider } from '../../types';
+import { MultiAttestPayload, SignerOrProvider } from '../../types';
 import { Attestation } from '../Attestation';
+import { GapSchema } from '../GapSchema';
 import { MilestoneCompleted } from '../types/attestations';
 interface _Milestone extends Milestone {
 }
@@ -54,6 +55,21 @@ export declare class Milestone extends Attestation<IMilestone> implements IMiles
      * @param signer
      */
     revokeCompletion(signer: SignerOrProvider): Promise<void>;
+    /**
+     * Creates the payload for a multi-attestation.
+     *
+     * > if Current payload is set, it'll be used as the base payload
+     * and the project should refer to an index of the current payload,
+     * usually the community position.
+     *
+     * @param payload
+     * @param grantIdx
+     */
+    multiAttestPayload(currentPayload?: MultiAttestPayload, grantIdx?: number): Promise<[Attestation<unknown, GapSchema>, import("../../types").RawMultiAttestPayload][]>;
+    /**
+     * @inheritdoc
+     */
+    attest(signer: SignerOrProvider): Promise<void>;
     /**
      * Attest the status of the milestone as approved, rejected or completed.
      */

package/core/class/entities/Milestone.js

@@ -5,6 +5,7 @@ const Attestation_1 = require("../Attestation");
 const GAP_1 = require("../GAP");
 const GapSchema_1 = require("../GapSchema");
 const SchemaError_1 = require("../SchemaError");
+const GapContract_1 = require("../contract/GapContract");
 const attestations_1 = require("../types/attestations");
 class Milestone extends Attestation_1.Attestation {
     /**
@@ -119,6 +120,40 @@ class Milestone extends Attestation_1.Attestation {
             },
         ]);
     }
+    /**
+     * Creates the payload for a multi-attestation.
+     *
+     * > if Current payload is set, it'll be used as the base payload
+     * and the project should refer to an index of the current payload,
+     * usually the community position.
+     *
+     * @param payload
+     * @param grantIdx
+     */
+    async multiAttestPayload(currentPayload = [], grantIdx = 0) {
+        this.assertPayload();
+        const payload = [...currentPayload];
+        const milestoneIdx = payload.push([this, await this.payloadFor(grantIdx)]) - 1;
+        if (this.completed) {
+            payload.push([
+                this.completed,
+                await this.completed.payloadFor(milestoneIdx),
+            ]);
+        }
+        return payload.slice(currentPayload.length, payload.length);
+    }
+    /**
+     * @inheritdoc
+     */
+    async attest(signer) {
+        this.assertPayload();
+        const payload = await this.multiAttestPayload();
+        const uids = await GapContract_1.GapContract.multiAttest(signer, payload.map((p) => p[1]));
+        uids.forEach((uid, index) => {
+            payload[index][0].uid = uid;
+        });
+        console.log(uids);
+    }
     /**
      * Attest the status of the milestone as approved, rejected or completed.
      */

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

@@ -23,7 +23,7 @@ export declare class Project extends Attestation<IProject> {
      * @param payload
      * @param communityIdx
      */
-    multiAttestPayload(currentPayload?: MultiAttestPayload, communityIdx?: number): MultiAttestPayload;
+    multiAttestPayload(currentPayload?: MultiAttestPayload, communityIdx?: number): Promise<MultiAttestPayload>;
     attest(signer: SignerOrProvider): Promise<void>;
     /**
      * Add new members to the project.

package/core/class/entities/Project.js

@@ -26,26 +26,22 @@ class Project extends Attestation_1.Attestation {
      * @param payload
      * @param communityIdx
      */
-    multiAttestPayload(currentPayload = [], communityIdx = 0) {
+    async multiAttestPayload(currentPayload = [], communityIdx = 0) {
         const payload = [...currentPayload];
-        const projectIdx = payload.push([this, this.payloadFor(communityIdx)]) - 1;
+        const projectIdx = payload.push([this, await this.payloadFor(communityIdx)]) - 1;
         if (this.details) {
-            payload.push([this.details, this.details.payloadFor(projectIdx)]);
+            payload.push([this.details, await this.details.payloadFor(projectIdx)]);
         }
         if (this.members?.length) {
-            this.members.forEach((m) => {
-                payload.push(...m.multiAttestPayload(payload, projectIdx));
-            });
+            await Promise.all(this.members.map(async (m) => payload.push(...(await m.multiAttestPayload(payload, projectIdx)))));
         }
         if (this.grants?.length) {
-            this.grants.forEach((g) => {
-                payload.push(...g.multiAttestPayload(payload, projectIdx));
-            });
+            await Promise.all(this.grants.map(async (g) => payload.push(...(await g.multiAttestPayload(payload, projectIdx)))));
         }
         return payload.slice(currentPayload.length, payload.length);
     }
     async attest(signer) {
-        const payload = this.multiAttestPayload();
+        const payload = await this.multiAttestPayload();
         const uids = await GapContract_1.GapContract.multiAttest(signer, payload.map((p) => p[1]));
         uids.forEach((uid, index) => {
             payload[index][0].uid = uid;

package/core/class/index.d.ts

@@ -1,7 +1,10 @@
-export * from "./Attestation";
-export * from "./GAP";
-export * from "./GapSchema";
-export * from "./Schema";
-export * from "./SchemaError";
-export * from "./entities";
-export * from "./karma-indexer/GapIndexerClient";
+export * from './Attestation';
+export * from './GAP';
+export * from './GapSchema';
+export * from './Schema';
+export * from './SchemaError';
+export * from './entities';
+export * from './Fetcher';
+export * from './karma-indexer/GapIndexerClient';
+export * from './remote-storage/IpfsStorage';
+export * from './remote-storage/RemoteStorage';

package/core/class/index.js

@@ -20,4 +20,7 @@ __exportStar(require("./GapSchema"), exports);
 __exportStar(require("./Schema"), exports);
 __exportStar(require("./SchemaError"), exports);
 __exportStar(require("./entities"), exports);
+__exportStar(require("./Fetcher"), exports);
 __exportStar(require("./karma-indexer/GapIndexerClient"), exports);
+__exportStar(require("./remote-storage/IpfsStorage"), exports);
+__exportStar(require("./remote-storage/RemoteStorage"), exports);

package/core/class/remote-storage/IpfsStorage.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import { NFTStorage } from 'nft.storage';
+import { RemoteStorage } from './RemoteStorage';
+import { TRemoteStorageOutput } from 'core/types';
+export interface IpfsStorageOptions {
+    token: string;
+    endpoint?: URL;
+}
+export declare class IpfsStorage extends RemoteStorage<NFTStorage> {
+    constructor(opts: IpfsStorageOptions, 
+    /**
+     * If set, will send request to another server instead of
+     * using the local instance
+     */
+    sponsor?: RemoteStorage['sponsor']);
+    private assert;
+    save<T = unknown>(data: T): Promise<string>;
+    encode(data: string): TRemoteStorageOutput<string>;
+    get<T = unknown>(args: {
+        cid: string;
+    }): Promise<T>;
+}

package/core/class/remote-storage/IpfsStorage.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IpfsStorage = void 0;
+const nft_storage_1 = require("nft.storage");
+const RemoteStorage_1 = require("./RemoteStorage");
+const SchemaError_1 = require("../SchemaError");
+const utils_1 = require("../../utils");
+class IpfsStorage extends RemoteStorage_1.RemoteStorage {
+    constructor(opts, 
+    /**
+     * If set, will send request to another server instead of
+     * using the local instance
+     */
+    sponsor) {
+        super(0 /* STORAGE_TYPE.IPFS */, sponsor);
+        this.assert(opts);
+        this.client = new nft_storage_1.NFTStorage({ ...opts });
+    }
+    assert(opts) { }
+    async save(data) {
+        try {
+            const blob = new Blob([JSON.stringify(data)], {
+                type: 'application/json',
+            });
+            const cid = await this.client.storeBlob(blob);
+            return cid;
+        }
+        catch (error) {
+            throw new SchemaError_1.RemoteStorageError('REMOTE_STORAGE_UPLOAD', `Error adding data to IPFS`);
+        }
+    }
+    encode(data) {
+        return { hash: data, storageType: this.storageType };
+    }
+    async get(args) {
+        return (0, utils_1.getIPFSData)(args.cid);
+    }
+}
+exports.IpfsStorage = IpfsStorage;

package/core/class/remote-storage/RemoteStorage.d.ts

@@ -0,0 +1,41 @@
+import { STORAGE_TYPE, TRemoteStorageOutput } from 'core/types';
+interface SponsoredRemote {
+    url: string;
+    responseParser: (response: any) => string;
+}
+export declare abstract class RemoteStorage<C = unknown> {
+    protected client: C;
+    readonly storageType: number;
+    readonly sponsor?: SponsoredRemote;
+    constructor(storageType: STORAGE_TYPE, 
+    /**
+     * If set, will try to POST request to another server instead of
+     * using the local instance.
+     *
+     * > If a response parser is not set, it will try to get { cid: string }.
+     */
+    sponsor: SponsoredRemote);
+    /**
+     * Try to save data to remote storage and return the CID.
+     * IF sponsorUrl is set, this method will be automatically
+     * intercepted and will send a POST request to the sponsorUrl
+     * with the contents: `{ data: T, type: "<AttestationType>" }`
+     */
+    abstract save<T = unknown>(data: T, schemaName: string): Promise<string>;
+    /**
+     * Encodes the data according to the remote storage type parameters
+     * OR returns the data as is if no encoding is required
+     */
+    abstract encode(data: unknown): TRemoteStorageOutput;
+    /**
+     * Get data from Remote Storage
+     */
+    abstract get<T = unknown>(args: unknown): Promise<T>;
+    /**
+     * If sponsorUrl is set, intercept the save method and send a POST request
+     * to the sponsorUrl instead of using the local instance.
+     * @returns
+     */
+    private interceptRemoteStorage;
+}
+export {};

package/core/class/remote-storage/RemoteStorage.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoteStorage = void 0;
+const axios_1 = __importDefault(require("axios"));
+class RemoteStorage {
+    constructor(storageType, 
+    /**
+     * If set, will try to POST request to another server instead of
+     * using the local instance.
+     *
+     * > If a response parser is not set, it will try to get { cid: string }.
+     */
+    sponsor) {
+        this.storageType = storageType;
+        this.sponsor = sponsor;
+        this.interceptRemoteStorage();
+    }
+    /**
+     * If sponsorUrl is set, intercept the save method and send a POST request
+     * to the sponsorUrl instead of using the local instance.
+     * @returns
+     */
+    interceptRemoteStorage() {
+        if (!this.sponsor?.url)
+            return;
+        this.save = async (data, schemaName) => {
+            const { data: response } = await axios_1.default.post(this.sponsor.url, {
+                data: data,
+                type: schemaName,
+            });
+            return this.sponsor.responseParser?.(response) || response.cid;
+        };
+    }
+}
+exports.RemoteStorage = RemoteStorage;

package/core/types.d.ts

@@ -1,8 +1,8 @@
-import { BytesLike } from "ethers";
-import { AttestationRequestData, EAS, MultiAttestationRequest, SchemaItem } from "@ethereum-attestation-service/eas-sdk";
-import { SignerOrProvider as EASSigner } from "@ethereum-attestation-service/eas-sdk/dist/transaction";
-import { Attestation } from "./class";
-import { Fetcher } from "./class/Fetcher";
+import { BytesLike } from 'ethers';
+import { AttestationRequestData, EAS, MultiAttestationRequest, SchemaItem } from '@ethereum-attestation-service/eas-sdk';
+import { SignerOrProvider as EASSigner } from '@ethereum-attestation-service/eas-sdk/dist/transaction';
+import { Attestation } from './class';
+import { Fetcher } from './class/Fetcher';
 export type Hex = `0x${string}`;
 export type SignerOrProvider = EASSigner & {
     address?: Hex;
@@ -26,10 +26,10 @@ export interface AttestArgs<T = unknown> {
     refUID?: Hex;
     signer: SignerOrProvider;
 }
-export type TSchemaName = "Community" | "CommunityDetails" | "Grant" | "GrantDetails" | "GrantVerified" | "MemberOf" | "MemberDetails" | "Milestone" | "MilestoneCompleted" | "MilestoneApproved" | "Project" | "ProjectDetails" | "Details";
-export type TResolvedSchemaNames = "Community" | "Grant" | "GrantVerified" | "MemberOf" | "MilestoneCompleted" | "MilestoneApproved" | "Project" | "Details";
-export type TExternalLink = "twitter" | "github" | "website" | "linkedin" | "discord";
-export type TNetwork = "optimism" | "optimism-goerli" | "sepolia";
+export type TSchemaName = 'Community' | 'CommunityDetails' | 'Grant' | 'GrantDetails' | 'GrantVerified' | 'MemberOf' | 'MemberDetails' | 'Milestone' | 'MilestoneCompleted' | 'MilestoneApproved' | 'Project' | 'ProjectDetails' | 'Details';
+export type TResolvedSchemaNames = 'Community' | 'Grant' | 'GrantVerified' | 'MemberOf' | 'MilestoneCompleted' | 'MilestoneApproved' | 'Project' | 'Details';
+export type TExternalLink = 'twitter' | 'github' | 'website' | 'linkedin' | 'discord';
+export type TNetwork = 'optimism' | 'optimism-goerli' | 'sepolia';
 /**
  * Generic GAP Facade interface.
  * This supplies the GAP class with the necessary properties.
@@ -105,3 +105,16 @@ export interface SchemaRes {
         attestations: IAttestation[];
     };
 }
+/**
+ * Valid remote storage types
+ */
+export declare const enum STORAGE_TYPE {
+    IPFS = 0,
+    ARWEAVE = 1,
+    SWARM = 2,
+    UNKNOWN = 3
+}
+export type TRemoteStorageOutput<T = unknown> = {
+    hash: T;
+    storageType: number;
+};

package/core/utils/get-ipfs-data.d.ts

@@ -0,0 +1 @@
+export declare function getIPFSData<T>(cid: string): Promise<T>;

package/core/utils/get-ipfs-data.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIPFSData = void 0;
+const axios_1 = __importDefault(require("axios"));
+async function getIPFSData(cid) {
+    try {
+        const { data } = await axios_1.default.get(`https://ipfs.io/ipfs/${cid}`, {
+            timeout: 5000,
+        });
+        return data;
+    }
+    catch (err) {
+        console.error(err);
+        throw new Error(`Error to retrive data for CID: ${cid}`);
+    }
+}
+exports.getIPFSData = getIPFSData;

package/core/utils/index.d.ts

@@ -4,3 +4,4 @@ export * from './gql-queries';
 export * from './map-filter';
 export * from './serialize-bigint';
 export * from './to-unix';
+export * from './get-ipfs-data';

package/core/utils/index.js

@@ -20,3 +20,4 @@ __exportStar(require("./gql-queries"), exports);
 __exportStar(require("./map-filter"), exports);
 __exportStar(require("./serialize-bigint"), exports);
 __exportStar(require("./to-unix"), exports);
+__exportStar(require("./get-ipfs-data"), exports);

package/package.json

@@ -3,9 +3,9 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "0.1.41",
+    "version": "0.2.2",
     "description": "Simple and easy interface between EAS and Karma GAP.",
-    "main": "dist/index.js",
+    "main": "./index.js",
     "author": "KarmaHQ",
     "license": "MIT",
     "private": false,
@@ -23,6 +23,7 @@
         "@types/sha256": "^0.2.0",
         "axios": "^1.4.0",
         "ethers": "5.7",
+        "nft.storage": "^7.1.1",
         "sha256": "^0.2.0",
         "simple-ts-job-runner": "^1.0.12"
     },