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

package/core/class/Attestation.d.ts

@@ -1,4 +1,4 @@
-import { Hex, IAttestation, JSONStr, MultiAttestData, SignerOrProvider } from '../types';
+import { Hex, IAttestation, JSONStr, MultiAttestData, SignerOrProvider, TNetwork } from '../types';
 import { Schema } from './Schema';
 import { SchemaItem, SchemaValue } from '@ethereum-attestation-service/eas-sdk';
 import { GapSchema } from './GapSchema';
@@ -20,13 +20,13 @@ export interface AttestationArgs<T = unknown, S extends Schema = Schema> {
  *
  * ```ts
  * const grantee = new Attestation({
- *  schema: Schema.get("Grantee"), // Use GapSchema.find("SchemaName") if using default GAP schemas
+ *  schema: Schema.get("Grantee", "network-name"), // Use this.schema.gap.findSchema("SchemaName") if using default GAP schemas
  *  data: { grantee: true },
  *  uid: "0xabc123",
  * });
  *
  * const granteeDetails = new Attestation({
- *  schema: Schema.get("GranteeDetails"),
+ *  schema: Schema.get("GranteeDetails", "optimism"),
  *  data: {
  *    name: "John Doe",
  *    description: "A description",
@@ -55,7 +55,7 @@ export declare class Attestation<T = unknown, S extends Schema = GapSchema> impl
     readonly revoked?: boolean;
     readonly revocationTime?: Date;
     readonly createdAt: Date;
-    readonly chainID: number;
+    private _chainID;
     private _reference?;
     constructor(args: AttestationArgs<T, S>);
     /**
@@ -149,13 +149,14 @@ export declare class Attestation<T = unknown, S extends Schema = GapSchema> impl
     /**
      * Transform attestation interface-based into class-based.
      */
-    static fromInterface<T extends Attestation = Attestation>(attestations: IAttestation[]): T[];
+    static fromInterface<T extends Attestation = Attestation>(attestations: IAttestation[], network: TNetwork): T[];
     /**
      * Asserts if schema is valid.
      * > Does not check refUID if `strict = false`. To check refUID use `Schema.validate()`
      * @param args
      */
     protected assert(args: AttestationArgs, strict?: boolean): void;
+    get chainID(): number;
     get data(): T;
     get uid(): Hex;
     set uid(uid: Hex);

package/core/class/Attestation.js

@@ -13,13 +13,13 @@ const GapContract_1 = require("./contract/GapContract");
  *
  * ```ts
  * const grantee = new Attestation({
- *  schema: Schema.get("Grantee"), // Use GapSchema.find("SchemaName") if using default GAP schemas
+ *  schema: Schema.get("Grantee", "network-name"), // Use this.schema.gap.findSchema("SchemaName") if using default GAP schemas
  *  data: { grantee: true },
  *  uid: "0xabc123",
  * });
  *
  * const granteeDetails = new Attestation({
- *  schema: Schema.get("GranteeDetails"),
+ *  schema: Schema.get("GranteeDetails", "optimism"),
  *  data: {
  *    name: "John Doe",
  *    description: "A description",
@@ -50,7 +50,7 @@ class Attestation {
         this.revoked = args.revoked;
         this.revocationTime = (0, get_date_1.getDate)(args.revocationTime);
         this.createdAt = (0, get_date_1.getDate)(args.createdAt || Date.now() / 1000);
-        this.chainID = args.chainID;
+        this._chainID = args.chainID || consts_1.Networks[this.schema.gap.network].chainId;
     }
     /**
      * Encodes the schema.
@@ -257,14 +257,15 @@ class Attestation {
     /**
      * Transform attestation interface-based into class-based.
      */
-    static fromInterface(attestations) {
+    static fromInterface(attestations, network) {
         const result = [];
         attestations.forEach((attestation) => {
             try {
-                const schema = Schema_1.Schema.get(attestation.schemaId);
+                const schema = Schema_1.Schema.get(attestation.schemaId, network);
                 result.push(new Attestation({
                     ...attestation,
                     schema,
+                    chainID: consts_1.Networks[network].chainId,
                     data: attestation.decodedDataJson,
                 }));
             }
@@ -288,7 +289,10 @@ class Attestation {
             throw new SchemaError_1.SchemaError('MISSING_FIELD', 'Schema uid is required');
         }
         if (strict)
-            Schema_1.Schema.validate();
+            Schema_1.Schema.validate(this.schema.gap.network);
+    }
+    get chainID() {
+        return this._chainID;
     }
     get data() {
         return this._data;
@@ -315,6 +319,7 @@ class Attestation {
             schema,
             uid: '0x0',
             createdAt: new Date(),
+            chainID: consts_1.Networks[schema.gap.network].chainId,
         });
     }
 }

package/core/class/Fetcher.d.ts

@@ -3,7 +3,11 @@ import { Attestation } from './Attestation';
 import { Community, Grant, MemberOf, Milestone, Project } from './entities';
 import { Grantee } from './types/attestations';
 import { AxiosGQL } from './GraphQL/AxiosGQL';
+import { GAP } from './GAP';
 export declare abstract class Fetcher extends AxiosGQL {
+    protected gap: GAP;
+    constructor(url: string);
+    set gapInstance(gap: GAP);
     /**
      * Fetch a single attestation by its UID.
      * @param uid

package/core/class/Fetcher.js

@@ -3,5 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Fetcher = void 0;
 const AxiosGQL_1 = require("./GraphQL/AxiosGQL");
 class Fetcher extends AxiosGQL_1.AxiosGQL {
+    constructor(url) {
+        super(url);
+    }
+    set gapInstance(gap) {
+        this.gap = gap;
+    }
 }
 exports.Fetcher = Fetcher;

package/core/class/GAP.d.ts

@@ -136,8 +136,7 @@ interface GAPArgs {
  *
  * const schemas = MountEntities(Networks.sepolia);
  *
- * // Use GAP.createClient to create a singleton GAP client
- * const gap = GAP.createClient({
+ * const gap = new GAP({
  *   network: "sepolia",
  *   owner: "0xd7d1DB401EA825b0325141Cd5e6cd7C2d01825f2",
  *   schemas: Object.values(schemas),
@@ -152,7 +151,6 @@ interface GAPArgs {
  * ```
  */
 export declare class GAP extends Facade {
-    private static client;
     private static remoteStorage?;
     readonly fetch: Fetcher;
     readonly network: TNetwork;
@@ -187,19 +185,22 @@ export declare class GAP extends Facade {
      */
     generateSlug: (text: string) => Promise<string>;
     /**
-     * Creates or returns an existing GAP client.
-     *
-     * _Use the constructor only if multiple clients are needed._
-     * @static
-     * @param {GAPArgs} args
+     * Returns a copy of the original schema with no pointers.
+     * @param name
+     * @returns
+     */
+    findSchema(name: TSchemaName): GapSchema;
+    /**
+     * Find many schemas by name and return their copies as an array in the same order.
+     * @param names
      * @returns
      */
-    static createClient(args: GAPArgs): GAP;
+    findManySchemas(names: TSchemaName[]): GapSchema[];
     /**
      * Get the multicall contract
      * @param signer
      */
-    static getMulticall(signer: SignerOrProvider): ethers.Contract;
+    static getMulticall(signer: SignerOrProvider): Promise<ethers.Contract>;
     /**
      * Get the multicall contract
      * @param signer

package/core/class/GAP.js

@@ -9,11 +9,11 @@ const ProjectResolver_json_1 = __importDefault(require("../abi/ProjectResolver.j
 const types_1 = require("../types");
 const Schema_1 = require("./Schema");
 const GapSchema_1 = require("./GapSchema");
-const GapEasClient_1 = require("./GraphQL/GapEasClient");
 const eas_sdk_1 = require("@ethereum-attestation-service/eas-sdk");
 const consts_1 = require("../consts");
 const ethers_1 = require("ethers");
 const package_json_1 = require("../../package.json");
+const GraphQL_1 = require("./GraphQL");
 const get_web3_provider_1 = require("../utils/get-web3-provider");
 /**
  * GAP SDK Facade.
@@ -55,8 +55,7 @@ const get_web3_provider_1 = require("../utils/get-web3-provider");
  *
  * const schemas = MountEntities(Networks.sepolia);
  *
- * // Use GAP.createClient to create a singleton GAP client
- * const gap = GAP.createClient({
+ * const gap = new GAP({
  *   network: "sepolia",
  *   owner: "0xd7d1DB401EA825b0325141Cd5e6cd7C2d01825f2",
  *   schemas: Object.values(schemas),
@@ -97,14 +96,19 @@ class GAP extends types_1.Facade {
         };
         const schemas = args.schemas || Object.values((0, consts_1.MountEntities)(consts_1.Networks[args.network]));
         this.network = args.network;
-        GAP._eas = new eas_sdk_1.EAS(consts_1.Networks[args.network].contracts.eas);
-        this.fetch = args.apiClient || new GapEasClient_1.GapEasClient({ network: args.network });
+        this._eas = new eas_sdk_1.EAS(consts_1.Networks[args.network].contracts.eas);
+        this.fetch =
+            args.apiClient ||
+                new GraphQL_1.GapEasClient({
+                    network: args.network,
+                });
+        this.fetch.gapInstance = this;
         this.assertGelatoOpts(args);
         GAP._gelatoOpts = args.gelatoOpts;
         GAP.remoteStorage = args.remoteStorage;
-        this._schemas = schemas.map((schema) => new GapSchema_1.GapSchema(schema, false, args.globalSchemas ? !args.globalSchemas : false));
-        Schema_1.Schema.validate();
-        console.info(`Loaded GAP SDK v${package_json_1.version}`);
+        this._schemas = schemas.map((schema) => new GapSchema_1.GapSchema(schema, this, false, args.globalSchemas ? !args.globalSchemas : false));
+        Schema_1.Schema.validate(this.network);
+        console.info(`Loaded GAP SDK v${package_json_1.version} for network ${this.network}`);
     }
     assertGelatoOpts(args) {
         if (args.gelatoOpts &&
@@ -131,7 +135,7 @@ class GAP extends types_1.Facade {
      * @param schema
      */
     async attest(attestation) {
-        const schema = GapSchema_1.GapSchema.find(attestation.schemaName);
+        const schema = GapSchema_1.GapSchema.find(attestation.schemaName, this.network);
         return schema.attest(attestation);
     }
     /**
@@ -139,34 +143,43 @@ class GAP extends types_1.Facade {
      * @param schemas
      */
     replaceSchemas(schemas) {
-        Schema_1.Schema.replaceAll(schemas);
+        Schema_1.Schema.replaceAll(schemas, this.network);
     }
     /**
      *  Replaces a schema from the schema list.
      * @throws {SchemaError} if desired schema name does not exist.
      */
     replaceSingleSchema(schema) {
-        Schema_1.Schema.replaceOne(schema);
+        Schema_1.Schema.replaceOne(schema, this.network);
     }
     /**
-     * Creates or returns an existing GAP client.
-     *
-     * _Use the constructor only if multiple clients are needed._
-     * @static
-     * @param {GAPArgs} args
+     * Returns a copy of the original schema with no pointers.
+     * @param name
+     * @returns
+     */
+    findSchema(name) {
+        const found = Schema_1.Schema.get(name, this.network);
+        return GapSchema_1.GapSchema.clone(found);
+    }
+    /**
+     * Find many schemas by name and return their copies as an array in the same order.
+     * @param names
      * @returns
      */
-    static createClient(args) {
-        if (!this.client)
-            this.client = new this(args);
-        return this.client;
+    findManySchemas(names) {
+        const schemas = Schema_1.Schema.getMany(names, this.network);
+        return schemas.map((s) => GapSchema_1.GapSchema.clone(s));
     }
     /**
      * Get the multicall contract
      * @param signer
      */
-    static getMulticall(signer) {
-        const address = consts_1.Networks[this.client.network].contracts.multicall;
+    static async getMulticall(signer) {
+        const chain = (await signer.provider.getNetwork()) || signer.provider.network;
+        const network = Object.values(consts_1.Networks).find((n) => +n.chainId === Number(chain.chainId));
+        if (!network)
+            throw new Error(`Network ${chain.name || chain.chainId} not supported.`);
+        const address = network.contracts.multicall;
         return new ethers_1.ethers.Contract(address, MultiAttester_json_1.default, signer);
     }
     /**
@@ -175,7 +188,8 @@ class GAP extends types_1.Facade {
      */
     static getProjectResolver(signer, chainId) {
         const provider = chainId ? (0, get_web3_provider_1.getWeb3Provider)(chainId) : signer;
-        const address = consts_1.Networks[this.client.network].contracts.projectResolver;
+        const network = Object.values(consts_1.Networks).find((n) => +n.chainId === Number(chainId));
+        const address = network.contracts.projectResolver;
         return new ethers_1.ethers.Contract(address, ProjectResolver_json_1.default, provider);
     }
     get schemas() {

package/core/class/GapSchema.d.ts

@@ -1,5 +1,6 @@
-import { IGapSchema, SchemaInterface, TSchemaName } from "../types";
-import { Schema } from "./Schema";
+import { IGapSchema, SchemaInterface, TNetwork, TSchemaName } from '../types';
+import { Schema } from './Schema';
+import { GAP } from './GAP';
 /**
  * Represents the GapSchema
  * @extends Schema
@@ -7,7 +8,7 @@ import { Schema } from "./Schema";
 export declare class GapSchema extends Schema implements IGapSchema {
     readonly name: TSchemaName;
     readonly references: TSchemaName;
-    constructor(args: SchemaInterface<TSchemaName>, strict?: boolean, ignoreSchema?: boolean);
+    constructor(args: SchemaInterface<TSchemaName>, gap: GAP, strict?: boolean, ignoreSchema?: boolean);
     /**
      * Clones a schema without references to the original.
      * @param schema
@@ -19,13 +20,13 @@ export declare class GapSchema extends Schema implements IGapSchema {
      * @param name
      * @returns
      */
-    static find(name: TSchemaName): GapSchema;
+    static find(name: TSchemaName, network: TNetwork): GapSchema;
     /**
      * Find many schemas by name and return their copies as an array in the same order.
      * @param names
      * @returns
      */
-    static findMany(names: TSchemaName[]): GapSchema[];
+    static findMany(names: TSchemaName[], network: TNetwork): GapSchema[];
     /**
      * Get all schemas that references this schema.
      */

package/core/class/GapSchema.js

@@ -8,16 +8,16 @@ const Schema_1 = require("./Schema");
  * @extends Schema
  */
 class GapSchema extends Schema_1.Schema {
-    constructor(args, strict = false, ignoreSchema = false) {
-        super(args, strict, ignoreSchema);
+    constructor(args, gap, strict = false, ignoreSchema = false) {
+        super(args, gap, strict, ignoreSchema);
         if (!ignoreSchema)
-            Schema_1.Schema.add(new GapSchema({
+            Schema_1.Schema.add(gap.network, new GapSchema({
                 name: args.name,
                 schema: args.schema.map((s) => ({ ...s })),
                 uid: args.uid,
                 references: args.references,
                 revocable: args.revocable,
-            }, strict, true));
+            }, gap, strict, true));
     }
     /**
      * Clones a schema without references to the original.
@@ -31,15 +31,15 @@ class GapSchema extends Schema_1.Schema {
             uid: schema.uid,
             references: schema.references,
             revocable: schema.revocable,
-        }, false, true);
+        }, schema.gap, false, true);
     }
     /**
      * Returns a copy of the original schema with no pointers.
      * @param name
      * @returns
      */
-    static find(name) {
-        const found = Schema_1.Schema.get(name);
+    static find(name, network) {
+        const found = Schema_1.Schema.get(name, network);
         return this.clone(found);
     }
     /**
@@ -47,15 +47,15 @@ class GapSchema extends Schema_1.Schema {
      * @param names
      * @returns
      */
-    static findMany(names) {
-        const schemas = Schema_1.Schema.getMany(names);
+    static findMany(names, network) {
+        const schemas = Schema_1.Schema.getMany(names, network);
         return schemas.map((s) => this.clone(s));
     }
     /**
      * Get all schemas that references this schema.
      */
     get children() {
-        return (0, utils_1.mapFilter)(GapSchema.schemas, (s) => s.references === this.name || s.references === this.uid, (s) => new GapSchema(s, false, true));
+        return (0, utils_1.mapFilter)(GapSchema.schemas[this.gap.network], (s) => s.references === this.name || s.references === this.uid, (s) => new GapSchema(s, s.gap, false, true));
     }
 }
 exports.GapSchema = GapSchema;