@show-karma/karma-gap-sdk 0.4.27 → 0.4.29

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

@@ -30,6 +30,7 @@ export declare class Milestone extends Attestation<IMilestone> implements IMiles
     completed: MilestoneCompleted;
     approved: MilestoneCompleted;
     rejected: MilestoneCompleted;
+    cancelled: MilestoneCompleted;
     verified: MilestoneCompleted[];
     type: string;
     priority?: number;
@@ -93,6 +94,23 @@ export declare class Milestone extends Attestation<IMilestone> implements IMiles
         tx: Transaction[];
         uids: `0x${string}`[];
     }>;
+    /**
+     * Cancels this milestone. A cancelled milestone will not be delivered and is
+     * kept, badged "cancelled", for the program's records. Only milestones that
+     * are not yet completed or verified can be cancelled.
+     * @param signer
+     * @param reason
+     */
+    cancel(signer: SignerOrProvider, reason?: string, callback?: Function): Promise<AttestationWithTx>;
+    /**
+     * Revokes the cancelled status of the milestone (un-cancel). If the milestone
+     * is not cancelled, it will throw an error.
+     * @param signer
+     */
+    revokeCancel(signer: SignerOrProvider): Promise<{
+        tx: Transaction[];
+        uids: `0x${string}`[];
+    }>;
     /**
      * Revokes multiple milestone attestations at once.
      * This method can be used to revoke multiple milestone attestations in a single transaction.

package/core/class/entities/Milestone.js

@@ -31,7 +31,7 @@ class Milestone extends Attestation_1.Attestation {
      * @param callback - Optional callback function for status updates
      */
     async edit(signer, newData, callback) {
-        if (this.completed || this.approved || this.verified?.length) {
+        if (this.completed || this.approved || this.verified?.length || this.cancelled) {
             throw new SchemaError_1.AttestationError("ATTEST_ERROR", "Cannot edit milestone that is not in PENDING state");
         }
         // Step 1: Revoke current attestation
@@ -216,6 +216,55 @@ class Milestone extends Attestation_1.Attestation {
         ]);
         return { tx, uids };
     }
+    /**
+     * Cancels this milestone. A cancelled milestone will not be delivered and is
+     * kept, badged "cancelled", for the program's records. Only milestones that
+     * are not yet completed or verified can be cancelled.
+     * @param signer
+     * @param reason
+     */
+    async cancel(signer, reason = "", callback) {
+        if (this.completed || this.verified?.length)
+            throw new SchemaError_1.AttestationError("ATTEST_ERROR", "Cannot cancel a completed or verified milestone");
+        if (this.cancelled)
+            throw new SchemaError_1.AttestationError("ATTEST_ERROR", "Milestone is already cancelled");
+        const schema = this.schema.gap.findSchema("MilestoneCompleted");
+        if (this.schema.isJsonSchema()) {
+            schema.setValue("json", JSON.stringify({ type: "cancelled", reason }));
+        }
+        else {
+            schema.setValue("type", "cancelled");
+            schema.setValue("reason", reason);
+        }
+        const { tx, uids } = await this.attestStatus(signer, schema, callback);
+        this.cancelled = new attestations_1.MilestoneCompleted({
+            data: {
+                type: "cancelled",
+                reason,
+            },
+            refUID: this.uid,
+            uid: uids?.[0],
+            schema: schema,
+            recipient: this.recipient,
+        });
+        return { tx, uids };
+    }
+    /**
+     * Revokes the cancelled status of the milestone (un-cancel). If the milestone
+     * is not cancelled, it will throw an error.
+     * @param signer
+     */
+    async revokeCancel(signer) {
+        if (!this.cancelled)
+            throw new SchemaError_1.AttestationError("ATTEST_ERROR", "Milestone is not cancelled");
+        const { tx, uids } = await this.cancelled.schema.multiRevoke(signer, [
+            {
+                schemaId: this.cancelled.schema.uid,
+                uid: this.cancelled.uid,
+            },
+        ]);
+        return { tx, uids };
+    }
     /**
      * Revokes multiple milestone attestations at once.
      * This method can be used to revoke multiple milestone attestations in a single transaction.
@@ -589,6 +638,16 @@ class Milestone extends Attestation_1.Attestation {
                     chainID: attestation.chainID,
                 });
             }
+            if (attestation.cancelled) {
+                milestone.cancelled = new attestations_1.MilestoneCompleted({
+                    ...attestation.cancelled,
+                    data: {
+                        ...attestation.cancelled.data,
+                    },
+                    schema: new AllGapSchemas_1.AllGapSchemas().findSchema("MilestoneCompleted", consts_1.chainIdToNetwork[attestation.chainID]),
+                    chainID: attestation.chainID,
+                });
+            }
             if (attestation.verified?.length > 0) {
                 milestone.verified = attestation.verified.map((m) => new attestations_1.MilestoneCompleted({
                     ...m,

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

@@ -50,6 +50,7 @@ export interface IMilestoneResponse extends IAttestationResponse {
     completed?: IMilestoneCompleted;
     approved?: IMilestoneCompleted;
     rejected?: IMilestoneCompleted;
+    cancelled?: IMilestoneCompleted;
     verified?: IMilestoneCompleted[];
     data: {
         title: string;

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

@@ -91,12 +91,12 @@ export declare class MemberDetails extends Attestation<IMemberDetails> implement
     profilePictureURL: string;
 }
 export interface IMilestoneCompleted {
-    type?: "approved" | "rejected" | "completed" | "verified";
+    type?: "approved" | "rejected" | "completed" | "verified" | "cancelled";
     reason?: string;
     proofOfWork?: string;
 }
 export declare class MilestoneCompleted extends Attestation<IMilestoneCompleted> implements IMilestoneCompleted {
-    type: "approved" | "rejected" | "completed" | "verified";
+    type: "approved" | "rejected" | "completed" | "verified" | "cancelled";
     reason?: string;
     proofOfWork?: string;
 }

package/package.json

@@ -3,7 +3,7 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "0.4.27",
+    "version": "0.4.29",
     "description": "Simple and easy interface between EAS and Karma.",
     "main": "./index.js",
     "author": "KarmaHQ",

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

@@ -1,20 +0,0 @@
-/**
- * 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

@@ -1,328 +0,0 @@
-"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/__tests__/received-date.types.test.d.ts

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

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

@@ -1,39 +0,0 @@
-"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/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}`);
-    }
-}