@show-karma/karma-gap-sdk 0.1.29

package/core/class/karma-indexer/GapIndexerClient.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GapIndexerClient = void 0;
+const Attestation_1 = require("../Attestation");
+const GapSchema_1 = require("../GapSchema");
+const Fetcher_1 = require("../Fetcher");
+const entities_1 = require("../entities");
+const Endpoints = {
+    attestations: {
+        all: () => "/attestations",
+        byUid: (uid) => `/attestations/${uid}`,
+    },
+    communities: {
+        all: () => "/communities",
+        byUidOrSlug: (uidOrSlug) => `/communities/${uidOrSlug}`,
+        grants: (uidOrSlug) => `/communities/${uidOrSlug}/grants`,
+    },
+    grantees: {
+        all: () => "/grantees",
+        byAddress: (address) => `/grantees/${address}`,
+        grants: (address) => `/grantees/${address}/grants`,
+        projects: (address) => `/grantees/${address}/projects`,
+    },
+    grants: {
+        all: () => "/grants",
+        byUid: (uid) => `/grants/${uid}`,
+    },
+    project: {
+        all: () => "/projects",
+        byUidOrSlug: (uidOrSlug) => `/projects/${uidOrSlug}`,
+        grants: (uidOrSlug) => `/projects/${uidOrSlug}/grants`,
+        milestones: (uidOrSlug) => `/projects/${uidOrSlug}/milestones`,
+    },
+};
+class GapIndexerClient extends Fetcher_1.Fetcher {
+    async attestation(uid) {
+        const { data } = await this.client.get(Endpoints.attestations.byUid(uid));
+        if (!data)
+            throw new Error("Attestation not found");
+        return Attestation_1.Attestation.fromInterface([data])[0];
+    }
+    async attestations(schemaName, search) {
+        const { data } = await this.client.get(Endpoints.attestations.all(), {
+            params: {
+                "filter[schemaUID]": GapSchema_1.GapSchema.get(schemaName).uid,
+                "filter[data]": search,
+            },
+        });
+        return data || [];
+    }
+    async attestationsOf(schemaName, attester) {
+        const { data } = await this.client.get(Endpoints.attestations.all(), {
+            params: {
+                "filter[schemaUID]": GapSchema_1.GapSchema.get(schemaName).uid,
+                "filter[recipient]": attester,
+            },
+        });
+        return data || [];
+    }
+    attestationsTo(schemaName, recipient) {
+        return this.attestationsOf(schemaName, recipient);
+    }
+    async communities(search) {
+        const { data } = await this.client.get(Endpoints.communities.all(), {
+            params: {
+                "filter[name]": search,
+            },
+        });
+        return entities_1.Community.from(data);
+    }
+    communitiesByIds(uids) {
+        throw new Error("Method not implemented.");
+    }
+    async communityBySlug(slug) {
+        const { data } = await this.client.get(Endpoints.communities.byUidOrSlug(slug));
+        return entities_1.Community.from([data])[0];
+    }
+    communityById(uid) {
+        return this.communityBySlug(uid);
+    }
+    async projectBySlug(slug) {
+        const { data } = await this.client.get(Endpoints.project.byUidOrSlug(slug));
+        return entities_1.Project.from([data])[0];
+    }
+    projectById(uid) {
+        return this.projectBySlug(uid);
+    }
+    async projects(name) {
+        const { data } = await this.client.get(Endpoints.project.all(), {
+            params: {
+                "filter[title]": name,
+            },
+        });
+        return entities_1.Project.from(data);
+    }
+    async projectsOf(grantee) {
+        const { data } = await this.client.get(Endpoints.grantees.projects(grantee));
+        return entities_1.Project.from(data);
+    }
+    async grantee(address) {
+        const { data } = await this.client.get(Endpoints.grantees.byAddress(address));
+        return data;
+    }
+    async grantees() {
+        const { data } = await this.client.get(Endpoints.grantees.all());
+        return data;
+    }
+    async grantsOf(grantee, withCommunity) {
+        const { data } = await this.client.get(Endpoints.grantees.grants(grantee));
+        return entities_1.Grant.from(data);
+    }
+    async grantsFor(projects, withCommunity) {
+        const { data } = await this.client.get(Endpoints.project.grants(projects[0].uid));
+        return entities_1.Grant.from(data);
+    }
+    async grantsByCommunity(uid) {
+        const { data } = await this.client.get(Endpoints.communities.grants(uid));
+        return entities_1.Grant.from(data);
+    }
+    async milestonesOf(grants) {
+        const { data } = await this.client.get(Endpoints.project.milestones(grants[0].uid));
+        return entities_1.Milestone.from(data);
+    }
+    async membersOf(projects) {
+        throw new Error("Method not implemented.");
+    }
+    async slugExists(slug) {
+        try {
+            await this.client.get(Endpoints.project.byUidOrSlug(slug));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+exports.GapIndexerClient = GapIndexerClient;

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

@@ -0,0 +1,108 @@
+import { Attestation } from '../Attestation';
+import { Hex } from 'core/types';
+import { Project } from '../entities/Project';
+/** Attestation interfaces */
+export type ExternalLink = {
+    type: string;
+    url: string;
+}[];
+export interface ICommunityDetails {
+    name: string;
+    description: string;
+    imageURL: string;
+    slug?: string;
+    links?: ExternalLink;
+}
+export declare class CommunityDetails extends Attestation<ICommunityDetails> implements ICommunityDetails {
+    name: string;
+    description: string;
+    imageURL: string;
+    links: ExternalLink;
+    slug?: string;
+}
+export interface IGrantDetails {
+    title: string;
+    amount?: string;
+    proposalURL: string;
+    assetAndChainId?: [Hex, number];
+    payoutAddress?: Hex;
+    description?: string;
+    season?: string;
+    cycle?: string;
+}
+export declare class GrantDetails extends Attestation<IGrantDetails> implements IGrantDetails {
+    title: string;
+    proposalURL: string;
+    payoutAddress?: Hex;
+    amount?: string;
+    assetAndChainId?: [Hex, number];
+    description?: string;
+    season?: string;
+    cycle?: string;
+}
+export interface IGrantRound {
+    name: string;
+}
+export declare class GrantRound extends Attestation<IGrantRound> implements IGrantRound {
+    name: string;
+}
+export interface IGrantVerified {
+    verified: boolean;
+}
+export declare class GrantVerified extends Attestation<IGrantVerified> implements IGrantVerified {
+    verified: boolean;
+}
+export interface IMemberDetails {
+    name: string;
+    profilePictureURL: string;
+}
+export declare class MemberDetails extends Attestation<IMemberDetails> implements IMemberDetails {
+    name: string;
+    profilePictureURL: string;
+}
+export interface IMilestoneCompleted {
+    type: 'approved' | 'rejected' | 'completed';
+    reason?: string;
+}
+export declare class MilestoneCompleted extends Attestation<IMilestoneCompleted> implements IMilestoneCompleted {
+    type: 'approved' | 'rejected' | 'completed';
+    reason?: string;
+}
+export interface ITag {
+    name: string;
+}
+export declare class Tag extends Attestation<ITag> implements ITag {
+    name: string;
+}
+export interface IProjectDetails {
+    title: string;
+    description: string;
+    imageURL: string;
+    links?: ExternalLink;
+    tags?: ITag[];
+    slug?: string;
+}
+export declare class ProjectDetails extends Attestation<IProjectDetails> implements IProjectDetails {
+    title: string;
+    description: string;
+    imageURL: string;
+    links: ExternalLink;
+    tags: ITag[];
+    slug: string;
+}
+export declare class Grantee {
+    address: string;
+    projects: Project[];
+    constructor(address: Hex, projects?: Project[]);
+}
+export interface IGrantUpdate {
+    title: string;
+    text: string;
+    type?: string;
+}
+export declare class GrantUpdate extends Attestation<IGrantUpdate> implements IGrantUpdate {
+    title: string;
+    text: string;
+}
+export declare class GrantCompleted extends GrantUpdate {
+}

package/core/class/types/attestations.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GrantCompleted = exports.GrantUpdate = exports.Grantee = exports.ProjectDetails = exports.Tag = exports.MilestoneCompleted = exports.MemberDetails = exports.GrantVerified = exports.GrantRound = exports.GrantDetails = exports.CommunityDetails = void 0;
+const Attestation_1 = require("../Attestation");
+class CommunityDetails extends Attestation_1.Attestation {
+    constructor() {
+        super(...arguments);
+        this.links = [];
+    }
+}
+exports.CommunityDetails = CommunityDetails;
+class GrantDetails extends Attestation_1.Attestation {
+    constructor() {
+        super(...arguments);
+        this.amount = '0';
+    }
+}
+exports.GrantDetails = GrantDetails;
+class GrantRound extends Attestation_1.Attestation {
+}
+exports.GrantRound = GrantRound;
+class GrantVerified extends Attestation_1.Attestation {
+}
+exports.GrantVerified = GrantVerified;
+class MemberDetails extends Attestation_1.Attestation {
+}
+exports.MemberDetails = MemberDetails;
+class MilestoneCompleted extends Attestation_1.Attestation {
+}
+exports.MilestoneCompleted = MilestoneCompleted;
+class Tag extends Attestation_1.Attestation {
+}
+exports.Tag = Tag;
+class ProjectDetails extends Attestation_1.Attestation {
+    constructor() {
+        super(...arguments);
+        this.links = [];
+        this.tags = [];
+    }
+}
+exports.ProjectDetails = ProjectDetails;
+class Grantee {
+    constructor(address, projects = []) {
+        this.projects = [];
+        this.address = address;
+        this.projects = projects;
+    }
+}
+exports.Grantee = Grantee;
+class GrantUpdate extends Attestation_1.Attestation {
+}
+exports.GrantUpdate = GrantUpdate;
+class GrantCompleted extends GrantUpdate {
+}
+exports.GrantCompleted = GrantCompleted;

package/core/consts.d.ts

@@ -0,0 +1,19 @@
+import { EASNetworkConfig, SchemaInterface, TNetwork, TSchemaName } from "./types";
+/**
+ * Schemas that should use default EAS attestation
+ * instead of the custom contract.
+ */
+export declare const useDefaultAttestation: TSchemaName[];
+export declare const nullRef = "0x0000000000000000000000000000000000000000000000000000000000000000";
+export declare const nullResolver = "0x0000000000000000000000000000000000000000";
+export declare const zeroAddress = "0x0000000000000000000000000000000000000000";
+/**
+ * The networks that are supported by the EAS
+ */
+export declare const Networks: Record<TNetwork, EASNetworkConfig>;
+/**
+ * Mounts the schemas for the given network and return all the settings
+ * @param network
+ * @returns
+ */
+export declare const MountEntities: (network: EASNetworkConfig) => Record<TSchemaName, SchemaInterface<TSchemaName>>;

package/core/consts.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MountEntities = exports.Networks = exports.zeroAddress = exports.nullResolver = exports.nullRef = exports.useDefaultAttestation = void 0;
+/**
+ * Schemas that should use default EAS attestation
+ * instead of the custom contract.
+ */
+exports.useDefaultAttestation = [
+    "MilestoneApproved",
+    "MilestoneCompleted",
+    "GrantVerified",
+    "Community",
+];
+exports.nullRef = "0x0000000000000000000000000000000000000000000000000000000000000000";
+// TODO: Remove null resolver and change usage to zero address
+exports.nullResolver = "0x0000000000000000000000000000000000000000";
+exports.zeroAddress = exports.nullResolver;
+// resolver for dependents = 0xed081ABE885bc3575f810c904052A1f685A85903
+/**
+ * The networks that are supported by the EAS
+ */
+exports.Networks = {
+    // mainnet: {
+    //   url: "https://easscan.org/graphql",
+    //   chainId: 1,
+    //   contracts: {
+    //     eas: "0xA1207F3BBa224E2c9c3c6D5aF63D0eb1582Ce587",
+    //     schema: "0xA7b39296258348C78294F95B872b282326A97BDF",
+    //     multicall:''
+    //   },
+    //   schemas: {
+    //     Grant: "",
+    //     GrantVerified: "",
+    //     MemberOf: "",
+    //     MilestoneApproved: "",
+    //     MilestoneCompleted: "",
+    //     Project: "",
+    //   },
+    // },
+    // "base-goerli": {
+    //   chainId: 5,
+    //   url: "https://base-goerli.easscan.org/graphql",
+    //   contracts: {
+    //     eas: "0xAcfE09Fd03f7812F022FBf636700AdEA18Fd2A7A",
+    //     schema: "0x720c2bA66D19A725143FBf5fDC5b4ADA2742682E",
+    //     multicall:''
+    //   },
+    //   schemas: {
+    //     Grant: "",
+    //     GrantVerified: "",
+    //     MemberOf: "",
+    //     MilestoneApproved: "",
+    //     MilestoneCompleted: "",
+    //     Project: "",
+    //   },
+    // },
+    optimism: {
+        chainId: 10,
+        url: "https://optimism.easscan.org/graphql",
+        contracts: {
+            eas: "0x4200000000000000000000000000000000000021",
+            schema: "0x4200000000000000000000000000000000000020",
+            multicall: "0xd2eD366393FDfd243931Fe48e9fb65A192B0018c", //proxy
+        },
+        schemas: {
+            Community: "0x721c17b065dccc5c916e0c2708d0ef50f1810591b76d0402ff6fe5accbd8488f",
+            Details: "0x70a3f615f738fc6a4f56100692ada93d947c028b840940d97af7e7d6f0fa0577",
+            Grant: "0x12837231f48acbca4e1e7f4416f684f3353bd4d71d4f03a09d29e5ffa6f21a50",
+            GrantVerified: "0x13adc8df8a7324b1651e8bcec948b3e2d4fcfa2a88a52136206cb9ea44836e93",
+            MemberOf: "0x7fbb8a65924d8ad2ae12356e04b1418043e8361ba3b1b6c917de2e23df3ec81c",
+            MilestoneApproved: "0x13adc8df8a7324b1651e8bcec948b3e2d4fcfa2a88a52136206cb9ea44836e93",
+            MilestoneCompleted: "0x13adc8df8a7324b1651e8bcec948b3e2d4fcfa2a88a52136206cb9ea44836e93",
+            Project: "0x5b873b6e7a16207b526dde366e8164e95bcda2f009272306519667c5e94d2191",
+        },
+    },
+    "optimism-goerli": {
+        chainId: 420,
+        url: "https://optimism-goerli-bedrock.easscan.org/graphql",
+        contracts: {
+            eas: "0x4200000000000000000000000000000000000021",
+            schema: "0x4200000000000000000000000000000000000020",
+            multicall: "0x5D5a8032b2FA06652804c33F60DcEA00e389B732", //proxy
+        },
+        schemas: {
+            Community: "0xc1aade58410b3fd807c19845181996721248459c5f042284f27d21cec12a38d1",
+            // "0x14b016a56b56db47ee2cdda6963a3481374a75e1471dafd85a17e6e5c23d2a11",
+            Details: "0xfe590d9582957e10affbabcdc34a201785a1d4f77982d6616b736cce1a91ae43",
+            Grant: "0xd6ce374765c355687101ba70b3f8824d555c12716d2bdad71a08ccad1ded3218",
+            GrantVerified: "0xf544fbd9721ac50863d32dc0eed5992051e7fb270b38ab2ce062327cc0ae26ea",
+            MemberOf: "0x78c811e506849d414a91a56dab91f07f7ed108f0bf27f550796f13e7bb2e2f2d",
+            MilestoneApproved: "0xf544fbd9721ac50863d32dc0eed5992051e7fb270b38ab2ce062327cc0ae26ea",
+            MilestoneCompleted: "0xf544fbd9721ac50863d32dc0eed5992051e7fb270b38ab2ce062327cc0ae26ea",
+            Project: "0xec77990a252b54b17673955c774b9712766de5eecb22ca5aa2c440e0e93257fb",
+        },
+    },
+    // arbitrum: {
+    //   chainId: 42161,
+    //   url: "https://arbitrum.easscan.org/graphql",
+    //   contracts: {
+    //     eas: "0xbD75f629A22Dc1ceD33dDA0b68c546A1c035c458",
+    //     schema: "0xA310da9c5B885E7fb3fbA9D66E9Ba6Df512b78eB",
+    //     multicall:''
+    //   },
+    //   schemas: {
+    //     Grant: "",
+    //     GrantVerified: "",
+    //     MemberOf: "",
+    //     MilestoneApproved: "",
+    //     MilestoneCompleted: "",
+    //     Project: "",
+    //   },
+    // },
+    sepolia: {
+        chainId: 11155111,
+        url: "https://sepolia.easscan.org/graphql",
+        contracts: {
+            eas: "0xC2679fBD37d54388Ce493F1DB75320D236e1815e",
+            schema: "0x0a7E2Ff54e76B8E6659aedc9103FB21c038050D0",
+            multicall: "0x00Ee8a5082567c3da8f3D34D33ac8D788C4Cd754", // enhanced
+            // multicall: "0x04D6BB799f5A8c76882C4372d1FC39Cd0DDA0A4c",// original
+        },
+        schemas: {
+            Community: "0xf3d790c7fdab6c1b1f25ffcc9289e5be2792eb596d2851a4d059c8aae1bc8b2e",
+            // "0x1954572e3fe21bf4334afdaf1358ed7098af1ed136e76dc93c2fdc25e83934c1", // original without resolver
+            Details: "0x2c270e35bfcdc4d611f0e9d3d2ab6924ec6c673505abc22a1dd07e19b67211af",
+            Grant: "0x09697aeeb3ae71de1cc19e388fd74264f11af5fba3016094764553ac341fdc72",
+            GrantVerified: "0x0be8952e2dd74ffd63a02f4d55b20b603fe7a60130cb9d70de31feb9c52fdd37",
+            MemberOf: "0xdd87b3500457931252424f4439365534ba72a367503a8805ff3482353fb90301",
+            MilestoneApproved: "0xcdef0e492d2e7ad25d0b0fdb868f6dcd1f5e5c30e42fd5fa0debdc12f7618322",
+            MilestoneCompleted: "0xcdef0e492d2e7ad25d0b0fdb868f6dcd1f5e5c30e42fd5fa0debdc12f7618322",
+            Project: "0xec77990a252b54b17673955c774b9712766de5eecb22ca5aa2c440e0e93257fb",
+        },
+    },
+};
+const DetailsSchema = [{ type: "string", name: "json", value: null }];
+/**
+ * Mounts the schemas for the given network and return all the settings
+ * @param network
+ * @returns
+ */
+const MountEntities = (network) => ({
+    Community: {
+        name: "Community",
+        schema: [{ type: "bool", name: "community", value: true }],
+        uid: network.schemas.Community,
+    },
+    CommunityDetails: {
+        name: "CommunityDetails",
+        schema: DetailsSchema,
+        uid: network.schemas.Details,
+        references: "Community",
+    },
+    Project: {
+        name: "Project",
+        schema: [{ type: "bool", name: "project", value: true }],
+        uid: network.schemas.Project,
+    },
+    ProjectDetails: {
+        name: "ProjectDetails",
+        schema: DetailsSchema,
+        uid: network.schemas.Details,
+        references: "Project",
+    },
+    MemberOf: {
+        name: "MemberOf",
+        schema: [{ type: "bool", name: "memberOf", value: true }],
+        uid: network.schemas.MemberOf,
+        references: "Project",
+    },
+    MemberDetails: {
+        name: "MemberDetails",
+        schema: DetailsSchema,
+        uid: network.schemas.Details,
+        references: "MemberOf",
+    },
+    Grant: {
+        name: "Grant",
+        schema: [{ type: "bytes32", name: "communityUID", value: true }],
+        // schema: [{ type: "bool", name: "grant", value: true }],
+        uid: network.schemas.Grant,
+        references: "Project",
+    },
+    GrantDetails: {
+        name: "GrantDetails",
+        schema: DetailsSchema,
+        uid: network.schemas.Details,
+        references: "Grant",
+    },
+    GrantVerified: {
+        name: "GrantVerified",
+        schema: [
+            { type: "string", name: "type", value: null },
+            { type: "string", name: "reason", value: "" },
+        ],
+        uid: network.schemas.GrantVerified,
+        references: "Grant",
+    },
+    Milestone: {
+        name: "Milestone",
+        schema: DetailsSchema,
+        uid: network.schemas.Details,
+        references: "Grant",
+    },
+    MilestoneApproved: {
+        name: "MilestoneApproved",
+        schema: [
+            { type: "string", name: "type", value: null },
+            { type: "string", name: "reason", value: "" },
+        ],
+        uid: network.schemas.MilestoneApproved,
+        references: "Milestone",
+    },
+    MilestoneCompleted: {
+        name: "MilestoneCompleted",
+        schema: [
+            { type: "string", name: "type", value: null },
+            { type: "string", name: "reason", value: "" },
+        ],
+        uid: network.schemas.MilestoneCompleted,
+        references: "Milestone",
+    },
+    Details: {
+        schema: DetailsSchema,
+        name: "    schema",
+        uid: network.schemas.Details,
+    },
+});
+exports.MountEntities = MountEntities;

package/core/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./consts";
+export * from "./types";
+export * from "./utils";
+export * from "./class/GAP";
+export * from "./class/GapSchema";
+export * from "./class/types/attestations";
+export * from "./class/entities";

package/core/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+__exportStar(require("./consts"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./class/GAP"), exports);
+__exportStar(require("./class/GapSchema"), exports);
+__exportStar(require("./class/types/attestations"), exports);
+__exportStar(require("./class/entities"), exports);

package/core/types.d.ts

@@ -0,0 +1,107 @@
+import { BytesLike } from "ethers";
+import { AttestationRequestData, EAS, MultiAttestationRequest, SchemaItem } from "@ethereum-attestation-service/eas-sdk";
+import { SignerOrProvider as EASSigner } from "@ethereum-attestation-service/eas-sdk/dist/transaction";
+import { Attestation } from "./class";
+import { Fetcher } from "./class/Fetcher";
+export type Hex = `0x${string}`;
+export type SignerOrProvider = EASSigner & {
+    address?: Hex;
+    _address?: Hex;
+    getAddress?: () => Promise<Hex>;
+};
+export interface SchemaInterface<T extends string = string> {
+    name: string;
+    schema: SchemaItem[];
+    references?: T;
+    uid: Hex;
+    revocable?: boolean;
+}
+export interface MultiRevokeArgs {
+    uid: Hex;
+    schemaId: Hex;
+}
+export interface AttestArgs<T = unknown> {
+    to: Hex;
+    data: T;
+    refUID?: Hex;
+    signer: SignerOrProvider;
+}
+export type TSchemaName = "Community" | "CommunityDetails" | "Grant" | "GrantDetails" | "GrantVerified" | "MemberOf" | "MemberDetails" | "Milestone" | "MilestoneCompleted" | "MilestoneApproved" | "Project" | "ProjectDetails" | "Details";
+export type TResolvedSchemaNames = "Community" | "Grant" | "GrantVerified" | "MemberOf" | "MilestoneCompleted" | "MilestoneApproved" | "Project" | "Details";
+export type TExternalLink = "twitter" | "github" | "website" | "linkedin" | "discord";
+export type TNetwork = "optimism" | "optimism-goerli" | "sepolia";
+/**
+ * Generic GAP Facade interface.
+ * This supplies the GAP class with the necessary properties.
+ */
+export declare abstract class Facade {
+    abstract readonly network: TNetwork;
+    abstract readonly schemas: SchemaInterface[];
+    abstract readonly fetch: Fetcher;
+    protected static _eas: EAS;
+    static get eas(): EAS;
+}
+export interface RawAttestationPayload {
+    schema: Hex;
+    data: {
+        payload: AttestationRequestData;
+        raw: AttestationRequestData;
+    };
+}
+export interface RawMultiAttestPayload {
+    payload: MultiAttestData;
+    raw: MultiAttestData;
+}
+export interface MultiAttestData {
+    uid?: Hex;
+    multiRequest: MultiAttestationRequest;
+    refIdx: number;
+}
+export type MultiAttestPayload = [Attestation, RawMultiAttestPayload][];
+export interface EASNetworkConfig {
+    url: string;
+    chainId: number;
+    contracts: {
+        eas: Hex;
+        schema: Hex;
+        multicall: Hex;
+    };
+    /**
+     * A tuple containing the schema name and it's UID for that network
+     */
+    schemas: Record<TResolvedSchemaNames, Hex>;
+}
+export type IGapSchema = SchemaInterface<TSchemaName>;
+export type JSONStr = string;
+export interface Schemata {
+    uid: Hex;
+    schema: string;
+}
+export interface SchemataRes {
+    schemata: Schemata[];
+}
+export interface IAttestation {
+    uid: Hex;
+    attester: Hex;
+    data: BytesLike;
+    decodedDataJson: JSONStr;
+    recipient: Hex;
+    revoked: boolean;
+    createdAt: number;
+    refUID?: Hex;
+    isOffchain: boolean;
+    revocable: boolean;
+    revocationTime?: number;
+    schemaId: Hex;
+}
+export interface AttestationRes {
+    attestation: IAttestation;
+}
+export interface AttestationsRes {
+    attestations: IAttestation[];
+}
+export interface SchemaRes {
+    schema: {
+        attestations: IAttestation[];
+    };
+}