@show-karma/karma-gap-sdk 0.4.19 → 0.4.21

package/core/__tests__/received-date.types.test.d.ts

@@ -0,0 +1 @@
+export {};

package/core/__tests__/received-date.types.test.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const attestationGrantDetails = {
+    title: "Grant",
+    proposalURL: "https://example.com",
+    type: "grant-details",
+    receivedDate: 1704844800
+};
+const indexerGrantDetails = {
+    id: "attestation-id",
+    uid: "0x1111111111111111111111111111111111111111111111111111111111111111",
+    schemaUID: "0x2222222222222222222222222222222222222222222222222222222222222222",
+    refUID: "0x0000000000000000000000000000000000000000000000000000000000000000",
+    attester: "0x3333333333333333333333333333333333333333333333333333333333333333",
+    recipient: "0x4444444444444444444444444444444444444444444444444444444444444444",
+    revoked: false,
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    chainID: 10,
+    type: "GrantDetails",
+    decodedDataJson: "{}",
+    isOffchain: false,
+    revocable: true,
+    schemaId: "0x5555555555555555555555555555555555555555555555555555555555555555",
+    data: {
+        title: "Grant",
+        amount: "1000",
+        description: "Description",
+        proposalURL: "https://example.com",
+        payoutAddress: "0x6666666666666666666666666666666666666666666666666666666666666666",
+        questions: [],
+        type: "grant-details",
+        receivedDate: 1704844800
+    }
+};
+const attestationReceivedDate = attestationGrantDetails.receivedDate;
+const indexerReceivedDate = indexerGrantDetails.data.receivedDate;
+void attestationReceivedDate;
+void indexerReceivedDate;

package/core/class/GAP.d.ts

@@ -1,8 +1,7 @@
 import { ethers } from "ethers";
-import { AttestArgs, Facade, SchemaInterface, SignerOrProvider, TNetwork, TSchemaName } from "../types";
+import { AttestArgs, Facade, GAPRpcConfig, SchemaInterface, SignerOrProvider, TNetwork, TSchemaName } from "../types";
 import { Fetcher } from "./Fetcher";
 import { GapSchema } from "./GapSchema";
-import { RemoteStorage } from "./remote-storage/RemoteStorage";
 interface GAPArgs {
     network: TNetwork;
     globalSchemas?: boolean;
@@ -12,6 +11,37 @@ interface GAPArgs {
      */
     apiClient?: Fetcher;
     schemas?: SchemaInterface<TSchemaName>[];
+    /**
+     * RPC URL configuration for the networks you need to use.
+     * Maps chain IDs to RPC endpoint URLs.
+     *
+     * @example
+     * ```typescript
+     * // Using literal strings
+     * const gap = new GAP({
+     *   network: "optimism",
+     *   rpcUrls: {
+     *     10: "https://opt-mainnet.g.alchemy.com/v2/YOUR_KEY",
+     *     42161: "https://arb-mainnet.g.alchemy.com/v2/YOUR_KEY",
+     *   },
+     * });
+     *
+     * // Using environment variables (with validation)
+     * const requireEnv = (key: string): string => {
+     *   const value = process.env[key];
+     *   if (!value) throw new Error(`Missing: ${key}`);
+     *   return value;
+     * };
+     *
+     * const gap = new GAP({
+     *   network: "optimism",
+     *   rpcUrls: {
+     *     10: requireEnv("OPTIMISM_RPC_URL"),
+     *   },
+     * });
+     * ```
+     */
+    rpcUrls?: GAPRpcConfig;
     /**
      * Defined if the transactions will be gasless or not.
      *
@@ -89,12 +119,6 @@ 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.
@@ -156,10 +180,10 @@ interface GAPArgs {
  * ```
  */
 export declare class GAP extends Facade {
-    private static remoteStorage?;
     private static instances;
     readonly fetch: Fetcher;
     readonly network: TNetwork;
+    readonly rpcConfig: GAPRpcConfig;
     private _schemas;
     private static _gelatoOpts;
     /**
@@ -168,7 +192,7 @@ export declare class GAP extends Facade {
      * @param args Optional initialization arguments
      * @returns The singleton instance of GAP for the specified network
      */
-    static getInstance(args?: GAPArgs): GAP;
+    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().
@@ -214,25 +238,37 @@ export declare class GAP extends Facade {
      * @returns
      */
     findManySchemas(names: TSchemaName[]): GapSchema[];
+    /**
+     * Get a Web3 provider for a specific chain ID using this instance's RPC configuration.
+     *
+     * @param chainId - The chain ID to get a provider for
+     * @returns An ethers JsonRpcProvider for the specified chain
+     * @throws Error if no RPC URL is configured for the chain ID
+     */
+    getProvider(chainId: number): ethers.JsonRpcProvider;
     /**
      * Get the multicall contract
      * @param signer
      */
     static getMulticall(signer: SignerOrProvider): Promise<ethers.Contract>;
     /**
-     * Get the multicall contract
-     * @param signer
+     * Get the project resolver contract
+     * @param signer - The signer or provider to use
+     * @param rpcConfig - RPC URL configuration (required when chainId is provided)
+     * @param chainId - Optional chain ID to use a different chain than the signer's
      */
     static getProjectResolver(signer: SignerOrProvider & {
         getChainId?: () => Promise<number>;
-    }, chainId?: number): Promise<ethers.Contract>;
+    }, rpcConfig?: GAPRpcConfig, chainId?: number): Promise<ethers.Contract>;
     /**
-     * Get the multicall contract
-     * @param signer
+     * Get the community resolver contract
+     * @param signer - The signer or provider to use
+     * @param rpcConfig - RPC URL configuration (required when chainId is provided)
+     * @param chainId - Optional chain ID to use a different chain than the signer's
      */
     static getCommunityResolver(signer: SignerOrProvider & {
         getChainId?: () => Promise<number>;
-    }, chainId?: number): Promise<ethers.Contract>;
+    }, rpcConfig?: GAPRpcConfig, chainId?: number): Promise<ethers.Contract>;
     get schemas(): GapSchema[];
     /**
      * Defined if the transactions will be gasless or not.
@@ -249,6 +285,5 @@ export declare class GAP extends Facade {
      */
     static get gelatoOpts(): GAPArgs["gelatoOpts"];
     static set useGasLess(useGasLess: boolean);
-    static get remoteClient(): RemoteStorage<unknown>;
 }
 export {};

package/core/class/GAP.js

@@ -83,16 +83,10 @@ class GAP extends types_1.Facade {
      * @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;
@@ -132,6 +126,7 @@ class GAP extends types_1.Facade {
         };
         const schemas = args.schemas || Object.values((0, consts_1.MountEntities)(consts_1.Networks[args.network]));
         this.network = args.network;
+        this.rpcConfig = args.rpcUrls ?? {};
         this._eas = new eas_sdk_1.EAS(consts_1.Networks[args.network].contracts.eas);
         this.fetch =
             args.apiClient ||
@@ -141,7 +136,6 @@ class GAP extends types_1.Facade {
         this.fetch.gapInstance = this;
         this.assertGelatoOpts(args);
         GAP._gelatoOpts = args.gelatoOpts;
-        GAP.remoteStorage = args.remoteStorage;
         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}`);
@@ -207,6 +201,16 @@ class GAP extends types_1.Facade {
         const schemas = Schema_1.Schema.getMany(names, this.network);
         return schemas.map((s) => GapSchema_1.GapSchema.clone(s));
     }
+    /**
+     * Get a Web3 provider for a specific chain ID using this instance's RPC configuration.
+     *
+     * @param chainId - The chain ID to get a provider for
+     * @returns An ethers JsonRpcProvider for the specified chain
+     * @throws Error if no RPC URL is configured for the chain ID
+     */
+    getProvider(chainId) {
+        return (0, get_web3_provider_1.getWeb3Provider)(chainId, this.rpcConfig);
+    }
     /**
      * Get the multicall contract
      * @param signer
@@ -220,28 +224,44 @@ class GAP extends types_1.Facade {
         return new ethers_1.ethers.Contract(address, MultiAttester_json_1.default, signer);
     }
     /**
-     * Get the multicall contract
-     * @param signer
+     * Get the project resolver contract
+     * @param signer - The signer or provider to use
+     * @param rpcConfig - RPC URL configuration (required when chainId is provided)
+     * @param chainId - Optional chain ID to use a different chain than the signer's
      */
-    static async getProjectResolver(signer, chainId) {
+    static async getProjectResolver(signer, rpcConfig, chainId) {
         const currentChainId = chainId ||
             Number((await signer.provider.getNetwork())?.chainId ||
                 (await signer.getChainId()));
-        const provider = chainId ? (0, get_web3_provider_1.getWeb3Provider)(chainId) : signer;
+        const provider = chainId && rpcConfig
+            ? (0, get_web3_provider_1.getWeb3Provider)(chainId, rpcConfig)
+            : signer;
         const network = Object.values(consts_1.Networks).find((n) => +n.chainId === Number(currentChainId));
+        if (!network) {
+            throw new Error(`Network with chain ID ${currentChainId} is not supported. ` +
+                `Supported networks: ${Object.keys(consts_1.Networks).join(", ")}`);
+        }
         const address = network.contracts.projectResolver;
         return new ethers_1.ethers.Contract(address, ProjectResolver_json_1.default, provider);
     }
     /**
-     * Get the multicall contract
-     * @param signer
+     * Get the community resolver contract
+     * @param signer - The signer or provider to use
+     * @param rpcConfig - RPC URL configuration (required when chainId is provided)
+     * @param chainId - Optional chain ID to use a different chain than the signer's
      */
-    static async getCommunityResolver(signer, chainId) {
+    static async getCommunityResolver(signer, rpcConfig, chainId) {
         const currentChainId = chainId ||
             Number((await signer.provider.getNetwork())?.chainId ||
                 (await signer.getChainId()));
-        const provider = chainId ? (0, get_web3_provider_1.getWeb3Provider)(chainId) : signer;
+        const provider = chainId && rpcConfig
+            ? (0, get_web3_provider_1.getWeb3Provider)(chainId, rpcConfig)
+            : signer;
         const network = Object.values(consts_1.Networks).find((n) => +n.chainId === Number(currentChainId));
+        if (!network) {
+            throw new Error(`Network with chain ID ${currentChainId} is not supported. ` +
+                `Supported networks: ${Object.keys(consts_1.Networks).join(", ")}`);
+        }
         const address = network.contracts.communityResolver;
         return new ethers_1.ethers.Contract(address, CommunityResolverABI_json_1.default, provider);
     }
@@ -280,9 +300,6 @@ class GAP extends types_1.Facade {
         }
         this._gelatoOpts.useGasless = useGasLess;
     }
-    static get remoteClient() {
-        return this.remoteStorage;
-    }
 }
 exports.GAP = GAP;
 GAP.instances = new Map();

package/core/class/GrantProgramRegistry/Allo.d.ts

@@ -3,15 +3,13 @@ export declare class AlloBase {
     private signer;
     private contract;
     private allo;
-    private pinataJWTToken;
-    constructor(signer: ethers.Signer, pinataJWTToken: string, chainId: number);
-    saveAndGetCID(data: any, pinataMetadata?: {
-        name: string;
-    }): Promise<any>;
+    constructor(signer: ethers.Signer, chainId: number);
     encodeStrategyInitData(applicationStart: number, applicationEnd: number, roundStart: number, roundEnd: number, payoutToken: string): Promise<string>;
-    createGrant(args: any, callback?: Function): Promise<{
+    createGrant(args: any & {
+        metadataCid: string;
+    }, callback?: Function): Promise<{
         poolId: string;
         txHash: string;
     }>;
-    updatePoolMetadata(poolId: string, poolMetadata: any, callback?: Function): Promise<any>;
+    updatePoolMetadata(poolId: string, metadataCid: string, callback?: Function): Promise<any>;
 }

package/core/class/GrantProgramRegistry/Allo.js

@@ -9,32 +9,13 @@ const Allo_json_1 = __importDefault(require("../../abi/Allo.json"));
 const consts_1 = require("../../consts");
 const ethers_2 = require("ethers");
 const allo_v2_sdk_1 = require("@allo-team/allo-v2-sdk/");
-const axios_1 = __importDefault(require("axios"));
 // ABI fragment for the Initialized event
 const INITIALIZED_EVENT = ["event Initialized(uint256 poolId, bytes data)"];
 class AlloBase {
-    constructor(signer, pinataJWTToken, chainId) {
+    constructor(signer, chainId) {
         this.signer = signer;
         this.contract = new ethers_1.ethers.Contract(consts_1.AlloContracts.alloProxy, Allo_json_1.default, signer);
         this.allo = new allo_v2_sdk_1.Allo({ chain: chainId });
-        this.pinataJWTToken = pinataJWTToken;
-    }
-    async saveAndGetCID(data, pinataMetadata = { name: "via karma-gap-sdk" }) {
-        try {
-            const res = await axios_1.default.post("https://api.pinata.cloud/pinning/pinJSONToIPFS", {
-                pinataContent: data,
-                pinataMetadata: pinataMetadata,
-            }, {
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: `Bearer ${this.pinataJWTToken}`,
-                },
-            });
-            return res.data.IpfsHash;
-        }
-        catch (error) {
-            console.log(error);
-        }
     }
     async encodeStrategyInitData(applicationStart, applicationEnd, roundStart, roundEnd, payoutToken) {
         const encoder = new ethers_2.AbiCoder();
@@ -54,13 +35,9 @@ class AlloBase {
         const walletBalance = await this.signer.provider.getBalance(await this.signer.getAddress());
         console.log("Wallet balance:", (0, ethers_1.formatEther)(walletBalance.toString()), " ETH");
         try {
-            const metadata_cid = await this.saveAndGetCID({
-                round: args.roundMetadata,
-                application: args.applicationMetadata,
-            });
             const metadata = {
                 protocol: BigInt(1),
-                pointer: metadata_cid,
+                pointer: args.metadataCid,
             };
             const initStrategyData = (await this.encodeStrategyInitData(args.applicationStart, args.applicationEnd, args.roundStart, args.roundEnd, args.payoutToken));
             const createPoolArgs = {
@@ -114,13 +91,12 @@ class AlloBase {
             throw new Error(`Failed to create pool metadata: ${error}`);
         }
     }
-    async updatePoolMetadata(poolId, poolMetadata, callback) {
+    async updatePoolMetadata(poolId, metadataCid, callback) {
         try {
             callback?.("preparing");
-            const metadata_cid = await this.saveAndGetCID(poolMetadata);
             const metadata = {
                 protocol: 1,
-                pointer: metadata_cid,
+                pointer: metadataCid,
             };
             const tx = await this.contract.updatePoolMetadata(poolId, metadata);
             callback?.("pending");

package/core/class/GrantProgramRegistry/AlloRegistry.d.ts

@@ -1,15 +1,10 @@
 import { ethers } from "ethers";
-import { ProfileMetadata } from "../types/allo";
 export declare class AlloRegistry {
     private contract;
-    private pinataJWTToken;
-    constructor(signer: ethers.Signer, pinataJWTToken: string);
-    saveAndGetCID(data: any, pinataMetadata?: {
-        name: string;
-    }): Promise<any>;
-    createProgram(nonce: number, name: string, profileMetadata: ProfileMetadata, owner: string, members: string[]): Promise<{
+    constructor(signer: ethers.Signer);
+    createProgram(nonce: number, name: string, metadataCid: string, owner: string, members: string[]): Promise<{
         profileId: any;
         txHash: any;
     }>;
-    updateProgramMetadata(profileId: string, profileMetadata: ProfileMetadata): Promise<any>;
+    updateProgramMetadata(profileId: string, metadataCid: string): Promise<any>;
 }

package/core/class/GrantProgramRegistry/AlloRegistry.js

@@ -7,36 +7,16 @@ exports.AlloRegistry = void 0;
 const ethers_1 = require("ethers");
 const AlloRegistry_json_1 = __importDefault(require("../../abi/AlloRegistry.json"));
 const consts_1 = require("../../consts");
-const axios_1 = __importDefault(require("axios"));
 class AlloRegistry {
-    constructor(signer, pinataJWTToken) {
+    constructor(signer) {
         this.contract = new ethers_1.ethers.Contract(consts_1.AlloContracts.registry, AlloRegistry_json_1.default, signer);
-        this.pinataJWTToken = pinataJWTToken;
     }
-    async saveAndGetCID(data, pinataMetadata = { name: "via karma-gap-sdk" }) {
-        try {
-            const res = await axios_1.default.post("https://api.pinata.cloud/pinning/pinJSONToIPFS", {
-                pinataContent: data,
-                pinataMetadata: pinataMetadata,
-            }, {
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: `Bearer ${this.pinataJWTToken}`,
-                },
-            });
-            return res.data.IpfsHash;
-        }
-        catch (error) {
-            console.log(error);
-        }
-    }
-    async createProgram(nonce, name, profileMetadata, owner, members) {
+    async createProgram(nonce, name, metadataCid, owner, members) {
         console.log("Creating program...");
         try {
-            const metadata_cid = await this.saveAndGetCID(profileMetadata);
             const metadata = {
                 protocol: 1,
-                pointer: metadata_cid,
+                pointer: metadataCid,
             };
             const tx = await this.contract.createProfile(nonce, name, metadata, owner, members);
             const receipt = await tx.wait();
@@ -51,12 +31,11 @@ class AlloRegistry {
             console.error(`Failed to register program: ${error}`);
         }
     }
-    async updateProgramMetadata(profileId, profileMetadata) {
+    async updateProgramMetadata(profileId, metadataCid) {
         try {
-            const metadata_cid = await this.saveAndGetCID(profileMetadata);
             const metadata = {
                 protocol: 1,
-                pointer: metadata_cid,
+                pointer: metadataCid,
             };
             const tx = await this.contract.updateProfileMetadata(profileId, metadata);
             const receipt = await tx.wait();

package/core/class/Schema.d.ts

@@ -135,16 +135,11 @@ export declare abstract class Schema<T extends string = string> implements Schem
     /**
      * 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.
+     * This function checks a schema against predefined standards or rules and creates
+     * an attestation on-chain.
      *
      * @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.
+     * @returns {Object} An object containing the attestation results.
      */
     attest<T>({ data, to, signer, refUID, callback, }: AttestArgs<T>): Promise<AttestationWithTx>;
     /**

package/core/class/Schema.js

@@ -208,16 +208,11 @@ class Schema {
     /**
      * 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.
+     * This function checks a schema against predefined standards or rules and creates
+     * an attestation on-chain.
      *
      * @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.
+     * @returns {Object} An object containing the attestation results.
      */
     async attest({ data, to, signer, refUID, callback, }) {
         const eas = this.gap.eas.connect(signer);

package/core/class/SchemaError.d.ts

@@ -14,7 +14,6 @@ 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;
@@ -25,6 +24,4 @@ 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.RemoteStorageError = exports.AttestationError = exports.SchemaError = void 0;
+exports.AttestationError = exports.SchemaError = void 0;
 const SchemaErrorCodes = {
     INVALID_SCHEMA: 50001,
     INVALID_SCHEMA_NAME: 50002,
@@ -17,7 +17,6 @@ const SchemaErrorCodes = {
     INVALID_REF_UID: 50013,
     REVOKATION_ERROR: 50014,
     NOT_REVOCABLE: 50015,
-    REMOTE_STORAGE_UPLOAD: 50016,
 };
 class SchemaError extends Error {
     constructor(code, append, originalError) {
@@ -34,6 +33,3 @@ exports.SchemaError = SchemaError;
 class AttestationError extends SchemaError {
 }
 exports.AttestationError = AttestationError;
-class RemoteStorageError extends SchemaError {
-}
-exports.RemoteStorageError = RemoteStorageError;

package/core/class/contract/GapContract.d.ts

@@ -1,5 +1,5 @@
 import { MultiRevocationRequest } from "@ethereum-attestation-service/eas-sdk";
-import { CallbackStatus, Hex, RawAttestationPayload, RawMultiAttestPayload, SignerOrProvider } from "core/types";
+import { CallbackStatus, GAPRpcConfig, Hex, RawAttestationPayload, RawMultiAttestPayload, SignerOrProvider } from "core/types";
 import { Transaction } from "ethers";
 import { AttestationWithTx } from "../types/attestations";
 export declare class GapContract {
@@ -66,22 +66,24 @@ export declare class GapContract {
     static transferProjectOwnership(signer: SignerOrProvider, projectUID: Hex, newOwner: Hex): Promise<any>;
     /**
      * Check if the signer is the owner of the project
-     * @param signer
-     * @param projectUID
-     * @param projectChainId
-     * @param publicAddress
-     * @returns
+     * @param signer - Signer or provider
+     * @param projectUID - The project UID
+     * @param projectChainId - The chain ID where the project exists
+     * @param publicAddress - Optional public address to check (uses signer address if not provided)
+     * @param rpcConfig - Optional RPC config for cross-chain operations. If not provided, uses the signer's chain.
+     * @returns Whether the address is a project owner
      */
-    static isProjectOwner(signer: SignerOrProvider, projectUID: Hex, projectChainId: number, publicAddress?: string): Promise<boolean>;
+    static isProjectOwner(signer: SignerOrProvider, projectUID: Hex, projectChainId: number, publicAddress?: string, rpcConfig?: GAPRpcConfig): Promise<boolean>;
     /**
      * Check if the signer is admin of the project
-     * @param signer
-     * @param projectUID
-     * @param projectChainId
-     * @param publicAddress
-     * @returns
+     * @param signer - Signer or provider
+     * @param projectUID - The project UID
+     * @param projectChainId - The chain ID where the project exists
+     * @param publicAddress - Optional public address to check (uses signer address if not provided)
+     * @param rpcConfig - Optional RPC config for cross-chain operations. If not provided, uses the signer's chain.
+     * @returns Whether the address is a project admin
      */
-    static isProjectAdmin(signer: SignerOrProvider, projectUID: Hex, projectChainId: number, publicAddress?: string): Promise<boolean>;
+    static isProjectAdmin(signer: SignerOrProvider, projectUID: Hex, projectChainId: number, publicAddress?: string, rpcConfig?: GAPRpcConfig): Promise<boolean>;
     private static getTransactionLogs;
     /**
      * Add Project Admin

package/core/class/contract/GapContract.js

@@ -222,28 +222,30 @@ class GapContract {
     }
     /**
      * Check if the signer is the owner of the project
-     * @param signer
-     * @param projectUID
-     * @param projectChainId
-     * @param publicAddress
-     * @returns
+     * @param signer - Signer or provider
+     * @param projectUID - The project UID
+     * @param projectChainId - The chain ID where the project exists
+     * @param publicAddress - Optional public address to check (uses signer address if not provided)
+     * @param rpcConfig - Optional RPC config for cross-chain operations. If not provided, uses the signer's chain.
+     * @returns Whether the address is a project owner
      */
-    static async isProjectOwner(signer, projectUID, projectChainId, publicAddress) {
-        const contract = await GAP_1.GAP.getProjectResolver(signer, projectChainId);
+    static async isProjectOwner(signer, projectUID, projectChainId, publicAddress, rpcConfig) {
+        const contract = await GAP_1.GAP.getProjectResolver(signer, rpcConfig, projectChainId);
         const address = publicAddress || (await this.getSignerAddress(signer));
         const isOwner = await contract.isOwner(projectUID, address);
         return isOwner;
     }
     /**
      * Check if the signer is admin of the project
-     * @param signer
-     * @param projectUID
-     * @param projectChainId
-     * @param publicAddress
-     * @returns
+     * @param signer - Signer or provider
+     * @param projectUID - The project UID
+     * @param projectChainId - The chain ID where the project exists
+     * @param publicAddress - Optional public address to check (uses signer address if not provided)
+     * @param rpcConfig - Optional RPC config for cross-chain operations. If not provided, uses the signer's chain.
+     * @returns Whether the address is a project admin
      */
-    static async isProjectAdmin(signer, projectUID, projectChainId, publicAddress) {
-        const contract = await GAP_1.GAP.getProjectResolver(signer, projectChainId);
+    static async isProjectAdmin(signer, projectUID, projectChainId, publicAddress, rpcConfig) {
+        const contract = await GAP_1.GAP.getProjectResolver(signer, rpcConfig, projectChainId);
         const address = publicAddress || (await this.getSignerAddress(signer));
         const isAdmin = await contract.isAdmin(projectUID, address);
         return isAdmin;

package/core/class/index.d.ts

@@ -6,5 +6,3 @@ 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

@@ -22,5 +22,3 @@ __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/karma-indexer/api/GapIndexerApi.d.ts

@@ -2,72 +2,72 @@ import { AxiosGQL } from "../../GraphQL/AxiosGQL";
 import { Hex, IAttestationResponse, ICommunityResponse, ICommunityAdminsResponse, IGrantResponse, IProjectResponse, ISearchResponse, IProjectMilestoneResponse, ITrackResponse, ITrackAssignmentResponse, IProjectTrackResponse } from "./types";
 export declare class GapIndexerApi extends AxiosGQL {
     constructor(url: string);
-    attestation(uid: Hex): Promise<import("axios").AxiosResponse<IAttestationResponse, any>>;
-    attestations(schemaUID: string, search?: string): Promise<import("axios").AxiosResponse<IAttestationResponse[], any>>;
-    attestationsOf(schemaUID: string, attester: Hex): Promise<import("axios").AxiosResponse<IAttestationResponse[], any>>;
+    attestation(uid: Hex): Promise<import("axios").AxiosResponse<IAttestationResponse, any, {}>>;
+    attestations(schemaUID: string, search?: string): Promise<import("axios").AxiosResponse<IAttestationResponse[], any, {}>>;
+    attestationsOf(schemaUID: string, attester: Hex): Promise<import("axios").AxiosResponse<IAttestationResponse[], any, {}>>;
     /**
      * Community
      */
-    communities(search?: string): Promise<import("axios").AxiosResponse<ICommunityResponse[], any>>;
-    communitiesOf(address: Hex, withGrants: boolean): Promise<import("axios").AxiosResponse<ICommunityResponse[], any>>;
-    adminOf(address: Hex): Promise<import("axios").AxiosResponse<ICommunityResponse[], any>>;
-    communityBySlug(slug: string): Promise<import("axios").AxiosResponse<ICommunityResponse, any>>;
-    communityAdmins(uid: Hex): Promise<import("axios").AxiosResponse<ICommunityAdminsResponse, any>>;
+    communities(search?: string): Promise<import("axios").AxiosResponse<ICommunityResponse[], any, {}>>;
+    communitiesOf(address: Hex, withGrants: boolean): Promise<import("axios").AxiosResponse<ICommunityResponse[], any, {}>>;
+    adminOf(address: Hex): Promise<import("axios").AxiosResponse<ICommunityResponse[], any, {}>>;
+    communityBySlug(slug: string): Promise<import("axios").AxiosResponse<ICommunityResponse, any, {}>>;
+    communityAdmins(uid: Hex): Promise<import("axios").AxiosResponse<ICommunityAdminsResponse, any, {}>>;
     /**
      * Project
      */
-    projectBySlug(slug: string): Promise<import("axios").AxiosResponse<IProjectResponse, any>>;
-    search(query: string): Promise<import("axios").AxiosResponse<ISearchResponse, any>>;
-    searchProjects(query: string): Promise<import("axios").AxiosResponse<IProjectResponse[], any>>;
-    projects(name?: string): Promise<import("axios").AxiosResponse<IProjectResponse[], any>>;
-    projectsOf(grantee: Hex): Promise<import("axios").AxiosResponse<IProjectResponse[], any>>;
-    projectMilestones(uidOrSlug: string): Promise<import("axios").AxiosResponse<IProjectMilestoneResponse[], any>>;
+    projectBySlug(slug: string): Promise<import("axios").AxiosResponse<IProjectResponse, any, {}>>;
+    search(query: string): Promise<import("axios").AxiosResponse<ISearchResponse, any, {}>>;
+    searchProjects(query: string): Promise<import("axios").AxiosResponse<IProjectResponse[], any, {}>>;
+    projects(name?: string): Promise<import("axios").AxiosResponse<IProjectResponse[], any, {}>>;
+    projectsOf(grantee: Hex): Promise<import("axios").AxiosResponse<IProjectResponse[], any, {}>>;
+    projectMilestones(uidOrSlug: string): Promise<import("axios").AxiosResponse<IProjectMilestoneResponse[], any, {}>>;
     /**
      * Grantee
      */
-    grantee(address: Hex): Promise<import("axios").AxiosResponse<any, any>>;
+    grantee(address: Hex): Promise<import("axios").AxiosResponse<any, any, {}>>;
     grantees(): Promise<import("axios").AxiosResponse<{
         [key: `0x${string}`]: {
             grants: number;
             projects: number;
         };
-    }, any>>;
+    }, any, {}>>;
     /**
      * Grant
      */
-    grantsOf(grantee: Hex, withCommunity?: boolean): Promise<import("axios").AxiosResponse<IGrantResponse[], any>>;
-    grantsFor(uid: string, withCommunity?: boolean): Promise<import("axios").AxiosResponse<IGrantResponse[], any>>;
-    grantsForExtProject(projectExtId: string): Promise<import("axios").AxiosResponse<IGrantResponse[], any>>;
-    grantBySlug(slug: Hex): Promise<import("axios").AxiosResponse<IGrantResponse, any>>;
+    grantsOf(grantee: Hex, withCommunity?: boolean): Promise<import("axios").AxiosResponse<IGrantResponse[], any, {}>>;
+    grantsFor(uid: string, withCommunity?: boolean): Promise<import("axios").AxiosResponse<IGrantResponse[], any, {}>>;
+    grantsForExtProject(projectExtId: string): Promise<import("axios").AxiosResponse<IGrantResponse[], any, {}>>;
+    grantBySlug(slug: Hex): Promise<import("axios").AxiosResponse<IGrantResponse, any, {}>>;
     grantsByCommunity(uid: Hex, page?: number, pageLimit?: number): Promise<import("axios").AxiosResponse<{
         data: IGrantResponse[];
-    }, any>>;
+    }, any, {}>>;
     /**
      * Milestone
      */
-    milestonesOf(uid: Hex): Promise<import("axios").AxiosResponse<any, any>>;
+    milestonesOf(uid: Hex): Promise<import("axios").AxiosResponse<any, any, {}>>;
     slugExists(slug: string): Promise<boolean>;
     /**
      * Tracks
      */
-    getTracks(communityUID: string, includeArchived?: boolean): Promise<import("axios").AxiosResponse<ITrackResponse[], any>>;
-    getTrackById(id: string): Promise<import("axios").AxiosResponse<ITrackResponse, any>>;
+    getTracks(communityUID: string, includeArchived?: boolean): Promise<import("axios").AxiosResponse<ITrackResponse[], any, {}>>;
+    getTrackById(id: string): Promise<import("axios").AxiosResponse<ITrackResponse, any, {}>>;
     createTrack(data: {
         name: string;
         description?: string;
         communityUID: string;
-    }): Promise<import("axios").AxiosResponse<ITrackResponse, any>>;
+    }): Promise<import("axios").AxiosResponse<ITrackResponse, any, {}>>;
     updateTrack(id: string, data: {
         name?: string;
         description?: string;
         communityUID?: string;
-    }): Promise<import("axios").AxiosResponse<ITrackResponse, any>>;
-    archiveTrack(id: string): Promise<import("axios").AxiosResponse<ITrackResponse, any>>;
-    assignTracksToProgram(programId: string, trackIds: string[]): Promise<import("axios").AxiosResponse<ITrackAssignmentResponse[], any>>;
-    unassignTrackFromProgram(programId: string, trackId: string): Promise<import("axios").AxiosResponse<ITrackAssignmentResponse, any>>;
-    getTracksForProgram(programId: string): Promise<import("axios").AxiosResponse<ITrackResponse[], any>>;
-    getTracksForProject(projectId: string, programId: string, activeOnly?: boolean): Promise<import("axios").AxiosResponse<ITrackResponse[], any>>;
-    assignTracksToProject(projectId: string, programId: string, trackIds: string[]): Promise<import("axios").AxiosResponse<any[], any>>;
-    unassignTracksFromProject(projectId: string, programId: string, trackIds: string[]): Promise<import("axios").AxiosResponse<any[], any>>;
-    getProjectsByTrack(communityId: string, programId: string, trackId?: string): Promise<import("axios").AxiosResponse<IProjectTrackResponse[], any>>;
+    }): Promise<import("axios").AxiosResponse<ITrackResponse, any, {}>>;
+    archiveTrack(id: string): Promise<import("axios").AxiosResponse<ITrackResponse, any, {}>>;
+    assignTracksToProgram(programId: string, trackIds: string[]): Promise<import("axios").AxiosResponse<ITrackAssignmentResponse[], any, {}>>;
+    unassignTrackFromProgram(programId: string, trackId: string): Promise<import("axios").AxiosResponse<ITrackAssignmentResponse, any, {}>>;
+    getTracksForProgram(programId: string): Promise<import("axios").AxiosResponse<ITrackResponse[], any, {}>>;
+    getTracksForProject(projectId: string, programId: string, activeOnly?: boolean): Promise<import("axios").AxiosResponse<ITrackResponse[], any, {}>>;
+    assignTracksToProject(projectId: string, programId: string, trackIds: string[]): Promise<import("axios").AxiosResponse<any[], any, {}>>;
+    unassignTracksFromProject(projectId: string, programId: string, trackIds: string[]): Promise<import("axios").AxiosResponse<any[], any, {}>>;
+    getProjectsByTrack(communityId: string, programId: string, trackId?: string): Promise<import("axios").AxiosResponse<IProjectTrackResponse[], any, {}>>;
 }

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

@@ -146,7 +146,8 @@ export interface IGrantDetails extends IAttestationResponse {
             query: string;
             explanation: string;
         }[];
-        startDate: number;
+        startDate?: number;
+        receivedDate?: number;
         programId?: string;
         type: "grant-details";
         fundUsage?: string;

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

@@ -48,6 +48,7 @@ export interface IGrantDetails {
     questions?: IGrantDetailsQuestion[];
     type?: string;
     startDate?: number;
+    receivedDate?: number;
     programId?: string;
     fundUsage?: string;
     selectedTrackIds?: string[];
@@ -65,6 +66,7 @@ export declare class GrantDetails extends Attestation<IGrantDetails> implements
     questions?: IGrantDetailsQuestion[];
     type: string;
     startDate?: number;
+    receivedDate?: number;
     fundUsage?: string;
     selectedTrackIds?: string[];
 }

package/core/consts.js

@@ -43,7 +43,6 @@ exports.Networks = {
     optimism: {
         chainId: 10,
         url: "https://optimism.easscan.org/graphql",
-        rpcUrl: "https://opt-mainnet.g.alchemy.com/v2/fx2SlVDrPbXwPMQT4v0lRT1PABA16Myl",
         contracts: {
             eas: "0x4200000000000000000000000000000000000021",
             schema: "0x4200000000000000000000000000000000000020",
@@ -98,7 +97,6 @@ exports.Networks = {
     "optimism-sepolia": {
         chainId: 11155420,
         url: "https://optimism-sepolia.easscan.org/graphql",
-        rpcUrl: "https://opt-sepolia.g.alchemy.com/v2/9FEqTNKmgO7X7ll92ALJrEih7Jjhldf-",
         contracts: {
             communityResolver: "0xa5B7bbFD545A1a816aa8cBE28a1F0F2Cca58363d",
             eas: "0x4200000000000000000000000000000000000021",
@@ -153,7 +151,6 @@ exports.Networks = {
     arbitrum: {
         chainId: 42161,
         url: "https://arbitrum.easscan.org/graphql",
-        rpcUrl: "https://arb-mainnet.g.alchemy.com/v2/okcKBSKXvLuSCbas6QWGvKuh-IcHHSOr",
         contracts: {
             eas: "0xbD75f629A22Dc1ceD33dDA0b68c546A1c035c458",
             schema: "0xA310da9c5B885E7fb3fbA9D66E9Ba6Df512b78eB",
@@ -208,7 +205,6 @@ exports.Networks = {
     sepolia: {
         chainId: 11155111,
         url: "https://sepolia.easscan.org/graphql",
-        rpcUrl: "https://eth-sepolia.g.alchemy.com/v2/_M6YQg_DoVKuMisaFHSVZL-EcdkTbhUi",
         contracts: {
             eas: "0xC2679fBD37d54388Ce493F1DB75320D236e1815e",
             schema: "0x0a7E2Ff54e76B8E6659aedc9103FB21c038050D0",
@@ -237,7 +233,6 @@ exports.Networks = {
     "base-sepolia": {
         chainId: 84532,
         url: "https://base-sepolia.easscan.org/graphql",
-        rpcUrl: "https://sepolia.base.org",
         contracts: {
             eas: "0x4200000000000000000000000000000000000021",
             schema: "0x4200000000000000000000000000000000000020",
@@ -265,7 +260,6 @@ exports.Networks = {
     celo: {
         chainId: 42220,
         url: "https://celo.easscan.org/graphql",
-        rpcUrl: "https://forno.celo.org",
         contracts: {
             eas: "0x72E1d8ccf5299fb36fEfD8CC4394B8ef7e98Af92",
             schema: "0x5ece93bE4BDCF293Ed61FA78698B594F2135AF34",
@@ -320,7 +314,6 @@ exports.Networks = {
     sei: {
         chainId: 1329,
         url: "https://sei.easscan.org/graphql",
-        rpcUrl: "https://muddy-orbital-arrow.sei-pacific.quiknode.pro/594552c3ab4ed4106b40402c16dba137ab279d40",
         contracts: {
             eas: "0x391020888b0adBA584A67693458b374e4141f838",
             schema: "0x80A4B50f549a8271e10A6C8e79172cb56f35fD57",
@@ -375,7 +368,6 @@ exports.Networks = {
     "sei-testnet": {
         chainId: 1328,
         url: "https://sei-testnet.easscan.org/graphql",
-        rpcUrl: "https://evm-rpc-testnet.sei-apis.com",
         contracts: {
             eas: "0x4F166ed0A038ECdEEefa7Dc508f15991762974Fe",
             schema: "0x906a57aCa067178e76e6eBDF4C7b26CBcAEC0Edd",
@@ -403,7 +395,6 @@ exports.Networks = {
     lisk: {
         chainId: 1135,
         url: "https://lisk.easscan.org/graphql",
-        rpcUrl: "https://lisk.drpc.org",
         contracts: {
             eas: "0x4200000000000000000000000000000000000021",
             schema: "0x4200000000000000000000000000000000000020",
@@ -431,7 +422,6 @@ exports.Networks = {
     scroll: {
         chainId: 534352,
         url: "https://scroll.easscan.org/graphql",
-        rpcUrl: "https://scroll-mainnet.g.alchemy.com/v2/SsQRSwtqtBMGmXQCDH9lYb4U8p9QnqXK",
         contracts: {
             eas: "0xC47300428b6AD2c7D03BB76D05A176058b47E6B0",
             schema: "0xD2CDF46556543316e7D34e8eDc4624e2bB95e3B6",
@@ -459,7 +449,6 @@ exports.Networks = {
     "base": {
         chainId: 8453,
         url: "https://base.easscan.org/graphql",
-        rpcUrl: "https://mainnet.base.org",
         contracts: {
             eas: "0x4200000000000000000000000000000000000021",
             schema: "0x4200000000000000000000000000000000000020",
@@ -487,7 +476,6 @@ exports.Networks = {
     "polygon": {
         chainId: 137,
         url: "https://polygon.easscan.org/graphql",
-        rpcUrl: "https://polygon-rpc.com/",
         contracts: {
             eas: "0x5E634ef5355f45A855d02D66eCD687b1502AF790",
             schema: "0x7876EEF51A891E737AF8ba5A5E0f0Fd29073D5a7",

package/core/types.d.ts

@@ -31,6 +31,24 @@ export type TSchemaName = "Community" | "CommunityDetails" | "Grant" | "GrantDet
 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" | "custom";
 export type TNetwork = "optimism" | "celo" | "optimism-sepolia" | "arbitrum" | "sepolia" | "sei" | "sei-testnet" | "base-sepolia" | "lisk" | "scroll" | "base" | "polygon";
+/**
+ * Supported chain IDs for GAP SDK networks
+ */
+export type SupportedChainId = 10 | 11155420 | 42161 | 11155111 | 84532 | 42220 | 1328 | 1329 | 1135 | 534352 | 8453 | 137;
+/**
+ * RPC configuration for GAP SDK.
+ * Maps chain IDs to RPC URLs.
+ * Only configure the networks you need to use.
+ *
+ * @example
+ * ```typescript
+ * const rpcUrls: GAPRpcConfig = {
+ *   10: "https://opt-mainnet.g.alchemy.com/v2/YOUR_KEY",
+ *   42161: "https://arb-mainnet.g.alchemy.com/v2/YOUR_KEY",
+ * };
+ * ```
+ */
+export type GAPRpcConfig = Partial<Record<SupportedChainId, string>>;
 /**
  * Generic GAP Facade interface.
  * This supplies the GAP class with the necessary properties.
@@ -61,7 +79,6 @@ export interface MultiAttestData {
 export type MultiAttestPayload = [Attestation, RawMultiAttestPayload][];
 export interface EASNetworkConfig {
     url: string;
-    rpcUrl: string;
     chainId: number;
     contracts: {
         eas: Hex;
@@ -116,16 +133,3 @@ 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-web3-provider.d.ts

@@ -1,2 +1,17 @@
 import { ethers } from "ethers";
-export declare const getWeb3Provider: (chainId: number) => ethers.JsonRpcProvider;
+import { GAPRpcConfig } from "../types";
+/**
+ * Get a Web3 provider for a specific chain ID using the provided RPC configuration.
+ *
+ * @param chainId - The chain ID to get a provider for
+ * @param config - RPC URL configuration mapping chain IDs to RPC URLs
+ * @returns An ethers JsonRpcProvider for the specified chain
+ * @throws Error if no RPC URL is configured for the chain ID or if the URL is invalid
+ */
+export declare const getWeb3Provider: (chainId: number, config: GAPRpcConfig) => ethers.JsonRpcProvider;
+/**
+ * Clear all cached providers.
+ * Useful for testing or when reconfiguring the SDK.
+ * @internal - This is an internal function, not part of the public API.
+ */
+export declare const clearProviderCache: () => void;

package/core/utils/get-web3-provider.js

@@ -1,18 +1,58 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getWeb3Provider = void 0;
-const consts_1 = require("../consts");
+exports.clearProviderCache = exports.getWeb3Provider = void 0;
 const ethers_1 = require("ethers");
-const providers = {};
-const getWeb3Provider = (chainId) => {
-    const rpcUrl = Object.values(consts_1.Networks).find((n) => n.chainId === chainId)
-        ?.rpcUrl;
+/**
+ * Global provider cache keyed by "chainId:rpcUrl" to allow caching
+ * while supporting different RPC URLs for the same chain.
+ */
+const providers = new Map();
+/**
+ * Validate that a string is a valid URL.
+ * @internal
+ */
+const isValidUrl = (url) => {
+    try {
+        new URL(url);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+/**
+ * Get a Web3 provider for a specific chain ID using the provided RPC configuration.
+ *
+ * @param chainId - The chain ID to get a provider for
+ * @param config - RPC URL configuration mapping chain IDs to RPC URLs
+ * @returns An ethers JsonRpcProvider for the specified chain
+ * @throws Error if no RPC URL is configured for the chain ID or if the URL is invalid
+ */
+const getWeb3Provider = (chainId, config) => {
+    const rpcUrl = config[chainId];
     if (!rpcUrl) {
-        throw new Error(`No rpcUrl found for chainId ${chainId}`);
+        throw new Error(`RPC URL not configured for chain ${chainId}. ` +
+            `Please provide an RPC URL in the rpcUrls configuration when initializing GAP.`);
     }
-    if (!providers[chainId]) {
-        providers[chainId] = new ethers_1.ethers.JsonRpcProvider(rpcUrl);
+    if (!isValidUrl(rpcUrl)) {
+        throw new Error(`Invalid RPC URL for chain ${chainId}: "${rpcUrl}". ` +
+            `Please provide a valid URL (e.g., "https://mainnet.infura.io/v3/YOUR_KEY").`);
     }
-    return providers[chainId];
+    const cacheKey = `${chainId}:${rpcUrl}`;
+    let provider = providers.get(cacheKey);
+    if (!provider) {
+        provider = new ethers_1.ethers.JsonRpcProvider(rpcUrl);
+        providers.set(cacheKey, provider);
+    }
+    return provider;
 };
 exports.getWeb3Provider = getWeb3Provider;
+/**
+ * Clear all cached providers.
+ * Useful for testing or when reconfiguring the SDK.
+ * @internal - This is an internal function, not part of the public API.
+ */
+const clearProviderCache = () => {
+    providers.clear();
+};
+exports.clearProviderCache = clearProviderCache;

package/core/utils/index.d.ts

@@ -1,7 +1,7 @@
 export * from './gelato';
 export * from './get-date';
+export { clearProviderCache } from './get-web3-provider';
 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

@@ -14,10 +14,14 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearProviderCache = void 0;
 __exportStar(require("./gelato"), exports);
 __exportStar(require("./get-date"), exports);
+// Note: get-web3-provider functions are internal. Use gap.getProvider() instead.
+// clearProviderCache is exported only for testing purposes.
+var get_web3_provider_1 = require("./get-web3-provider");
+Object.defineProperty(exports, "clearProviderCache", { enumerable: true, get: function () { return get_web3_provider_1.clearProviderCache; } });
 __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,7 +3,7 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "0.4.19",
+    "version": "0.4.21",
     "description": "Simple and easy interface between EAS and Karma GAP.",
     "main": "./index.js",
     "author": "KarmaHQ",
@@ -14,6 +14,8 @@
         "type": "git"
     },
     "scripts": {
+        "build": "tsc -p tsconfig.json",
+        "test": "npx tsc -p tsconfig.json --noEmit",
         "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",

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

@@ -1,23 +0,0 @@
-import { RemoteStorage } from "./RemoteStorage";
-import { TRemoteStorageOutput } from "core/types";
-export interface IpfsStorageOptions {
-    token: string;
-}
-export declare class IpfsStorage extends RemoteStorage {
-    private pinataJWTToken;
-    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>;
-    saveAndGetCID(data: any, pinataMetadata?: {
-        name: string;
-    }): Promise<any>;
-}

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

@@ -1,56 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IpfsStorage = void 0;
-const RemoteStorage_1 = require("./RemoteStorage");
-const SchemaError_1 = require("../SchemaError");
-const utils_1 = require("../../utils");
-const axios_1 = __importDefault(require("axios"));
-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.pinataJWTToken = opts.token;
-    }
-    assert(opts) { }
-    async save(data) {
-        try {
-            const cid = await this.saveAndGetCID(data);
-            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);
-    }
-    async saveAndGetCID(data, pinataMetadata = { name: "via karma-gap-sdk" }) {
-        try {
-            const res = await axios_1.default.post("https://api.pinata.cloud/pinning/pinJSONToIPFS", {
-                pinataContent: data,
-                pinataMetadata: pinataMetadata,
-            }, {
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: `Bearer ${this.pinataJWTToken}`,
-                },
-            });
-            return res.data.IpfsHash;
-        }
-        catch (error) {
-            throw new SchemaError_1.RemoteStorageError("REMOTE_STORAGE_UPLOAD", `Error adding data to IPFS`);
-        }
-    }
-}
-exports.IpfsStorage = IpfsStorage;

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

@@ -1,41 +0,0 @@
-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

@@ -1,38 +0,0 @@
-"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/utils/get-ipfs-data.d.ts

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

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

@@ -1,19 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getIPFSData = getIPFSData;
-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}`);
-    }
-}