@show-karma/karma-gap-sdk 0.4.22 → 0.4.24

package/core/__tests__/Milestone.edit.test.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Tests for Milestone.edit() and Milestone.editCompletion() convenience methods.
+ *
+ * Phase 3: edit() performs revoke-and-re-attest for milestone definitions:
+ *   1. Guard: only PENDING milestones (no completed, approved, or verified)
+ *   2. Revoke the current attestation via this.revoke()
+ *   3. Update data via this.setValues() (merges old + new fields)
+ *   4. Re-attest via this.attest()
+ *
+ * Phase 4: editCompletion() performs revoke-and-re-complete for completed milestones:
+ *   1. Guard: must be COMPLETED but not APPROVED or VERIFIED
+ *   2. Revoke current completion via this.revokeCompletion()
+ *   3. Re-complete with updated data via this.complete()
+ *
+ * Since the SDK has no Jest config, these tests define the behavioral contract.
+ * They simulate the methods' behavior to validate the expected flow without
+ * requiring the full EAS/blockchain dependency chain. When a Jest config is added,
+ * they will become directly runnable.
+ */
+export {};

package/core/__tests__/Milestone.edit.test.js

@@ -0,0 +1,328 @@
+"use strict";
+/**
+ * Tests for Milestone.edit() and Milestone.editCompletion() convenience methods.
+ *
+ * Phase 3: edit() performs revoke-and-re-attest for milestone definitions:
+ *   1. Guard: only PENDING milestones (no completed, approved, or verified)
+ *   2. Revoke the current attestation via this.revoke()
+ *   3. Update data via this.setValues() (merges old + new fields)
+ *   4. Re-attest via this.attest()
+ *
+ * Phase 4: editCompletion() performs revoke-and-re-complete for completed milestones:
+ *   1. Guard: must be COMPLETED but not APPROVED or VERIFIED
+ *   2. Revoke current completion via this.revokeCompletion()
+ *   3. Re-complete with updated data via this.complete()
+ *
+ * Since the SDK has no Jest config, these tests define the behavioral contract.
+ * They simulate the methods' behavior to validate the expected flow without
+ * requiring the full EAS/blockchain dependency chain. When a Jest config is added,
+ * they will become directly runnable.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+// ---------------------------------------------------------------------------
+// Phase 3: Milestone.edit()
+// ---------------------------------------------------------------------------
+describe("Milestone.edit()", () => {
+    let mockSigner;
+    beforeEach(() => {
+        mockSigner = {};
+    });
+    /**
+     * Creates a test milestone simulating the real Milestone class behavior.
+     * Uses revoke() + setValues() + attest() internally, matching the actual
+     * implementation in core/class/entities/Milestone.ts.
+     */
+    function createTestMilestone(overrides) {
+        const revokeMock = jest.fn().mockResolvedValue({ tx: {}, uids: [] });
+        const attestMock = jest.fn().mockResolvedValue({
+            tx: { hash: "0xTxHash" },
+            uids: ["0xNewUID"]
+        });
+        const setValuesMock = jest.fn();
+        const milestone = {
+            uid: "0xOldMilestoneUID",
+            title: "Original Title",
+            description: "Original Description",
+            endsAt: 1735689600,
+            startsAt: 1704067200,
+            type: "milestone",
+            completed: overrides?.completed || undefined,
+            approved: overrides?.approved || undefined,
+            verified: overrides?.verified || [],
+            recipient: "0xRecipient",
+            data: {
+                title: "Original Title",
+                description: "Original Description",
+                endsAt: 1735689600,
+                startsAt: 1704067200
+            },
+            // Mock methods matching real Attestation class
+            revoke: revokeMock,
+            attest: attestMock,
+            setValues: setValuesMock,
+            // Expose mocks for assertions
+            _mocks: { revoke: revokeMock, attest: attestMock, setValues: setValuesMock }
+        };
+        // Simulate the edit method matching the real implementation
+        milestone.edit = async function (signer, newData, callback) {
+            // Guard: only PENDING milestones
+            if (this.completed || this.approved || (this.verified && this.verified.length > 0)) {
+                throw new Error("Cannot edit milestone that is not in PENDING state");
+            }
+            // Step 1: Revoke current attestation
+            await this.revoke(signer, callback);
+            // Step 2: Update data with new fields
+            const updatedData = { ...this.data, ...newData };
+            this.setValues(updatedData);
+            // Step 3: Re-attest with updated data
+            return this.attest(signer, callback);
+        };
+        return milestone;
+    }
+    describe("successful edit (PENDING milestone)", () => {
+        it("should call revoke on current attestation, then re-attest", async () => {
+            const milestone = createTestMilestone();
+            await milestone.edit(mockSigner, {
+                title: "Updated Title",
+                description: "Updated Description"
+            });
+            expect(milestone._mocks.revoke).toHaveBeenCalledTimes(1);
+            expect(milestone._mocks.revoke).toHaveBeenCalledWith(mockSigner, undefined);
+            expect(milestone._mocks.attest).toHaveBeenCalledTimes(1);
+            expect(milestone._mocks.attest).toHaveBeenCalledWith(mockSigner, undefined);
+        });
+        it("should call setValues with merged data (old + new)", async () => {
+            const milestone = createTestMilestone();
+            await milestone.edit(mockSigner, {
+                title: "New Title"
+            });
+            expect(milestone._mocks.setValues).toHaveBeenCalledTimes(1);
+            expect(milestone._mocks.setValues).toHaveBeenCalledWith(expect.objectContaining({
+                title: "New Title",
+                description: "Original Description",
+                endsAt: 1735689600,
+                startsAt: 1704067200
+            }));
+        });
+        it("should preserve unchanged fields during partial update", async () => {
+            const milestone = createTestMilestone();
+            await milestone.edit(mockSigner, {
+                title: "New Title Only"
+            });
+            const setValuesArg = milestone._mocks.setValues.mock.calls[0][0];
+            expect(setValuesArg.description).toBe("Original Description");
+            expect(setValuesArg.endsAt).toBe(1735689600);
+            expect(setValuesArg.startsAt).toBe(1704067200);
+        });
+        it("should update all supported fields when fully provided", async () => {
+            const milestone = createTestMilestone();
+            await milestone.edit(mockSigner, {
+                title: "New Title",
+                description: "New Description",
+                endsAt: 1767225600,
+                startsAt: 1735689600,
+                priority: 1
+            });
+            const setValuesArg = milestone._mocks.setValues.mock.calls[0][0];
+            expect(setValuesArg.title).toBe("New Title");
+            expect(setValuesArg.description).toBe("New Description");
+            expect(setValuesArg.endsAt).toBe(1767225600);
+            expect(setValuesArg.startsAt).toBe(1735689600);
+            expect(setValuesArg.priority).toBe(1);
+        });
+        it("should return the result from attest()", async () => {
+            const milestone = createTestMilestone();
+            const result = await milestone.edit(mockSigner, { title: "New" });
+            expect(result).toEqual({
+                tx: { hash: "0xTxHash" },
+                uids: ["0xNewUID"]
+            });
+        });
+    });
+    describe("state guards", () => {
+        it("should throw for COMPLETED milestones", async () => {
+            const milestone = createTestMilestone({
+                completed: {
+                    uid: "0xCompletedUID",
+                    data: { type: "completed", reason: "Done" }
+                }
+            });
+            await expect(milestone.edit(mockSigner, { title: "Nope" })).rejects.toThrow("Cannot edit milestone that is not in PENDING state");
+            expect(milestone._mocks.revoke).not.toHaveBeenCalled();
+        });
+        it("should throw for APPROVED milestones", async () => {
+            const milestone = createTestMilestone({
+                approved: {
+                    uid: "0xApprovedUID",
+                    data: { type: "approved", reason: "Good" }
+                }
+            });
+            await expect(milestone.edit(mockSigner, { title: "Nope" })).rejects.toThrow("Cannot edit milestone that is not in PENDING state");
+        });
+        it("should throw for VERIFIED milestones (verified.length > 0)", async () => {
+            const milestone = createTestMilestone({
+                verified: [
+                    {
+                        uid: "0xVerifiedUID",
+                        data: { type: "verified", reason: "Verified" }
+                    }
+                ]
+            });
+            await expect(milestone.edit(mockSigner, { title: "Nope" })).rejects.toThrow("Cannot edit milestone that is not in PENDING state");
+        });
+        it("should allow edit when completed/approved/verified are all falsy/empty", async () => {
+            const milestone = createTestMilestone({
+                completed: undefined,
+                approved: undefined,
+                verified: []
+            });
+            await expect(milestone.edit(mockSigner, { title: "Allowed" })).resolves.not.toThrow();
+            expect(milestone._mocks.revoke).toHaveBeenCalledTimes(1);
+            expect(milestone._mocks.attest).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe("execution order", () => {
+        it("should call revoke BEFORE setValues and attest (correct ordering)", async () => {
+            const callOrder = [];
+            const milestone = createTestMilestone();
+            milestone._mocks.revoke.mockImplementation(async () => {
+                callOrder.push("revoke");
+                return { tx: {}, uids: [] };
+            });
+            milestone._mocks.setValues.mockImplementation(() => {
+                callOrder.push("setValues");
+            });
+            milestone._mocks.attest.mockImplementation(async () => {
+                callOrder.push("attest");
+                return { tx: {}, uids: ["0xNew"] };
+            });
+            await milestone.edit(mockSigner, {
+                title: "New"
+            });
+            expect(callOrder).toEqual(["revoke", "setValues", "attest"]);
+        });
+    });
+});
+// ---------------------------------------------------------------------------
+// Phase 4: Milestone.editCompletion()
+// ---------------------------------------------------------------------------
+describe("Milestone.editCompletion()", () => {
+    let mockSigner;
+    beforeEach(() => {
+        mockSigner = {};
+    });
+    /**
+     * Creates a test milestone with completion data for testing editCompletion().
+     */
+    function createCompletedMilestone(overrides) {
+        const revokeCompletionMock = jest
+            .fn()
+            .mockResolvedValue({ tx: {}, uids: [] });
+        const completeMock = jest.fn().mockResolvedValue({
+            tx: { hash: "0xCompletionTxHash" },
+            uids: ["0xNewCompletionUID"]
+        });
+        const milestone = {
+            uid: "0xMilestoneUID",
+            completed: {
+                uid: "0xOldCompletionUID",
+                data: {
+                    reason: "Original completion reason",
+                    proofOfWork: "https://example.com/original-proof"
+                }
+            },
+            approved: overrides?.approved || undefined,
+            verified: overrides?.verified || [],
+            revokeCompletion: revokeCompletionMock,
+            complete: completeMock,
+            _mocks: { revokeCompletion: revokeCompletionMock, complete: completeMock }
+        };
+        // Simulate editCompletion matching real implementation
+        milestone.editCompletion = async function (signer, newData, callback) {
+            if (!this.completed) {
+                throw new Error("Milestone is not completed");
+            }
+            if (this.approved) {
+                throw new Error("Cannot edit completion of an approved milestone");
+            }
+            if (this.verified && this.verified.length > 0) {
+                throw new Error("Cannot edit completion of a verified milestone");
+            }
+            await this.revokeCompletion(signer, callback);
+            const completionData = {
+                reason: newData.reason ?? this.completed?.data?.reason ?? "",
+                proofOfWork: newData.proofOfWork ?? this.completed?.data?.proofOfWork ?? ""
+            };
+            return this.complete(signer, completionData, callback);
+        };
+        return milestone;
+    }
+    describe("successful editCompletion", () => {
+        it("should revoke old completion and re-complete with updated data", async () => {
+            const milestone = createCompletedMilestone();
+            await milestone.editCompletion(mockSigner, {
+                reason: "Updated completion reason",
+                proofOfWork: "https://example.com/updated-proof"
+            });
+            expect(milestone._mocks.revokeCompletion).toHaveBeenCalledTimes(1);
+            expect(milestone._mocks.complete).toHaveBeenCalledTimes(1);
+            expect(milestone._mocks.complete).toHaveBeenCalledWith(mockSigner, {
+                reason: "Updated completion reason",
+                proofOfWork: "https://example.com/updated-proof"
+            }, undefined);
+        });
+        it("should preserve unchanged fields from original completion", async () => {
+            const milestone = createCompletedMilestone();
+            // Only update reason, proofOfWork should be preserved from original
+            await milestone.editCompletion(mockSigner, {
+                reason: "New reason only"
+            });
+            expect(milestone._mocks.complete).toHaveBeenCalledWith(mockSigner, {
+                reason: "New reason only",
+                proofOfWork: "https://example.com/original-proof"
+            }, undefined);
+        });
+        it("should return the result from complete()", async () => {
+            const milestone = createCompletedMilestone();
+            const result = await milestone.editCompletion(mockSigner, { reason: "Updated" });
+            expect(result).toEqual({
+                tx: { hash: "0xCompletionTxHash" },
+                uids: ["0xNewCompletionUID"]
+            });
+        });
+    });
+    describe("state guards", () => {
+        it("should throw if milestone is not completed", async () => {
+            const milestone = createCompletedMilestone();
+            milestone.completed = undefined;
+            await expect(milestone.editCompletion(mockSigner, {
+                reason: "Nope"
+            })).rejects.toThrow("Milestone is not completed");
+            expect(milestone._mocks.revokeCompletion).not.toHaveBeenCalled();
+        });
+        it("should throw if milestone is approved", async () => {
+            const milestone = createCompletedMilestone({
+                approved: {
+                    uid: "0xApprovedUID",
+                    data: { type: "approved", reason: "Approved" }
+                }
+            });
+            await expect(milestone.editCompletion(mockSigner, {
+                reason: "Nope"
+            })).rejects.toThrow("Cannot edit completion of an approved milestone");
+        });
+        it("should throw if milestone is verified", async () => {
+            const milestone = createCompletedMilestone({
+                verified: [
+                    {
+                        uid: "0xVerifiedUID",
+                        data: { type: "verified" }
+                    }
+                ]
+            });
+            await expect(milestone.editCompletion(mockSigner, {
+                reason: "Nope"
+            })).rejects.toThrow("Cannot edit completion of a verified milestone");
+        });
+    });
+});

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

@@ -33,6 +33,27 @@ export declare class Milestone extends Attestation<IMilestone> implements IMiles
     verified: MilestoneCompleted[];
     type: string;
     priority?: number;
+    /**
+     * Edits this milestone by revoking the current attestation and re-attesting with updated data.
+     * Only milestones in PENDING state (not completed, approved, or verified) can be edited.
+     * @param signer - The signer to use for revocation and re-attestation
+     * @param newData - Partial milestone data to update (only provided fields are overridden)
+     * @param callback - Optional callback function for status updates
+     */
+    edit(signer: SignerOrProvider, newData: Partial<IMilestone>, callback?: Function): Promise<AttestationWithTx>;
+    /**
+     * Edits the completion of this milestone by revoking the current completion
+     * attestation and re-completing with updated data.
+     * Only milestones in COMPLETED state (not yet approved or verified) can have
+     * their completion edited.
+     * @param signer - The signer to use for revocation and re-attestation
+     * @param newData - Updated completion data (reason and/or proofOfWork)
+     * @param callback - Optional callback function for status updates
+     */
+    editCompletion(signer: SignerOrProvider, newData: {
+        reason?: string;
+        proofOfWork?: string;
+    }, callback?: Function): Promise<AttestationWithTx>;
     /**
      * Approves this milestone. If the milestone is not completed or already approved,
      * it will throw an error.

package/core/class/entities/Milestone.js

@@ -23,6 +23,53 @@ class Milestone extends Attestation_1.Attestation {
         this.verified = [];
         this.type = "milestone";
     }
+    /**
+     * Edits this milestone by revoking the current attestation and re-attesting with updated data.
+     * Only milestones in PENDING state (not completed, approved, or verified) can be edited.
+     * @param signer - The signer to use for revocation and re-attestation
+     * @param newData - Partial milestone data to update (only provided fields are overridden)
+     * @param callback - Optional callback function for status updates
+     */
+    async edit(signer, newData, callback) {
+        if (this.completed || this.approved || this.verified?.length) {
+            throw new SchemaError_1.AttestationError("ATTEST_ERROR", "Cannot edit milestone that is not in PENDING state");
+        }
+        // Step 1: Revoke current attestation
+        await this.revoke(signer, callback);
+        // Step 2: Update data with new fields
+        const updatedData = { ...this.data, ...newData };
+        this.setValues(updatedData);
+        // Step 3: Re-attest with updated data
+        return this.attest(signer, callback);
+    }
+    /**
+     * Edits the completion of this milestone by revoking the current completion
+     * attestation and re-completing with updated data.
+     * Only milestones in COMPLETED state (not yet approved or verified) can have
+     * their completion edited.
+     * @param signer - The signer to use for revocation and re-attestation
+     * @param newData - Updated completion data (reason and/or proofOfWork)
+     * @param callback - Optional callback function for status updates
+     */
+    async editCompletion(signer, newData, callback) {
+        if (!this.completed) {
+            throw new SchemaError_1.AttestationError("ATTEST_ERROR", "Milestone is not completed");
+        }
+        if (this.approved) {
+            throw new SchemaError_1.AttestationError("ATTEST_ERROR", "Cannot edit completion of an approved milestone");
+        }
+        if (this.verified?.length) {
+            throw new SchemaError_1.AttestationError("ATTEST_ERROR", "Cannot edit completion of a verified milestone");
+        }
+        // Step 1: Revoke current completion attestation
+        await this.revokeCompletion(signer, callback);
+        // Step 2: Re-complete with updated data
+        const completionData = {
+            reason: newData.reason ?? this.completed?.data?.reason ?? "",
+            proofOfWork: newData.proofOfWork ?? this.completed?.data?.proofOfWork ?? "",
+        };
+        return this.complete(signer, completionData, callback);
+    }
     /**
      * Approves this milestone. If the milestone is not completed or already approved,
      * it will throw an error.

package/core/class/entities/Project.js

@@ -67,10 +67,10 @@ class Project extends Attestation_1.Attestation {
         return { tx: txArray, uids: [this.uid] };
     }
     isOwner(signer, publicAddress) {
-        return GapContract_1.GapContract.isProjectOwner(signer, this.uid, this.chainID, publicAddress);
+        return GapContract_1.GapContract.isProjectOwner(signer, this.uid, this.chainID, publicAddress, this.schema.gap.rpcConfig);
     }
     isAdmin(signer, publicAddress) {
-        return GapContract_1.GapContract.isProjectAdmin(signer, this.uid, this.chainID, publicAddress);
+        return GapContract_1.GapContract.isProjectAdmin(signer, this.uid, this.chainID, publicAddress, this.schema.gap.rpcConfig);
     }
     /**
      * Add new members to the project.

package/package.json

@@ -3,8 +3,8 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "0.4.22",
-    "description": "Simple and easy interface between EAS and Karma GAP.",
+    "version": "0.4.24",
+    "description": "Simple and easy interface between EAS and Karma.",
     "main": "./index.js",
     "author": "KarmaHQ",
     "license": "MIT",

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}`);
-    }
-}