@show-karma/karma-gap-sdk 0.2.9 → 0.3.2

package/core/class/GraphQL/GapEasClient.js

@@ -31,27 +31,27 @@ class GapEasClient extends Fetcher_1.Fetcher {
             name: '',
             schema: Schema_1.Schema.rawToObject(schema.schema),
             uid: schema.uid,
-        }));
+        }, this.gap));
     }
     async attestation(uid) {
         const query = gql_queries_1.gqlQueries.attestation(uid);
         const { attestation } = await this.query(query);
-        return Attestation_1.Attestation.fromInterface([attestation])[0];
+        return Attestation_1.Attestation.fromInterface([attestation], this.network.name)[0];
     }
     async attestations(schemaName, search) {
-        const schema = GapSchema_1.GapSchema.find(schemaName);
+        const schema = this.gap.findSchema(schemaName);
         const query = gql_queries_1.gqlQueries.attestationsOf(schema.uid, search);
         const { schema: { attestations }, } = await this.query(query);
         return attestations;
     }
     async attestationsOf(schemaName, recipient) {
-        const schema = GapSchema_1.GapSchema.find(schemaName);
+        const schema = this.gap.findSchema(schemaName);
         const query = gql_queries_1.gqlQueries.attestationsOf(schema.uid, recipient);
         const { schema: { attestations }, } = await this.query(query);
         return attestations;
     }
     async attestationsTo(schemaName, recipient) {
-        const schema = GapSchema_1.GapSchema.find(schemaName);
+        const schema = this.gap.findSchema(schemaName);
         const query = gql_queries_1.gqlQueries.attestationsTo(schema.uid, recipient);
         const { schema: { attestations }, } = await this.query(query);
         return attestations;
@@ -62,31 +62,31 @@ class GapEasClient extends Fetcher_1.Fetcher {
      * @param parentUid the parent uid to get dependents of.
      */
     async dependentsOf(parentSchema, parentUid) {
-        const parent = GapSchema_1.GapSchema.find(parentSchema);
+        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.`);
         const query = gql_queries_1.gqlQueries.dependentsOf(parentUid, children);
         const { attestations } = await this.query(query);
-        return Attestation_1.Attestation.fromInterface(attestations);
+        return Attestation_1.Attestation.fromInterface(attestations, this.network.name);
     }
     async communities(search) {
-        const [community, communityDetails] = GapSchema_1.GapSchema.findMany([
+        const [community, communityDetails] = this.gap.findManySchemas([
             'Community',
             'CommunityDetails',
         ]);
         const query = gql_queries_1.gqlQueries.attestationsOf(community.uid, search);
         const { schema: { attestations }, } = await this.query(query);
-        const communities = Attestation_1.Attestation.fromInterface(attestations);
+        const communities = Attestation_1.Attestation.fromInterface(attestations, this.network.name);
         if (!communities.length)
             return [];
         return this.communitiesDetails(communities);
     }
     async communitiesOf(address) {
-        const [community] = GapSchema_1.GapSchema.findMany(['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);
+        const communities = Attestation_1.Attestation.fromInterface(attestations, this.network.name);
         if (!communities.length)
             return [];
         return this.communitiesDetails(communities);
@@ -94,7 +94,7 @@ class GapEasClient extends Fetcher_1.Fetcher {
     async communitiesByIds(uids) {
         if (!uids.length)
             return [];
-        const communityDetails = GapSchema_1.GapSchema.find('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 {
@@ -102,8 +102,8 @@ class GapEasClient extends Fetcher_1.Fetcher {
                 this.query(communityQuery),
                 this.query(detailsQuery),
             ]);
-            const communitiesAttestations = Attestation_1.Attestation.fromInterface(communities.attestations || []);
-            const detailsAttestations = Attestation_1.Attestation.fromInterface(details.attestations || []);
+            const communitiesAttestations = Attestation_1.Attestation.fromInterface(communities.attestations || [], this.network.name);
+            const detailsAttestations = Attestation_1.Attestation.fromInterface(details.attestations || [], this.network.name);
             communitiesAttestations.forEach((community) => {
                 community.details = detailsAttestations.find((d) => d.refUID === community.uid);
             });
@@ -114,13 +114,13 @@ class GapEasClient extends Fetcher_1.Fetcher {
         }
     }
     async communitiesDetails(communities) {
-        const [project, communityDetails] = GapSchema_1.GapSchema.findMany([
+        const [project, communityDetails] = this.gap.findManySchemas([
             'Project',
             'CommunityDetails',
         ]);
         const ref = gql_queries_1.gqlQueries.dependentsOf(communities.map((c) => c.uid), [communityDetails.uid]);
         const results = await this.query(ref);
-        const deps = Attestation_1.Attestation.fromInterface(results.attestations || []);
+        const deps = Attestation_1.Attestation.fromInterface(results.attestations || [], this.network.name);
         return communities.map((community) => {
             community.projects = (deps.filter((ref) => ref.schema.uid === project.uid && ref.refUID === community.uid));
             community.details = (deps.find((ref) => ref.schema.uid === communityDetails.uid &&
@@ -129,13 +129,13 @@ class GapEasClient extends Fetcher_1.Fetcher {
         });
     }
     async communityBySlug(slug) {
-        const communitySchema = GapSchema_1.GapSchema.find('CommunityDetails');
+        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.');
-            const communities = (0, utils_1.mapFilter)(Attestation_1.Attestation.fromInterface(attestations), (details) => !!details.name, (details) => {
+            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 },
                     uid: details.refUID,
@@ -161,7 +161,7 @@ class GapEasClient extends Fetcher_1.Fetcher {
         const { attestation } = await this.query(query);
         if (!attestation)
             throw new Error('Community not found.');
-        const communities = Attestation_1.Attestation.fromInterface([attestation]).map((c) => new Community_1.Community(c));
+        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.');
@@ -177,14 +177,14 @@ 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] = GapSchema_1.GapSchema.findMany(['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),
             this.membersOf(projects),
             this.grantsFor(projects, true),
         ]);
-        const deps = Attestation_1.Attestation.fromInterface(result.attestations || []);
+        const deps = Attestation_1.Attestation.fromInterface(result.attestations || [], this.network.name);
         return projects.map((project) => {
             project.details = (deps.find((ref) => ref.schema.uid === projectDetails.uid && ref.refUID === project.uid));
             project.members = members.filter((m) => m.refUID === project.uid);
@@ -197,25 +197,23 @@ class GapEasClient extends Fetcher_1.Fetcher {
         const { attestation } = await this.query(query);
         if (!attestation)
             throw new Error('Project not found.');
-        const projectAttestation = Attestation_1.Attestation.fromInterface([
-            attestation,
-        ])[0];
+        const projectAttestation = Attestation_1.Attestation.fromInterface([attestation], this.network.name)[0];
         const [result] = await this.projectsDetails([
             new entities_1.Project(projectAttestation),
         ]);
         return result;
     }
     async projectBySlug(slug) {
-        const projectDetails = GapSchema_1.GapSchema.find('ProjectDetails');
+        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).filter((p) => p.title);
+        const projectAttestations = Attestation_1.Attestation.fromInterface(attestations, this.network.name).filter((p) => p.title);
         if (!projectAttestations.length)
             throw new Error('Project not found.');
         const project = new entities_1.Project({
             data: { project: true },
             uid: projectAttestations[0].refUID,
-            schema: GapSchema_1.GapSchema.find('Project'),
+            schema: this.gap.findSchema('Project'),
             recipient: projectAttestations[0].recipient,
         });
         const [withDetails] = await this.projectsDetails([project]);
@@ -224,7 +222,7 @@ class GapEasClient extends Fetcher_1.Fetcher {
         return withDetails;
     }
     async slugExists(slug) {
-        const details = GapSchema_1.GapSchema.find('ProjectDetails');
+        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));
@@ -236,14 +234,14 @@ class GapEasClient extends Fetcher_1.Fetcher {
         const result = await this.attestations('Project', name);
         if (!result.length)
             return [];
-        const projects = Attestation_1.Attestation.fromInterface(result);
+        const projects = Attestation_1.Attestation.fromInterface(result, this.network.name);
         return this.projectsDetails(projects);
     }
     async projectsOf(grantee) {
         const result = await this.attestationsTo('Project', grantee);
         if (!result.length)
             return [];
-        const projects = Attestation_1.Attestation.fromInterface(result);
+        const projects = Attestation_1.Attestation.fromInterface(result, this.network.name);
         return this.projectsDetails(projects);
     }
     async grantee(address) {
@@ -262,19 +260,19 @@ class GapEasClient extends Fetcher_1.Fetcher {
         }, []);
     }
     async grantsOf(grantee, withCommunity) {
-        const [grant, grantDetails, grantVerified] = GapSchema_1.GapSchema.findMany([
+        const [grant, grantDetails, grantVerified] = this.gap.findManySchemas([
             'Grant',
             'GrantDetails',
             'GrantVerified',
         ]);
         const query = gql_queries_1.gqlQueries.attestationsTo(grant.uid, grantee);
         const { schema: { attestations }, } = await this.query(query);
-        const grants = Attestation_1.Attestation.fromInterface(attestations);
+        const grants = Attestation_1.Attestation.fromInterface(attestations, this.network.name);
         if (!grants.length)
             return [];
         const ref = gql_queries_1.gqlQueries.dependentsOf(grants.map((g) => g.uid), [grantDetails.uid, grantVerified.uid], grants.map((g) => g.recipient));
         const results = await this.query(ref);
-        const deps = Attestation_1.Attestation.fromInterface(results.attestations || []);
+        const deps = Attestation_1.Attestation.fromInterface(results.attestations || [], this.network.name);
         const milestones = await this.milestonesOf(grants);
         const communities = withCommunity
             ? await this.communitiesByIds((0, utils_1.mapFilter)(grants, (g) => !!g.communityUID, (g) => g.communityUID))
@@ -292,17 +290,17 @@ class GapEasClient extends Fetcher_1.Fetcher {
         return this.grantsUpdates(withDetails);
     }
     async grantsUpdates(grants) {
-        const details = GapSchema_1.GapSchema.find('GrantDetails');
+        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);
+        const updates = Attestation_1.Attestation.fromInterface(attestations, this.network.name);
         return grants.map((grant) => {
             grant.updates = updates.filter((u) => u.refUID === grant.uid);
             return grant;
         });
     }
     async grantsByCommunity(uid) {
-        const [grant, grantDetails, project, projectDetails] = GapSchema_1.GapSchema.findMany([
+        const [grant, grantDetails, project, projectDetails] = this.gap.findManySchemas([
             'Grant',
             'GrantDetails',
             'Project',
@@ -310,15 +308,15 @@ class GapEasClient extends Fetcher_1.Fetcher {
         ]);
         const query = gql_queries_1.gqlQueries.attestations(grant.uid, uid);
         const { schema: { attestations }, } = await this.query(query);
-        const grants = Attestation_1.Attestation.fromInterface(attestations).map((g) => new entities_1.Grant(g));
+        const grants = Attestation_1.Attestation.fromInterface(attestations, this.network.name).map((g) => new entities_1.Grant(g));
         if (!grants.length)
             return [];
         const refs = gql_queries_1.gqlQueries.dependentsOf(grants.map((g) => [g.uid, g.refUID]).flat(), [grantDetails.uid, project.uid]);
         const results = await this.query(refs);
-        const deps = Attestation_1.Attestation.fromInterface(results.attestations || []);
+        const deps = Attestation_1.Attestation.fromInterface(results.attestations || [], this.network.name);
         const projectsQuery = gql_queries_1.gqlQueries.attestationsIn(grants.map((g) => g.refUID));
         const { attestations: projectAttestations } = await this.query(projectsQuery);
-        const projects = Attestation_1.Attestation.fromInterface(projectAttestations);
+        const projects = Attestation_1.Attestation.fromInterface(projectAttestations, this.network.name);
         const milestones = await this.milestonesOf(grants);
         const getSummaryProject = (project) => ({
             title: project.details?.title,
@@ -342,7 +340,7 @@ class GapEasClient extends Fetcher_1.Fetcher {
             .filter((g) => !!g.project);
     }
     async grantsFor(projects, withCommunity) {
-        const [grant, grantDetails] = GapSchema_1.GapSchema.findMany([
+        const [grant, grantDetails] = this.gap.findManySchemas([
             'Grant',
             'GrantDetails',
             'Milestone',
@@ -351,11 +349,11 @@ class GapEasClient extends Fetcher_1.Fetcher {
         ]);
         const query = gql_queries_1.gqlQueries.dependentsOf(projects.map((p) => p.uid), [grant.uid]);
         const { attestations: grants } = await this.query(query);
-        const grantsWithDetails = Attestation_1.Attestation.fromInterface(grants).map((g) => new entities_1.Grant(g));
+        const grantsWithDetails = Attestation_1.Attestation.fromInterface(grants, this.network.name).map((g) => new entities_1.Grant(g));
         const ref = gql_queries_1.gqlQueries.dependentsOf(grants.map((g) => g.uid), [grantDetails.uid]);
         const { attestations } = await this.query(ref);
         const milestones = await this.milestonesOf(grantsWithDetails);
-        const deps = Attestation_1.Attestation.fromInterface(attestations);
+        const deps = Attestation_1.Attestation.fromInterface(attestations, this.network.name);
         // TODO unify this with grantsOf
         grantsWithDetails.forEach((grant) => {
             grant.details = (deps.find((d) => d.refUID === grant.uid &&
@@ -378,21 +376,21 @@ class GapEasClient extends Fetcher_1.Fetcher {
             a.createdAt.getTime() - b.createdAt.getTime());
     }
     async milestonesOf(grants) {
-        const [milestone, milestoneApproved, milestoneCompleted] = GapSchema_1.GapSchema.findMany([
+        const [milestone, milestoneApproved, milestoneCompleted] = this.gap.findManySchemas([
             '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)
+        const milestones = Attestation_1.Attestation.fromInterface(attestations, this.network.name)
             .map((milestone) => new entities_1.Milestone(milestone))
             .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]);
         const results = await this.query(ref);
-        const deps = Attestation_1.Attestation.fromInterface(results.attestations || []);
+        const deps = Attestation_1.Attestation.fromInterface(results.attestations || [], this.network.name);
         return milestones.map((milestone) => {
             const refs = deps.filter((ref) => ref.refUID === milestone.uid);
             milestone.endsAt = (0, to_unix_1.toUnix)(milestone.endsAt);
@@ -403,7 +401,7 @@ class GapEasClient extends Fetcher_1.Fetcher {
         });
     }
     async membersOf(projects) {
-        const [member, memberDetails] = GapSchema_1.GapSchema.findMany([
+        const [member, memberDetails] = this.gap.findManySchemas([
             'MemberOf',
             'MemberDetails',
         ]);
@@ -411,11 +409,11 @@ class GapEasClient extends Fetcher_1.Fetcher {
             return [];
         const query = gql_queries_1.gqlQueries.dependentsOf(projects.map((p) => p.uid), [member.uid], projects.map((p) => p.attester));
         const results = await this.query(query);
-        const members = Attestation_1.Attestation.fromInterface(results.attestations || []);
+        const members = Attestation_1.Attestation.fromInterface(results.attestations || [], this.network.name);
         if (members.length) {
             const ref = gql_queries_1.gqlQueries.dependentsOf(members.map((a) => a.uid), [memberDetails.uid], members.map((a) => a.attester));
             const detailsResult = await this.query(ref);
-            const detailsRef = Attestation_1.Attestation.fromInterface(detailsResult.attestations || []);
+            const detailsRef = Attestation_1.Attestation.fromInterface(detailsResult.attestations || [], this.network.name);
             members.forEach((member) => {
                 member.details = detailsRef.find((d) => d.refUID === member.uid);
             });

package/core/class/Schema.d.ts

@@ -1,5 +1,6 @@
 import { SchemaEncoder, SchemaItem, SchemaValue } from '@ethereum-attestation-service/eas-sdk';
-import { AttestArgs, Hex, MultiRevokeArgs, SchemaInterface, SignerOrProvider } from '../types';
+import { AttestArgs, Hex, MultiRevokeArgs, SchemaInterface, SignerOrProvider, TNetwork } from '../types';
+import { GAP } from './GAP';
 import { Attestation } from './Attestation';
 /**
  * Represents the EAS Schema and provides methods to encode and decode the schema,
@@ -67,20 +68,21 @@ import { Attestation } from './Attestation';
  * ```
  */
 export declare abstract class Schema<T extends string = string> implements SchemaInterface<T> {
-    protected static schemas: Schema[];
+    protected static schemas: Record<TNetwork, Schema[]>;
     protected encoder: SchemaEncoder;
     private _schema;
     readonly uid: Hex;
     readonly name: string;
     readonly revocable?: boolean;
     readonly references?: T;
+    readonly gap: GAP;
     /**
      * Creates a new schema instance
      * @param args
      * @param strict If true, will throw an error if schema reference is not valid. With this option, user should add schemas
      * in a strict order.
      */
-    constructor(args: SchemaInterface<T>, strict?: boolean, ignoreSchema?: boolean);
+    constructor(args: SchemaInterface<T>, gap?: GAP, strict?: boolean, ignoreSchema?: boolean);
     /**
      * Encode the schema to be used as payload in the attestation
      * @returns
@@ -153,7 +155,7 @@ export declare abstract class Schema<T extends string = string> implements Schem
      * @returns
      */
     multiRevoke(signer: SignerOrProvider, toRevoke: MultiRevokeArgs[]): Promise<void>;
-    static exists(name: string): Schema<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.
      *
@@ -161,32 +163,32 @@ export declare abstract class Schema<T extends string = string> implements Schem
      * of the class AND its data can be overriden by any changes.__
      * @param schemas
      */
-    static add<T extends Schema>(...schemas: T[]): void;
-    static getAll<T extends Schema>(): T[];
-    static get<N extends string, T extends Schema>(name: N): T;
+    static add<T extends Schema>(network: TNetwork, ...schemas: T[]): void;
+    static getAll<T extends Schema>(network: TNetwork): T[];
+    static get<N extends string, T extends Schema>(name: N, network: TNetwork): T;
     /**
      * Find many schemas by name and return them as an array in the same order.
      * @param names
      * @returns
      */
-    static getMany<N extends string, T extends Schema>(names: N[]): T[];
-    static getNames(): string[];
+    static getMany<N extends string, T extends Schema>(names: N[], network: TNetwork): T[];
+    static getNames(network: TNetwork): string[];
     /**
      * Validade references
      * @throws {SchemaError} if any reference is not valid
      * @returns {true} if references are valid
      */
-    static validate(): true;
+    static validate(network: TNetwork): true;
     /**
      * Replaces the schema list with a new list.
      * @param schemas
      */
-    static replaceAll(schemas: Schema[]): void;
+    static replaceAll(schemas: Schema[], network: TNetwork): void;
     /**
      * Replaces a schema from the schema list.
      * @throws {SchemaError} if desired schema name does not exist.
      */
-    static replaceOne(schema: Schema): void;
+    static replaceOne(schema: Schema, network: TNetwork): void;
     /**
      * Transforms the given raw schema to SchemaItem[]
      *

package/core/class/Schema.js

@@ -79,9 +79,10 @@ class Schema {
      * @param strict If true, will throw an error if schema reference is not valid. With this option, user should add schemas
      * in a strict order.
      */
-    constructor(args, strict = false, ignoreSchema = false) {
+    constructor(args, gap, strict = false, ignoreSchema = false) {
         this._schema = [];
         this.assert(args, strict);
+        this.gap = gap;
         this._schema = args.schema;
         this.uid = args.uid;
         this.name = args.name;
@@ -162,7 +163,7 @@ class Schema {
         // if (!uid) {
         //   throw new SchemaError("MISSING_FIELD", "Schema uid is required");
         // }
-        if (strict && references && !Schema.exists(references)) {
+        if (strict && references && !Schema.exists(references, this.gap.network)) {
             throw new SchemaError_1.SchemaError('INVALID_REFERENCE', `Schema ${name} references ${references} but it does not exist.`);
         }
     }
@@ -171,7 +172,7 @@ class Schema {
      * @returns
      */
     async attestOffchain({ data, signer, to, refUID }) {
-        const eas = await GAP_1.GAP.eas.getOffchain();
+        const eas = await this.gap.eas.getOffchain();
         const payload = {
             data,
             version: eas.version,
@@ -191,7 +192,7 @@ class Schema {
      * @returns
      */
     async revokeOffchain(uid, signer) {
-        const eas = GAP_1.GAP.eas.connect(signer);
+        const eas = this.gap.eas.connect(signer);
         return eas.revokeOffchain(uid);
     }
     /**
@@ -201,7 +202,7 @@ class Schema {
      * @returns
      */
     async multiRevokeOffchain(uids, signer) {
-        const eas = GAP_1.GAP.eas.connect(signer);
+        const eas = this.gap.eas.connect(signer);
         return eas.multiRevokeOffchain(uids);
     }
     /**
@@ -219,7 +220,7 @@ class Schema {
      * @returns {Object} An object containing the attestation results, including the CID if 'ipfsKey' is enabled.
      */
     async attest({ data, to, signer, refUID }) {
-        const eas = GAP_1.GAP.eas.connect(signer);
+        const eas = this.gap.eas.connect(signer);
         if (this.references && !refUID)
             throw new SchemaError_1.AttestationError('INVALID_REFERENCE', 'Attestation schema references another schema but no reference UID was provided.');
         if (this.isJsonSchema()) {
@@ -278,7 +279,7 @@ class Schema {
             if (this.references && !entity.refUID)
                 throw new SchemaError_1.SchemaError('INVALID_REF_UID', `Entity ${entity.schema.name} references another schema but no reference UID was provided.`);
         });
-        const eas = GAP_1.GAP.eas.connect(signer);
+        const eas = this.gap.eas.connect(signer);
         const entityBySchema = entities.reduce((acc, entity) => {
             const schema = entity.schema.uid;
             if (!acc[schema])
@@ -313,7 +314,7 @@ class Schema {
             acc[schemaId].push(uid);
             return acc;
         }, {});
-        const eas = GAP_1.GAP.eas.connect(signer);
+        const eas = this.gap.eas.connect(signer);
         const payload = Object.entries(groupBySchema).map(([schema, uids]) => ({
             schema,
             data: uids.map((uid) => ({ uid })),
@@ -323,8 +324,8 @@ class Schema {
         });
         return tx.wait();
     }
-    static exists(name) {
-        return this.schemas.find((schema) => schema.name === name);
+    static exists(name, network) {
+        return this.schemas[network].find((schema) => schema.name === name);
     }
     /**
      * Adds the schema signature to a shares list. Use Schema.get("SchemaName") to get the schema.
@@ -333,21 +334,21 @@ class Schema {
      * of the class AND its data can be overriden by any changes.__
      * @param schemas
      */
-    static add(...schemas) {
+    static add(network, ...schemas) {
         schemas.forEach((schema) => {
-            if (!this.exists(schema.name))
-                this.schemas.push(schema);
+            if (!this.exists(schema.name, network))
+                this.schemas[network].push(schema);
             else
                 throw new SchemaError_1.SchemaError('SCHEMA_ALREADY_EXISTS', `Schema ${schema.name} already exists.`);
         });
     }
-    static getAll() {
-        return this.schemas;
+    static getAll(network) {
+        return this.schemas[network];
     }
-    static get(name) {
-        const schema = this.schemas.find((schema) => schema.name === name || schema.uid === name);
+    static get(name, network) {
+        const schema = this.schemas[network].find((schema) => schema.name === name || schema.uid === name);
         if (!schema)
-            throw new SchemaError_1.SchemaError('SCHEMA_NOT_FOUND', `Schema ${name} not found. Available schemas: ${Schema.getNames()}`);
+            throw new SchemaError_1.SchemaError('SCHEMA_NOT_FOUND', `Schema ${name} not found. Available schemas: ${Schema.getNames(network)}`);
         return schema;
     }
     /**
@@ -355,21 +356,21 @@ class Schema {
      * @param names
      * @returns
      */
-    static getMany(names) {
-        return names.map((name) => this.get(name));
+    static getMany(names, network) {
+        return names.map((name) => this.get(name, network));
     }
-    static getNames() {
-        return Schema.schemas.map((schema) => schema.name);
+    static getNames(network) {
+        return Schema.schemas[network].map((schema) => schema.name);
     }
     /**
      * Validade references
      * @throws {SchemaError} if any reference is not valid
      * @returns {true} if references are valid
      */
-    static validate() {
+    static validate(network) {
         const errors = [];
-        this.schemas.forEach((schema) => {
-            if (!schema.references || Schema.exists(schema.references))
+        this.schemas[network].forEach((schema) => {
+            if (!schema.references || Schema.exists(schema.references, network))
                 return;
             else
                 errors.push(new SchemaError_1.SchemaError('INVALID_REFERENCE', `Schema ${schema.name} references ${schema.references} but it does not exist.`));
@@ -382,15 +383,15 @@ class Schema {
      * Replaces the schema list with a new list.
      * @param schemas
      */
-    static replaceAll(schemas) {
-        this.schemas = schemas;
+    static replaceAll(schemas, network) {
+        this.schemas[network] = schemas;
     }
     /**
      * Replaces a schema from the schema list.
      * @throws {SchemaError} if desired schema name does not exist.
      */
-    static replaceOne(schema) {
-        const idx = this.schemas.findIndex((item) => schema.name === item.name);
+    static replaceOne(schema, network) {
+        const idx = this.schemas[network].findIndex((item) => schema.name === item.name);
         if (!~idx)
             throw new SchemaError_1.SchemaError('SCHEMA_NOT_FOUND', `Schema ${schema.name} not found.`);
         this.schemas[idx] = schema;
@@ -434,7 +435,7 @@ class Schema {
      * the changes made to it will reflect the original instance.
      */
     get children() {
-        return Schema.schemas.filter((schema) => schema.references === this.name || schema.references === this.uid);
+        return Schema.schemas[this.gap.network].filter((schema) => schema.references === this.name || schema.references === this.uid);
     }
     /**
      * Asserts and sets the schema value.
@@ -446,4 +447,9 @@ class Schema {
     }
 }
 exports.Schema = Schema;
-Schema.schemas = [];
+Schema.schemas = {
+    'optimism-goerli': [],
+    optimism: [],
+    sepolia: [],
+    arbitrum: [],
+};