@show-karma/karma-gap-sdk 0.3.43 → 0.3.44

package/core/class/Attestation.d.ts

@@ -2,6 +2,7 @@ import { Hex, IAttestation, JSONStr, MultiAttestData, SignerOrProvider, TNetwork
 import { Schema } from "./Schema";
 import { SchemaItem, SchemaValue } from "@ethereum-attestation-service/eas-sdk";
 import { GapSchema } from "./GapSchema";
+import { AttestationWithTx } from "./types/attestations";
 export interface AttestationArgs<T = unknown, S extends Schema = Schema> {
     data: T | string;
     schema: S;
@@ -88,7 +89,7 @@ export declare class Attestation<T = unknown, S extends Schema = GapSchema> impl
      * @param signer
      * @returns
      */
-    revoke(signer: SignerOrProvider, callback?: Function): Promise<void>;
+    revoke(signer: SignerOrProvider, callback?: Function): Promise<AttestationWithTx>;
     /**
      * Attests the data using the specified signer and schema.
      * @param signer - The signer or provider to use for attestation.
@@ -96,7 +97,7 @@ export declare class Attestation<T = unknown, S extends Schema = GapSchema> impl
      * @returns A Promise that resolves to the UID of the attestation.
      * @throws An `AttestationError` if an error occurs during attestation.
      */
-    attest(signer: SignerOrProvider, ...args: unknown[]): Promise<void>;
+    attest(signer: SignerOrProvider, ...args: unknown[]): Promise<AttestationWithTx>;
     /**
      * Validates the payload.
      *

package/core/class/Attestation.js

@@ -104,7 +104,7 @@ class Attestation {
     async revoke(signer, callback) {
         try {
             callback?.("preparing");
-            return GapContract_1.GapContract.multiRevoke(signer, [
+            const { tx } = await GapContract_1.GapContract.multiRevoke(signer, [
                 {
                     data: [
                         {
@@ -114,13 +114,15 @@ class Attestation {
                     ],
                     schema: this.schema.uid,
                 },
-            ]).then(() => {
+            ]).then((res) => {
                 callback?.("confirmed");
+                return res;
             });
+            return { tx, uids: [this.uid] };
         }
         catch (error) {
             console.error(error);
-            throw new SchemaError_1.SchemaError("REVOKE_ERROR", "Error revoking attestation.");
+            throw new SchemaError_1.SchemaError("REVOKE_ERROR", "Error revoking attestation.", error);
         }
     }
     /**
@@ -136,19 +138,20 @@ class Attestation {
             : null;
         console.log(`Attesting ${this.schema.name}`);
         try {
-            const uid = await this.schema.attest({
+            const { tx, uids } = await this.schema.attest({
                 data: this.data,
                 to: this.recipient,
                 refUID: this.refUID,
                 signer,
                 callback: callback,
             });
-            this._uid = uid;
-            console.log(`Attested ${this.schema.name} with UID ${uid}`);
+            this._uid = uids[0];
+            console.log(`Attested ${this.schema.name} with UID ${this.uid}`);
+            return { tx, uids };
         }
         catch (error) {
             console.error(error);
-            throw new SchemaError_1.AttestationError("ATTEST_ERROR", "Error during attestation.");
+            throw new SchemaError_1.AttestationError("ATTEST_ERROR", "Error during attestation.", error);
         }
     }
     /**
@@ -255,7 +258,7 @@ class Attestation {
         }
         catch (error) {
             console.error(error);
-            throw new SchemaError_1.SchemaError("INVALID_DATA", "Data must be a valid JSON string.");
+            throw new SchemaError_1.SchemaError("INVALID_DATA", "Data must be a valid JSON string.", error);
         }
     }
     /**

package/core/class/GAP.d.ts

@@ -167,7 +167,7 @@ export declare class GAP extends Facade {
      */
     attest<T>(attestation: AttestArgs<T> & {
         schemaName: TSchemaName;
-    }): Promise<`0x${string}`>;
+    }): Promise<import("..").AttestationWithTx>;
     /**
      * Replaces the schema list with a new list.
      * @param schemas

package/core/class/GapSchema.js

@@ -17,6 +17,7 @@ class GapSchema extends Schema_1.Schema {
                 uid: args.uid,
                 references: args.references,
                 revocable: args.revocable,
+                oldSchemas: args.oldSchemas,
             }, gap, strict, true));
     }
     /**

package/core/class/GraphQL/GapEasClient.d.ts

@@ -1,10 +1,10 @@
-import { Attestation } from '../Attestation';
-import { EASNetworkConfig, Hex, IAttestation, TNetwork, TSchemaName } from '../../types';
-import { Grantee } from '../types/attestations';
-import { GapSchema } from '../GapSchema';
-import { Grant, Milestone, Project, MemberOf } from '../entities';
-import { Community } from '../entities/Community';
-import { Fetcher } from '../Fetcher';
+import { Attestation } from "../Attestation";
+import { EASNetworkConfig, Hex, IAttestation, TNetwork, TSchemaName } from "../../types";
+import { Grantee } from "../types/attestations";
+import { GapSchema } from "../GapSchema";
+import { Grant, Milestone, Project, MemberOf } from "../entities";
+import { Community } from "../entities/Community";
+import { Fetcher } from "../Fetcher";
 interface EASClientProps {
     network: TNetwork;
 }

package/core/class/GraphQL/GapEasClient.js

@@ -28,7 +28,7 @@ class GapEasClient extends Fetcher_1.Fetcher {
         const query = gql_queries_1.gqlQueries.schemata(owner);
         const { schemata } = await this.query(query);
         return schemata.map((schema) => new GapSchema_1.GapSchema({
-            name: '',
+            name: "",
             schema: Schema_1.Schema.rawToObject(schema.schema),
             uid: schema.uid,
         }, this.gap));
@@ -65,15 +65,15 @@ class GapEasClient extends Fetcher_1.Fetcher {
         const parent = this.gap.findSchema(parentSchema);
         const children = parent.children.map((c) => c.uid);
         if (!children.length)
-            throw new SchemaError_1.SchemaError('INVALID_REFERENCE', `Schema ${parentSchema} has no children.`);
+            throw new SchemaError_1.SchemaError("INVALID_REFERENCE", `Schema ${parentSchema} has no children.`);
         const query = gql_queries_1.gqlQueries.dependentsOf(parentUid, children);
         const { attestations } = await this.query(query);
         return Attestation_1.Attestation.fromInterface(attestations, this.network.name);
     }
     async communities(search) {
         const [community, communityDetails] = this.gap.findManySchemas([
-            'Community',
-            'CommunityDetails',
+            "Community",
+            "CommunityDetails",
         ]);
         const query = gql_queries_1.gqlQueries.attestationsOf(community.uid, search);
         const { schema: { attestations }, } = await this.query(query);
@@ -83,7 +83,7 @@ class GapEasClient extends Fetcher_1.Fetcher {
         return this.communitiesDetails(communities);
     }
     async communitiesOf(address) {
-        const [community] = this.gap.findManySchemas(['Community']);
+        const [community] = this.gap.findManySchemas(["Community"]);
         const query = gql_queries_1.gqlQueries.attestationsTo(community.uid, address);
         const { schema: { attestations }, } = await this.query(query);
         const communities = Attestation_1.Attestation.fromInterface(attestations, this.network.name);
@@ -92,7 +92,7 @@ class GapEasClient extends Fetcher_1.Fetcher {
         return this.communitiesDetails(communities);
     }
     async communitiesAdminOf(address) {
-        const [community] = this.gap.findManySchemas(['Community']);
+        const [community] = this.gap.findManySchemas(["Community"]);
         const query = gql_queries_1.gqlQueries.attestationsTo(community.uid, address);
         const { schema: { attestations }, } = await this.query(query);
         const communities = Attestation_1.Attestation.fromInterface(attestations, this.network.name);
@@ -103,7 +103,7 @@ class GapEasClient extends Fetcher_1.Fetcher {
     async communitiesByIds(uids) {
         if (!uids.length)
             return [];
-        const communityDetails = this.gap.findSchema('CommunityDetails');
+        const communityDetails = this.gap.findSchema("CommunityDetails");
         const communityQuery = gql_queries_1.gqlQueries.attestationsIn(uids);
         const detailsQuery = gql_queries_1.gqlQueries.dependentsOf(uids, [communityDetails.uid]);
         try {
@@ -124,8 +124,8 @@ class GapEasClient extends Fetcher_1.Fetcher {
     }
     async communitiesDetails(communities) {
         const [project, communityDetails] = this.gap.findManySchemas([
-            'Project',
-            'CommunityDetails',
+            "Project",
+            "CommunityDetails",
         ]);
         const ref = gql_queries_1.gqlQueries.dependentsOf(communities.map((c) => c.uid), [communityDetails.uid]);
         const results = await this.query(ref);
@@ -138,12 +138,12 @@ class GapEasClient extends Fetcher_1.Fetcher {
         });
     }
     async communityBySlug(slug) {
-        const communitySchema = this.gap.findSchema('CommunityDetails');
-        const query = gql_queries_1.gqlQueries.attestationsOf(communitySchema.uid, this.getSearchFieldString('slug', slug));
+        const communitySchema = this.gap.findSchema("CommunityDetails");
+        const query = gql_queries_1.gqlQueries.attestationsOf(communitySchema.uid, this.getSearchFieldString("slug", slug));
         try {
             const { schema: { attestations }, } = await this.query(query);
             if (!attestations.length)
-                throw new Error('Community not found.');
+                throw new Error("Community not found.");
             const communities = (0, utils_1.mapFilter)(Attestation_1.Attestation.fromInterface(attestations, this.network.name), (details) => !!details.name, (details) => {
                 const community = new Community_1.Community({
                     data: { community: true },
@@ -156,7 +156,7 @@ class GapEasClient extends Fetcher_1.Fetcher {
             });
             const [withDetails] = await this.communitiesDetails(communities);
             if (!withDetails)
-                throw new Error('Community not found.');
+                throw new Error("Community not found.");
             const grants = await this.grantsByCommunity(withDetails.uid);
             withDetails.grants = grants;
             return withDetails;
@@ -169,11 +169,11 @@ class GapEasClient extends Fetcher_1.Fetcher {
         const query = gql_queries_1.gqlQueries.attestation(uid);
         const { attestation } = await this.query(query);
         if (!attestation)
-            throw new Error('Community not found.');
+            throw new Error("Community not found.");
         const communities = Attestation_1.Attestation.fromInterface([attestation], this.network.name).map((c) => new Community_1.Community(c));
         const [withDetails] = await this.communitiesDetails(communities);
         if (!withDetails)
-            throw new Error('Community not found.');
+            throw new Error("Community not found.");
         const grants = await this.grantsByCommunity(uid);
         withDetails.grants = grants;
         return withDetails;
@@ -186,7 +186,7 @@ class GapEasClient extends Fetcher_1.Fetcher {
      */
     async projectsDetails(projects) {
         // Get projects array and fetch details, members, grants, etc then append to the project and return the array.
-        const [projectDetails] = this.gap.findManySchemas(['ProjectDetails']);
+        const [projectDetails] = this.gap.findManySchemas(["ProjectDetails"]);
         const refQuery = gql_queries_1.gqlQueries.dependentsOf(projects.map((p) => p.uid), [projectDetails.uid]);
         const [result, members, grants] = await Promise.all([
             this.query(refQuery),
@@ -205,7 +205,7 @@ class GapEasClient extends Fetcher_1.Fetcher {
         const query = gql_queries_1.gqlQueries.attestation(uid);
         const { attestation } = await this.query(query);
         if (!attestation)
-            throw new Error('Project not found.');
+            throw new Error("Project not found.");
         const projectAttestation = Attestation_1.Attestation.fromInterface([attestation], this.network.name)[0];
         const [result] = await this.projectsDetails([
             new entities_1.Project(projectAttestation),
@@ -213,44 +213,44 @@ class GapEasClient extends Fetcher_1.Fetcher {
         return result;
     }
     async projectBySlug(slug) {
-        const projectDetails = this.gap.findSchema('ProjectDetails');
-        const query = gql_queries_1.gqlQueries.attestationsOf(projectDetails.uid, this.getSearchFieldString('slug', slug));
+        const projectDetails = this.gap.findSchema("ProjectDetails");
+        const query = gql_queries_1.gqlQueries.attestationsOf(projectDetails.uid, this.getSearchFieldString("slug", slug));
         const { schema: { attestations }, } = await this.query(query);
         const projectAttestations = Attestation_1.Attestation.fromInterface(attestations, this.network.name).filter((p) => p.title);
         if (!projectAttestations.length)
-            throw new Error('Project not found.');
+            throw new Error("Project not found.");
         const project = new entities_1.Project({
             data: { project: true },
             uid: projectAttestations[0].refUID,
-            schema: this.gap.findSchema('Project'),
+            schema: this.gap.findSchema("Project"),
             recipient: projectAttestations[0].recipient,
         });
         const [withDetails] = await this.projectsDetails([project]);
         if (!withDetails)
-            throw new Error('Project not found.');
+            throw new Error("Project not found.");
         return withDetails;
     }
     async slugExists(slug) {
-        const details = this.gap.findSchema('ProjectDetails');
-        const query = gql_queries_1.gqlQueries.attestationsOf(details.uid, 'slug');
+        const details = this.gap.findSchema("ProjectDetails");
+        const query = gql_queries_1.gqlQueries.attestationsOf(details.uid, "slug");
         const { schema: { attestations }, } = await this.query(query);
         return attestations.some((a) => a.decodedDataJson.includes(slug));
     }
     search(query) {
-        throw new Error('Method not implemented.');
+        throw new Error("Method not implemented.");
     }
     searchProjects(query) {
-        throw new Error('Method not implemented.');
+        throw new Error("Method not implemented.");
     }
     async projects(name) {
-        const result = await this.attestations('Project', name);
+        const result = await this.attestations("Project", name);
         if (!result.length)
             return [];
         const projects = Attestation_1.Attestation.fromInterface(result, this.network.name);
         return this.projectsDetails(projects);
     }
     async projectsOf(grantee) {
-        const result = await this.attestationsTo('Project', grantee);
+        const result = await this.attestationsTo("Project", grantee);
         if (!result.length)
             return [];
         const projects = Attestation_1.Attestation.fromInterface(result, this.network.name);
@@ -273,9 +273,9 @@ class GapEasClient extends Fetcher_1.Fetcher {
     }
     async grantsOf(grantee, withCommunity) {
         const [grant, grantDetails, grantVerified] = this.gap.findManySchemas([
-            'Grant',
-            'GrantDetails',
-            'GrantVerified',
+            "Grant",
+            "GrantDetails",
+            "GrantVerified",
         ]);
         const query = gql_queries_1.gqlQueries.attestationsTo(grant.uid, grantee);
         const { schema: { attestations }, } = await this.query(query);
@@ -294,16 +294,16 @@ class GapEasClient extends Fetcher_1.Fetcher {
             grant.verified = !!refs.find((ref) => ref.schema.uid === grantVerified.uid && ref.refUID === grant.uid);
             grant.details = (refs.find((ref) => ref.schema.uid === grantDetails.uid &&
                 ref.refUID === grant.uid &&
-                typeof ref.endsAt === 'undefined'));
-            grant.milestones = milestones.filter((m) => m.refUID === grant.uid && typeof m.endsAt !== 'undefined');
+                typeof ref.endsAt === "undefined"));
+            grant.milestones = milestones.filter((m) => m.refUID === grant.uid && typeof m.endsAt !== "undefined");
             grant.community = communities.find((c) => c.uid === grant.communityUID);
             return grant;
         });
         return this.grantsUpdates(withDetails);
     }
     async grantsUpdates(grants) {
-        const details = this.gap.findSchema('GrantDetails');
-        const query = gql_queries_1.gqlQueries.attestationsOf(details.uid, this.getSearchFieldString('type', 'grant-update'), grants.map((g) => g.uid));
+        const details = this.gap.findSchema("GrantDetails");
+        const query = gql_queries_1.gqlQueries.attestationsOf(details.uid, this.getSearchFieldString("type", "grant-update"), grants.map((g) => g.uid));
         const { schema: { attestations }, } = await this.query(query);
         const updates = Attestation_1.Attestation.fromInterface(attestations, this.network.name);
         return grants.map((grant) => {
@@ -313,10 +313,10 @@ class GapEasClient extends Fetcher_1.Fetcher {
     }
     async grantsByCommunity(uid) {
         const [grant, grantDetails, project, projectDetails] = this.gap.findManySchemas([
-            'Grant',
-            'GrantDetails',
-            'Project',
-            'ProjectDetails',
+            "Grant",
+            "GrantDetails",
+            "Project",
+            "ProjectDetails",
         ]);
         const query = gql_queries_1.gqlQueries.attestations(grant.uid, uid);
         const { schema: { attestations }, } = await this.query(query);
@@ -341,10 +341,10 @@ class GapEasClient extends Fetcher_1.Fetcher {
             grant.details = (deps.find((d) => d.refUID === grant.uid &&
                 d.schema.uid === grantDetails.uid &&
                 typeof d.amount !== undefined &&
-                typeof d.endsAt === 'undefined' &&
-                typeof d.data.type === 'undefined'));
+                typeof d.endsAt === "undefined" &&
+                typeof d.data.type === "undefined"));
             grant.milestones = milestones
-                .filter((m) => m.refUID === grant.uid && typeof m.endsAt !== 'undefined')
+                .filter((m) => m.refUID === grant.uid && typeof m.endsAt !== "undefined")
                 .sort((a, b) => a.endsAt - b.endsAt);
             grant.updates = deps.filter((d) => d.data.type && d.refUID === grant.uid);
             return grant;
@@ -353,11 +353,11 @@ class GapEasClient extends Fetcher_1.Fetcher {
     }
     async grantsFor(projects, withCommunity) {
         const [grant, grantDetails] = this.gap.findManySchemas([
-            'Grant',
-            'GrantDetails',
-            'Milestone',
-            'MilestoneApproved',
-            'MilestoneCompleted',
+            "Grant",
+            "GrantDetails",
+            "Milestone",
+            "MilestoneApproved",
+            "MilestoneCompleted",
         ]);
         const query = gql_queries_1.gqlQueries.dependentsOf(projects.map((p) => p.uid), [grant.uid]);
         const { attestations: grants } = await this.query(query);
@@ -371,10 +371,10 @@ class GapEasClient extends Fetcher_1.Fetcher {
             grant.details = (deps.find((d) => d.refUID === grant.uid &&
                 d.schema.uid === grantDetails.uid &&
                 typeof d.amount !== undefined &&
-                typeof d.endsAt === 'undefined' &&
-                typeof d.data.type === 'undefined'));
+                typeof d.endsAt === "undefined" &&
+                typeof d.data.type === "undefined"));
             grant.milestones = milestones
-                .filter((m) => m.refUID === grant.uid && typeof m.endsAt !== 'undefined')
+                .filter((m) => m.refUID === grant.uid && typeof m.endsAt !== "undefined")
                 .sort((a, b) => a.endsAt - b.endsAt);
         });
         const communities = withCommunity
@@ -389,15 +389,15 @@ class GapEasClient extends Fetcher_1.Fetcher {
     }
     async milestonesOf(grants) {
         const [milestone, milestoneApproved, milestoneCompleted] = this.gap.findManySchemas([
-            'Milestone',
-            'MilestoneApproved',
-            'MilestoneCompleted',
+            "Milestone",
+            "MilestoneApproved",
+            "MilestoneCompleted",
         ]);
         const query = gql_queries_1.gqlQueries.dependentsOf(grants.map((g) => g.uid), [milestone.uid]);
         const { attestations } = await this.query(query);
         const milestones = Attestation_1.Attestation.fromInterface(attestations, this.network.name)
             .map((milestone) => new entities_1.Milestone(milestone))
-            .filter((m) => typeof m.endsAt !== 'undefined');
+            .filter((m) => typeof m.endsAt !== "undefined");
         if (!milestones.length)
             return [];
         const ref = gql_queries_1.gqlQueries.dependentsOf(milestones.map((m) => m.uid), [milestoneApproved.uid, milestoneCompleted.uid]);
@@ -406,16 +406,16 @@ class GapEasClient extends Fetcher_1.Fetcher {
         return milestones.map((milestone) => {
             const refs = deps.filter((ref) => ref.refUID === milestone.uid);
             milestone.endsAt = (0, to_unix_1.toUnix)(milestone.endsAt);
-            milestone.completed = refs.find((dep) => dep.type === 'completed' && dep.refUID === milestone.uid);
-            milestone.approved = refs.find((dep) => dep.type === 'approved' && dep.refUID === milestone.uid);
-            milestone.rejected = refs.find((dep) => dep.type === 'rejected' && dep.refUID === milestone.uid);
+            milestone.completed = refs.find((dep) => dep.type === "completed" && dep.refUID === milestone.uid);
+            milestone.approved = refs.find((dep) => dep.type === "approved" && dep.refUID === milestone.uid);
+            milestone.rejected = refs.find((dep) => dep.type === "rejected" && dep.refUID === milestone.uid);
             return milestone;
         });
     }
     async membersOf(projects) {
         const [member, memberDetails] = this.gap.findManySchemas([
-            'MemberOf',
-            'MemberDetails',
+            "MemberOf",
+            "MemberDetails",
         ]);
         if (!projects.length)
             return [];
@@ -444,7 +444,7 @@ class GapEasClient extends Fetcher_1.Fetcher {
         ];
     }
     async grantsForExtProject(projectExtId) {
-        console.error(new Error('Grants for external project is only supported by a custom indexer. Check https://github.com/show-karma/karma-gap-sdk for more information.'));
+        console.error(new Error("Grants for external project is only supported by a custom indexer. Check https://github.com/show-karma/karma-gap-sdk for more information."));
         return [];
     }
 }

package/core/class/Schema.d.ts

@@ -1,7 +1,9 @@
 import { SchemaEncoder, SchemaItem, SchemaValue } from "@ethereum-attestation-service/eas-sdk";
 import { AttestArgs, Hex, MultiRevokeArgs, SchemaInterface, SignerOrProvider, TNetwork } from "../types";
+import { ethers } from "ethers";
 import { GAP } from "./GAP";
 import { Attestation } from "./Attestation";
+import { AttestationWithTx } from "./types/attestations";
 /**
  * Represents the EAS Schema and provides methods to encode and decode the schema,
  * and validate the schema references.
@@ -76,6 +78,10 @@ export declare abstract class Schema<T extends string = string> implements Schem
     readonly revocable?: boolean;
     readonly references?: T;
     readonly gap: GAP;
+    readonly oldSchemas?: {
+        uid: string;
+        raw: SchemaItem[];
+    }[];
     /**
      * Creates a new schema instance
      * @param args
@@ -140,21 +146,24 @@ export declare abstract class Schema<T extends string = string> implements Schem
      * @param {Object} param0 - An object containing the schema and other optional settings.
      * @returns {Object} An object containing the attestation results, including the CID if 'ipfsKey' is enabled.
      */
-    attest<T>({ data, to, signer, refUID, callback, }: AttestArgs<T>): Promise<Hex>;
+    attest<T>({ data, to, signer, refUID, callback, }: AttestArgs<T>): Promise<AttestationWithTx>;
     /**
      * Bulk attest a set of attestations.
      * @param signer
      * @param entities
      * @returns
      */
-    multiAttest(signer: SignerOrProvider, entities?: Attestation[], callback?: Function): Promise<void>;
+    multiAttest(signer: SignerOrProvider, entities?: Attestation[], callback?: Function): Promise<AttestationWithTx>;
     /**
      * Revokes a set of attestations by their UIDs.
      * @param signer
      * @param uids
      * @returns
      */
-    multiRevoke(signer: SignerOrProvider, toRevoke: MultiRevokeArgs[], callback?: Function): Promise<void>;
+    multiRevoke(signer: SignerOrProvider, toRevoke: MultiRevokeArgs[], callback?: Function): Promise<{
+        tx: ethers.Transaction[];
+        uids: `0x${string}`[];
+    }>;
     static exists(name: string, network: TNetwork): Schema<string>;
     /**
      * Adds the schema signature to a shares list. Use Schema.get("SchemaName") to get the schema.

package/core/class/Schema.js

@@ -87,6 +87,7 @@ class Schema {
         this.name = args.name;
         this.references = args.references;
         this.revocable = args.revocable || true;
+        this.oldSchemas = args.oldSchemas || null;
         this.encoder = new eas_sdk_1.SchemaEncoder(this.raw);
     }
     /**
@@ -142,7 +143,7 @@ class Schema {
                 JSON.parse(value);
             }
             catch (error) {
-                throw new SchemaError_1.SchemaError("INVALID_SCHEMA_FIELD", `Field ${name} is of type ${type} but value is not a valid JSON string.`);
+                throw new SchemaError_1.SchemaError("INVALID_SCHEMA_FIELD", `Field ${name} is of type ${type} but value is not a valid JSON string.`, error);
             }
         }
     }
@@ -253,17 +254,27 @@ class Schema {
         };
         callback?.("preparing");
         if (consts_1.useDefaultAttestation.includes(this.name)) {
-            const tx = await eas.attest({
+            const uid = await eas.attest({
                 schema: this.uid,
                 data: payload.data.payload,
             });
             callback?.("pending");
-            const txResult = await tx.wait();
+            const uidResult = await uid.wait();
             callback?.("confirmed");
-            return txResult;
+            return {
+                tx: [
+                    {
+                        hash: uidResult,
+                    },
+                ],
+                uids: [uidResult],
+            };
         }
-        const uid = await GapContract_1.GapContract.attest(signer, payload, callback);
-        return uid;
+        const { tx, uids } = await GapContract_1.GapContract.attest(signer, payload, callback);
+        return {
+            tx,
+            uids,
+        };
     }
     /**
      * Bulk attest a set of attestations.
@@ -295,15 +306,21 @@ class Schema {
         }));
         if (callback)
             callback("preparing");
-        const tx = await eas.multiAttest(payload, {
+        const attestation = await eas.multiAttest(payload, {
             gasLimit: 5000000n,
         });
         if (callback)
             callback("pending");
-        return tx.wait().then(() => {
+        const txResult = await attestation.wait().then((res) => {
             if (callback)
                 callback("confirmed");
+            return res;
         });
+        const tx = txResult.map((item) => ({ hash: item }));
+        return {
+            tx,
+            uids: txResult,
+        };
     }
     /**
      * Revokes a set of attestations by their UIDs.
@@ -328,9 +345,13 @@ class Schema {
             gasLimit: 5000000n,
         });
         callback?.("pending");
-        return tx.wait().then(() => {
+        tx.wait().then(() => {
             callback?.("confirmed");
         });
+        return {
+            tx: [{ hash: tx.tx.hash }],
+            uids: payload.map((p) => p.data.map((d) => d.uid)).flat(),
+        };
     }
     static exists(name, network) {
         return this.schemas[network].find((schema) => schema.name === name);
@@ -460,7 +481,7 @@ Schema.schemas = {
     sepolia: [],
     arbitrum: [],
     celo: [],
-    "sei": [],
+    sei: [],
     "sei-testnet": [],
     "base-sepolia": [],
 };

package/core/class/SchemaError.d.ts

@@ -19,7 +19,8 @@ declare const SchemaErrorCodes: {
 export declare class SchemaError extends Error {
     readonly code: number;
     private readonly _message;
-    constructor(code: keyof typeof SchemaErrorCodes, append?: string);
+    readonly originalError: any;
+    constructor(code: keyof typeof SchemaErrorCodes, append?: string, originalError?: any);
     get message(): string;
 }
 export declare class AttestationError extends SchemaError {

package/core/class/SchemaError.js

@@ -20,10 +20,11 @@ const SchemaErrorCodes = {
     REMOTE_STORAGE_UPLOAD: 50016,
 };
 class SchemaError extends Error {
-    constructor(code, append) {
-        super(`${code}${append ? `: ${append}` : ''}`);
-        this._message = append || code.replace(/_/g, ' ');
+    constructor(code, append, originalError) {
+        super(`${code}${append ? `: ${append}` : ""}`);
+        this._message = append || code.replace(/_/g, " ");
         this.code = SchemaErrorCodes[code];
+        this.originalError = originalError;
     }
     get message() {
         return this._message;