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

package/core/class/Attestation.js

@@ -188,11 +188,11 @@ class Attestation {
     async payloadFor(refIdx) {
         this.assertPayload();
         if (this.schema.isJsonSchema()) {
-            const ipfsManager = GAP_1.GAP.ipfs;
-            if (ipfsManager) {
-                const ipfsHash = await ipfsManager.save(this._data);
-                const encodedData = ipfsManager.encode(ipfsHash, 0);
-                this.schema.setValue("json", JSON.stringify(encodedData));
+            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) => ({

package/core/class/GAP.d.ts

@@ -1,8 +1,8 @@
-import { AttestArgs, Facade, SchemaInterface, TNetwork, TSchemaName, SignerOrProvider } from "../types";
-import { GapSchema } from "./GapSchema";
-import { ethers } from "ethers";
-import { Fetcher } from "./Fetcher";
-import { AttestationIPFS } from "./AttestationIPFS";
+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;
@@ -90,16 +90,11 @@ interface GAPArgs {
         useGasless?: boolean;
     };
     /**
-     * Specifies an optional IPFS key for uploading project details and other related data.
-     *
-     * This key is used to authenticate with the IPFS storage service, specifically designed for use with "NFT.STORAGE".
-     * Utilizing IPFS (InterPlanetary File System) offers a decentralized solution for storing data, ensuring better
-     * scalability and efficiency compared to sending large amounts of data directly in the attestation body.
-     *
-     * If an IPFS key is not provided, the default storage method will be used.
-     *
+     * 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.
      */
-    ipfsKey?: string;
+    remoteStorage?: RemoteStorage;
 }
 /**
  * GAP SDK Facade.
@@ -158,14 +153,13 @@ interface GAPArgs {
  */
 export declare class GAP extends Facade {
     private static client;
-    private static ipfsManager;
+    private static remoteStorage?;
     readonly fetch: Fetcher;
     readonly network: TNetwork;
     private _schemas;
     private static _gelatoOpts;
     constructor(args: GAPArgs);
     private assertGelatoOpts;
-    private assertIPFSOpts;
     /**
      * Creates the attestation payload using a specific schema.
      * @param from
@@ -220,8 +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 ipfs(): AttestationIPFS;
+    static get remoteClient(): RemoteStorage<unknown>;
 }
 export {};

package/core/class/GAP.js

@@ -13,7 +13,6 @@ const consts_1 = require("../consts");
 const ethers_1 = require("ethers");
 const MultiAttester_json_1 = __importDefault(require("../abi/MultiAttester.json"));
 const package_json_1 = require("../../package.json");
-const AttestationIPFS_1 = require("./AttestationIPFS");
 /**
  * GAP SDK Facade.
  *
@@ -80,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 });
@@ -100,9 +99,7 @@ class GAP extends types_1.Facade {
         this.fetch = args.apiClient || new GapEasClient_1.GapEasClient({ network: args.network });
         this.assertGelatoOpts(args);
         GAP._gelatoOpts = args.gelatoOpts;
-        if (this.assertIPFSOpts(args)) {
-            GAP.ipfsManager = new AttestationIPFS_1.AttestationIPFS(args.ipfsKey);
-        }
+        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}`);
@@ -110,25 +107,19 @@ class GAP extends types_1.Facade {
     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.");
-        }
-    }
-    assertIPFSOpts(args) {
-        if (!args.ipfsKey) {
-            return false;
+            console.warn('GAP::You are using gelatoOpts but not setting useGasless to true. This will send transactions through the normal provider.');
         }
-        return true;
     }
     /**
      * Creates the attestation payload using a specific schema.
@@ -186,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.');
         }
     }
     /**
@@ -207,12 +198,12 @@ 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 ipfs() {
-        return this.ipfsManager;
+    static get remoteClient() {
+        return this.remoteStorage;
     }
 }
 exports.GAP = GAP;

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.

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.`);
         }
     }
     /**
@@ -221,15 +221,15 @@ class Schema {
     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()) {
-            const ipfsManager = GAP_1.GAP.ipfs;
-            if (ipfsManager) {
-                const ipfsHash = await ipfsManager.save(data);
-                const encodedData = ipfsManager.encode(ipfsHash, 0);
+            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));
+            this.setValue('json', JSON.stringify(data));
         }
         else {
             Object.entries(data).forEach(([key, value]) => {
@@ -276,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) => {
@@ -338,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() {
@@ -347,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;
     }
     /**
@@ -372,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;
@@ -392,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;
     }
     /**
@@ -407,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;
@@ -423,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,7 +14,7 @@ declare const SchemaErrorCodes: {
     INVALID_REF_UID: number;
     REVOKATION_ERROR: number;
     NOT_REVOCABLE: number;
-    IPFS_UPLOAD: number;
+    REMOTE_STORAGE_UPLOAD: number;
 };
 export declare class SchemaError extends Error {
     readonly code: number;
@@ -24,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,12 +17,12 @@ const SchemaErrorCodes = {
     INVALID_REF_UID: 50013,
     REVOKATION_ERROR: 50014,
     NOT_REVOCABLE: 50015,
-    IPFS_UPLOAD: 50016,
+    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() {
@@ -33,3 +33,6 @@ exports.SchemaError = SchemaError;
 class AttestationError extends SchemaError {
 }
 exports.AttestationError = AttestationError;
+class RemoteStorageError extends SchemaError {
+}
+exports.RemoteStorageError = RemoteStorageError;

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.js

@@ -7,10 +7,13 @@ 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}`);
+        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}`);
     }
 }

package/package.json

@@ -3,9 +3,9 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "0.2.1",
+    "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,