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

package/core/abi/SchemaRegistry.json

@@ -0,0 +1 @@
+{"address": "0xA7b39296258348C78294F95B872b282326A97BDF","abi": [{"inputs": [],"name": "AlreadyExists","type": "error"},{"anonymous": false,"inputs": [{"indexed": true,"internalType": "bytes32","name": "uid","type": "bytes32"},{"indexed": false,"internalType": "address","name": "registerer","type": "address"}],"name": "Registered","type": "event"},{"inputs": [],"name": "VERSION","outputs": [{"internalType": "string","name": "","type": "string"}],"stateMutability": "view","type": "function"},{"inputs": [{"internalType": "bytes32","name": "uid","type": "bytes32"}],"name": "getSchema","outputs": [{"components": [{"internalType": "bytes32","name": "uid","type": "bytes32"},{"internalType": "contract ISchemaResolver","name": "resolver","type": "address"},{"internalType": "bool","name": "revocable","type": "bool"},{"internalType": "string","name": "schema","type": "string"}],"internalType": "struct SchemaRecord","name": "","type": "tuple"}],"stateMutability": "view","type": "function"},{"inputs": [{"internalType": "string","name": "schema","type": "string"},{"internalType": "contract ISchemaResolver","name": "resolver","type": "address"},{"internalType": "bool","name": "revocable","type": "bool"}],"name": "register","outputs": [{"internalType": "bytes32","name": "","type": "bytes32"}],"stateMutability": "nonpayable","type": "function"}],"transactionHash": "0x9eaa9c685585e12e62b5e323a6a29e81de392a4134cc45a543d1b824ee71d1ec","receipt": {"to": null,"from": "0x2bF22CAe1dc34f265cAE03F6ff419177b4f4FBb3","contractAddress": "0xA7b39296258348C78294F95B872b282326A97BDF","transactionIndex": 15,"gasUsed": "477737","logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","blockHash": "0xf78aba9bfc59ea3b77dc9458655cfaf523e78fed42e9f460c678d64413a5560a","transactionHash": "0x9eaa9c685585e12e62b5e323a6a29e81de392a4134cc45a543d1b824ee71d1ec","logs": [],"blockNumber": 16756726,"cumulativeGasUsed": "2318891","status": 1,"byzantium": true},"args": [],"numDeployments": 1,"solcInputHash": "f4b7f486d6c32786b7e8d2904f9f6cf8","metadata": "{\"compiler\":{\"version\":\"0.8.18+commit.87f61d96\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"AlreadyExists\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"uid\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"registerer\",\"type\":\"address\"}],\"name\":\"Registered\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"VERSION\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"uid\",\"type\":\"bytes32\"}],\"name\":\"getSchema\",\"outputs\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"uid\",\"type\":\"bytes32\"},{\"internalType\":\"contract ISchemaResolver\",\"name\":\"resolver\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"revocable\",\"type\":\"bool\"},{\"internalType\":\"string\",\"name\":\"schema\",\"type\":\"string\"}],\"internalType\":\"struct SchemaRecord\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"schema\",\"type\":\"string\"},{\"internalType\":\"contract ISchemaResolver\",\"name\":\"resolver\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"revocable\",\"type\":\"bool\"}],\"name\":\"register\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"events\":{\"Registered(bytes32,address)\":{\"details\":\"Emitted when a new schema has been registered\",\"params\":{\"registerer\":\"The address of the account used to register the schema.\",\"uid\":\"The schema UID.\"}}},\"kind\":\"dev\",\"methods\":{\"getSchema(bytes32)\":{\"details\":\"Returns an existing schema by UID\",\"params\":{\"uid\":\"The UID of the schema to retrieve.\"},\"returns\":{\"_0\":\"The schema data members.\"}},\"register(string,address,bool)\":{\"details\":\"Submits and reserves a new schema\",\"params\":{\"resolver\":\"An optional schema resolver.\",\"revocable\":\"Whether the schema allows revocations explicitly.\",\"schema\":\"The schema data schema.\"},\"returns\":{\"_0\":\"The UID of the new schema.\"}}},\"title\":\"The global schema registry.\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/SchemaRegistry.sol\":\"SchemaRegistry\"},\"evmVersion\":\"paris\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"none\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000000},\"remappings\":[],\"viaIR\":true},\"sources\":{\"contracts/ISchemaRegistry.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport { ISchemaResolver } from \\\"./resolver/ISchemaResolver.sol\\\";\\n\\n/**\\n * @title A struct representing a record for a submitted schema.\\n */\\nstruct SchemaRecord {\\nbytes32 uid; // The unique identifier of the schema.\\nISchemaResolver resolver; // Optional schema resolver.\\nbool revocable; // Whether the schema allows revocations explicitly.\\nstring schema; // Custom specification of the schema (e.g., an ABI).\\n}\\n\\n/**\\n * @title The global schema registry interface.\\n */\\ninterface ISchemaRegistry {\\n/**\\n * @dev Emitted when a new schema has been registered\\n *\\n * @param uid The schema UID.\\n * @param registerer The address of the account used to register the schema.\\n */\\nevent Registered(bytes32 indexed uid, address registerer);\\n\\n/**\\n * @dev Submits and reserves a new schema\\n *\\n * @param schema The schema data schema.\\n * @param resolver An optional schema resolver.\\n * @param revocable Whether the schema allows revocations explicitly.\\n *\\n * @return The UID of the new schema.\\n */\\nfunction register(string calldata schema, ISchemaResolver resolver, bool revocable) external returns (bytes32);\\n\\n/**\\n * @dev Returns an existing schema by UID\\n *\\n * @param uid The UID of the schema to retrieve.\\n *\\n * @return The schema data members.\\n */\\nfunction getSchema(bytes32 uid) external view returns (SchemaRecord memory);\\n}\\n\",\"keccak256\":\"0xef47e449dd02bd034e26b1dea505ce533906f8462fc674c938ed0e872a68d640\",\"license\":\"MIT\"},\"contracts/SchemaRegistry.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity 0.8.19;\\n\\nimport { EMPTY_UID } from \\\"./Types.sol\\\";\\nimport { ISchemaRegistry, SchemaRecord } from \\\"./ISchemaRegistry.sol\\\";\\n\\nimport { ISchemaResolver } from \\\"./resolver/ISchemaResolver.sol\\\";\\n\\n/**\\n * @title The global schema registry.\\n */\\ncontract SchemaRegistry is ISchemaRegistry {\\nerror AlreadyExists();\\n\\n// The version of the contract.\\nstring public constant VERSION = \\\"0.26\\\";\\n\\n// The global mapping between schema records and their IDs.\\nmapping(bytes32 uid => SchemaRecord schemaRecord) private _registry;\\n\\n/**\\n * @inheritdoc ISchemaRegistry\\n */\\nfunction register(string calldata schema, ISchemaResolver resolver, bool revocable) external returns (bytes32) {\\nSchemaRecord memory schemaRecord = SchemaRecord({\\nuid: EMPTY_UID,\\nschema: schema,\\nresolver: resolver,\\nrevocable: revocable\\n});\\n\\nbytes32 uid = _getUID(schemaRecord);\\nif (_registry[uid].uid != EMPTY_UID) {\\nrevert AlreadyExists();\\n}\\n\\nschemaRecord.uid = uid;\\n_registry[uid] = schemaRecord;\\n\\nemit Registered(uid, msg.sender);\\n\\nreturn uid;\\n}\\n\\n/**\\n * @inheritdoc ISchemaRegistry\\n */\\nfunction getSchema(bytes32 uid) external view returns (SchemaRecord memory) {\\nreturn _registry[uid];\\n}\\n\\n/**\\n * @dev Calculates a UID for a given schema.\\n *\\n * @param schemaRecord The input schema.\\n *\\n * @return schema UID.\\n */\\nfunction _getUID(SchemaRecord memory schemaRecord) private pure returns (bytes32) {\\nreturn keccak256(abi.encodePacked(schemaRecord.schema, schemaRecord.resolver, schemaRecord.revocable));\\n}\\n}\\n\",\"keccak256\":\"0x11ca856573f1b53530d27d40b0a5629a5c591957e221a1b4b8eae2b2053f168b\",\"license\":\"MIT\"},\"contracts/Types.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity 0.8.19;\\n\\n// A representation of an empty/uninitialized UID.\\nbytes32 constant EMPTY_UID = 0;\\n\\n/**\\n * @dev A struct representing EIP712 signature data.\\n */\\nstruct EIP712Signature {\\nuint8 v; // The recovery ID.\\nbytes32 r; // The x-coordinate of the nonce R.\\nbytes32 s; // The signature data.\\n}\\n\\n/**\\n * @dev A struct representing a single attestation.\\n */\\nstruct Attestation {\\nbytes32 uid; // A unique identifier of the attestation.\\nbytes32 schema; // The unique identifier of the schema.\\nuint64 time; // The time when the attestation was created (Unix timestamp).\\nuint64 expirationTime; // The time when the attestation expires (Unix timestamp).\\nuint64 revocationTime; // The time when the attestation was revoked (Unix timestamp).\\nbytes32 refUID; // The UID of the related attestation.\\naddress recipient; // The recipient of the attestation.\\naddress attester; // The attester/sender of the attestation.\\nbool revocable; // Whether the attestation is revocable.\\nbytes data; // Custom attestation data.\\n}\\n\",\"keccak256\":\"0x547096b5cb7bfad9591bdc520705f8110534cd040ed0f7a0ba8d83ea4a565b45\",\"license\":\"MIT\"},\"contracts/resolver/ISchemaResolver.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport { Attestation } from \\\"../Types.sol\\\";\\n\\n/**\\n * @title The interface of an optional schema resolver.\\n */\\ninterface ISchemaResolver {\\n/**\\n * @dev Returns whether the resolver supports ETH transfers.\\n */\\nfunction isPayable() external pure returns (bool);\\n\\n/**\\n * @dev Processes an attestation and verifies whether it's valid.\\n *\\n * @param attestation The new attestation.\\n *\\n * @return Whether the attestation is valid.\\n */\\nfunction attest(Attestation calldata attestation) external payable returns (bool);\\n\\n/**\\n * @dev Processes multiple attestations and verifies whether they are valid.\\n *\\n * @param attestations The new attestations.\\n * @param values Explicit ETH amounts which were sent with each attestation.\\n *\\n * @return Whether all the attestations are valid.\\n */\\nfunction multiAttest(\\nAttestation[] calldata attestations,\\nuint256[] calldata values\\n) external payable returns (bool);\\n\\n/**\\n * @dev Processes an attestation revocation and verifies if it can be revoked.\\n *\\n * @param attestation The existing attestation to be revoked.\\n *\\n * @return Whether the attestation can be revoked.\\n */\\nfunction revoke(Attestation calldata attestation) external payable returns (bool);\\n\\n/**\\n * @dev Processes revocation of multiple attestation and verifies they can be revoked.\\n *\\n * @param attestations The existing attestations to be revoked.\\n * @param values Explicit ETH amounts which were sent with each revocation.\\n *\\n * @return Whether the attestations can be revoked.\\n */\\nfunction multiRevoke(\\nAttestation[] calldata attestations,\\nuint256[] calldata values\\n) external payable returns (bool);\\n}\\n\",\"keccak256\":\"0x0f3a75c28cdb91fa9227a6eef183379ecea2b6bf38db52795b5c4e6af79299e8\",\"license\":\"MIT\"}},\"version\":1}","bytecode": "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","deployedBytecode": "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","devdoc": {"events": {"Registered(bytes32,address)": {"details": "Emitted when a new schema has been registered","params": {"registerer": "The address of the account used to register the schema.","uid": "The schema UID."}}},"kind": "dev","methods": {"getSchema(bytes32)": {"details": "Returns an existing schema by UID","params": {"uid": "The UID of the schema to retrieve."},"returns": {"_0": "The schema data members."}},"register(string,address,bool)": {"details": "Submits and reserves a new schema","params": {"resolver": "An optional schema resolver.","revocable": "Whether the schema allows revocations explicitly.","schema": "The schema data schema."},"returns": {"_0": "The UID of the new schema."}}},"title": "The global schema registry.","version": 1},"userdoc": {"kind": "user","methods": {},"version": 1},"storageLayout": {"storage": [{"astId": 5366,"contract": "contracts/SchemaRegistry.sol:SchemaRegistry","label": "_registry","offset": 0,"slot": "0","type": "t_mapping(t_bytes32,t_struct(SchemaRecord)5313_storage)"}],"types": {"t_bool": {"encoding": "inplace","label": "bool","numberOfBytes": "1"},"t_bytes32": {"encoding": "inplace","label": "bytes32","numberOfBytes": "32"},"t_contract(ISchemaResolver)5553": {"encoding": "inplace","label": "contract ISchemaResolver","numberOfBytes": "20"},"t_mapping(t_bytes32,t_struct(SchemaRecord)5313_storage)": {"encoding": "mapping","key": "t_bytes32","label": "mapping(bytes32 => struct SchemaRecord)","numberOfBytes": "32","value": "t_struct(SchemaRecord)5313_storage"},"t_string_storage": {"encoding": "bytes","label": "string","numberOfBytes": "32"},"t_struct(SchemaRecord)5313_storage": {"encoding": "inplace","label": "struct SchemaRecord","members": [{"astId": 5305,"contract": "contracts/SchemaRegistry.sol:SchemaRegistry","label": "uid","offset": 0,"slot": "0","type": "t_bytes32"},{"astId": 5308,"contract": "contracts/SchemaRegistry.sol:SchemaRegistry","label": "resolver","offset": 0,"slot": "1","type": "t_contract(ISchemaResolver)5553"},{"astId": 5310,"contract": "contracts/SchemaRegistry.sol:SchemaRegistry","label": "revocable","offset": 20,"slot": "1","type": "t_bool"},{"astId": 5312,"contract": "contracts/SchemaRegistry.sol:SchemaRegistry","label": "schema","offset": 0,"slot": "2","type": "t_string_storage"}],"numberOfBytes": "96"}}}}

package/core/class/Attestation.ts

@@ -0,0 +1,402 @@
+import {
+  Hex,
+  IAttestation,
+  JSONStr,
+  MultiAttestData,
+  MultiAttestPayload,
+  SignerOrProvider,
+  TNetwork,
+  TSchemaName,
+} from '../types';
+import { Schema } from './Schema';
+import { AttestationError, SchemaError } from './SchemaError';
+import {
+  SchemaDecodedItem,
+  SchemaItem,
+  SchemaValue,
+} from '@ethereum-attestation-service/eas-sdk';
+import { getDate } from '../utils/get-date';
+import { GAP } from './GAP';
+import { GapSchema } from './GapSchema';
+import { Networks, nullRef } from '../consts';
+import { GapContract } from './contract/GapContract';
+
+export interface AttestationArgs<T = unknown, S extends Schema = Schema> {
+  data: T | string;
+  schema: S;
+  uid?: Hex;
+  refUID?: Hex;
+  attester?: Hex;
+  recipient: Hex;
+  revoked?: boolean;
+  revocationTime?: Date | number;
+  createdAt?: Date | number;
+  chainID?: number;
+}
+
+/**
+ * Represents the EAS Attestation and provides methods to manage attestations.
+ * @example
+ *
+ * ```ts
+ * const grantee = new Attestation({
+ *  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", "optimism"),
+ *  data: {
+ *    name: "John Doe",
+ *    description: "A description",
+ *    imageURL: "https://example.com/image.png",
+ *  },
+ *  uid: "0xab234"
+ * );
+ *
+ * // Return the refferenced attestation
+ * const ref = granteeDetails.reference<Grantee>();
+ *
+ * // Revoke attestation
+ * granteeDetails.revoke();
+ *
+ * // Get attestation data from a decoded JSON string.
+ * granteeDetails.fromDecodedSchema(granteeDetails.data);
+ * ```
+ */
+export class Attestation<T = unknown, S extends Schema = GapSchema>
+  implements AttestationArgs<T, S>
+{
+  readonly schema: S;
+  private _data: T;
+
+  protected _uid: Hex;
+  readonly refUID?: Hex;
+  readonly attester?: Hex;
+  readonly recipient: Hex;
+  readonly revoked?: boolean;
+  readonly revocationTime?: Date;
+  readonly createdAt: Date;
+  private _chainID: number;
+
+  private _reference?: Attestation;
+
+  constructor(args: AttestationArgs<T, S>) {
+    this.schema = args.schema;
+
+    this._data = this.fromDecodedSchema(args.data);
+
+    this.setValues(this._data);
+    this._uid = args.uid || nullRef;
+    this.refUID = args.refUID || nullRef;
+    this.attester = args.attester;
+    this.recipient = args.recipient;
+    this.revoked = args.revoked;
+    this.revocationTime = getDate(args.revocationTime);
+    this.createdAt = getDate(args.createdAt || Date.now() / 1000);
+    this._chainID = args.chainID || Networks[this.schema.gap.network].chainId;
+  }
+
+  /**
+   * Encodes the schema.
+   * @returns
+   */
+  encodeSchema(schema: SchemaItem[]) {
+    return this.schema.encode(schema);
+  }
+
+  /**
+   * Sets a field in the schema.
+   */
+  setValue<K extends keyof T>(key: K, value: SchemaValue) {
+    this.schema.setValue(key as string, value);
+  }
+
+  /**
+   * Set attestation values to be uploaded.
+   * @param values
+   */
+  setValues(values: T) {
+    const isJsonSchema = this.schema.isJsonSchema();
+    if (isJsonSchema) this.schema.setValue('json', JSON.stringify(values));
+    this._data = values;
+
+    Object.entries(values).forEach(([key, value]) => {
+      this[key] = value;
+      if (!isJsonSchema) this.setValue(key as keyof T, value.value || value);
+    });
+  }
+
+  /**
+   * Returns the referenced attestation
+   */
+  reference<Ref = unknown, RefSchema extends Schema = Schema>() {
+    return this._reference as Attestation<Ref, RefSchema>;
+  }
+
+  /**
+   * Returns the attestation data as a JSON string.
+   * @param data
+   * @returns
+   */
+  fromDecodedSchema(data: T | JSONStr): T {
+    return typeof data === 'string'
+      ? Attestation.fromDecodedSchema<T>(data)
+      : data;
+  }
+
+  /**
+   * Revokes this attestation.
+   * @param eas
+   * @param signer
+   * @returns
+   */
+  revoke(signer: SignerOrProvider) {
+    try {
+      return GapContract.multiRevoke(signer, [
+        {
+          data: [
+            {
+              uid: this.uid,
+              value: 0n,
+            },
+          ],
+          schema: this.schema.uid,
+        },
+      ]);
+    } catch (error) {
+      console.error(error);
+      throw new SchemaError('REVOKE_ERROR', 'Error revoking attestation.');
+    }
+  }
+
+  /**
+   * Attests the data using the specified signer and schema.
+   * @param signer - The signer or provider to use for attestation.
+   * @param args - Additional arguments to pass to the schema's `attest` method.
+   * @returns A Promise that resolves to the UID of the attestation.
+   * @throws An `AttestationError` if an error occurs during attestation.
+   */
+  async attest(signer: SignerOrProvider, ...args: unknown[]) {
+    console.log(`Attesting ${this.schema.name}`);
+    try {
+      const uid = await this.schema.attest<T>({
+        data: this.data,
+        to: this.recipient,
+        refUID: this.refUID,
+        signer,
+      });
+      this._uid = uid;
+      console.log(`Attested ${this.schema.name} with UID ${uid}`);
+    } catch (error) {
+      console.error(error);
+      throw new AttestationError('ATTEST_ERROR', 'Error during attestation.');
+    }
+  }
+
+  /**
+   * Validates the payload.
+   *
+   * If an attestation should have anything
+   * specifically explicit, it should be implemented in
+   * order to avoid errors.
+   * @returns
+   */
+  protected assertPayload() {
+    return true;
+  }
+
+  /**
+   * Get the multi attestation payload for the referred index.
+   *
+   * The index should be the array position this payload wants
+   * to reference.
+   *
+   * E.g:
+   *
+   * 1. Project is index 0;
+   * 2. Project details is index 1;
+   * 3. Grant is index 2;
+   * 4. Grant details is index 3;
+   * 5. Milestone is index 4;
+   *
+   * `[Project, projectDetails, grant, grantDetails, milestone]`
+   *
+   * -> Project.payloadFor(0); // refs itself (no effect)
+   *
+   * -> project.details.payloadFor(0); // ref project
+   *
+   * -> grant.payloadFor(0); // ref project
+   *
+   * -> grant.details.payloadFor(2); // ref grant
+   *
+   * -> milestone.payloadFor(2); // ref grant
+   *
+   *
+   * @param refIdx
+   * @returns [Encoded payload, Raw payload]
+   */
+  async payloadFor(refIdx: number): Promise<{
+    payload: MultiAttestData;
+    raw: MultiAttestData;
+  }> {
+    this.assertPayload();
+
+    if (this.schema.isJsonSchema()) {
+      const { remoteClient } = GAP;
+      if (remoteClient) {
+        const cid = await remoteClient.save(this._data, this.schema.name);
+        const encodedData = remoteClient.encode(cid);
+        this.schema.setValue('json', JSON.stringify(encodedData));
+      }
+    }
+
+    const payload = (encode = true): MultiAttestData => ({
+      uid: nullRef,
+      refIdx,
+      multiRequest: {
+        schema: this.schema.uid,
+        data: [
+          {
+            refUID: this.refUID,
+            expirationTime: 0n,
+            revocable: this.schema.revocable || true,
+            value: 0n,
+            data: (encode ? this.schema.encode() : this.schema.schema) as any,
+            recipient: this.recipient,
+          },
+        ],
+      },
+    });
+    return {
+      payload: payload(),
+      raw: payload(false),
+    };
+  }
+
+  /**
+   * Returns an Attestation instance from a JSON decoded schema.
+   * @param data
+   * @returns
+   */
+  static fromDecodedSchema<T>(data: JSONStr): T {
+    try {
+      const parsed: SchemaDecodedItem[] = JSON.parse(data);
+
+      if (data.length < 2 && !/\{.*\}/gim.test(data)) return {} as T;
+      if (parsed.length === 1 && parsed[0].name === 'json') {
+        const { value } = parsed[0];
+        return (
+          typeof value.value === 'string'
+            ? JSON.parse(value.value)
+            : value.value
+        ) as T;
+      }
+
+      if (parsed && Array.isArray(parsed)) {
+        return parsed.reduce((acc, curr) => {
+          const { value } = curr.value;
+          if (curr.type.includes('uint')) {
+            acc[curr.name] = ['string', 'bigint'].includes(typeof value)
+              ? BigInt(value as any)
+              : Number(value);
+          } else acc[curr.name] = value;
+          return acc;
+        }, {}) as T;
+      }
+
+      throw new SchemaError(
+        'INVALID_DATA',
+        'Data must be a valid JSON array string.'
+      );
+    } catch (error) {
+      console.error(error);
+      throw new SchemaError(
+        'INVALID_DATA',
+        'Data must be a valid JSON string.'
+      );
+    }
+  }
+
+  /**
+   * Transform attestation interface-based into class-based.
+   */
+  static fromInterface<T extends Attestation = Attestation>(
+    attestations: IAttestation[],
+    network: TNetwork
+  ) {
+    const result: T[] = [];
+    attestations.forEach((attestation) => {
+      try {
+        const schema = Schema.get(attestation.schemaId, network);
+        result.push(
+          <T>new Attestation({
+            ...attestation,
+            schema,
+            chainID: Networks[network].chainId,
+            data: attestation.decodedDataJson,
+          })
+        );
+      } catch (e) {
+        console.log(e);
+      }
+    });
+    return result;
+  }
+
+  /**
+   * 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 = false) {
+    const { schema, uid } = args;
+
+    if (!schema || !(schema instanceof Schema)) {
+      throw new SchemaError('MISSING_FIELD', 'Schema must be an array.');
+    }
+
+    if (!uid) {
+      throw new SchemaError('MISSING_FIELD', 'Schema uid is required');
+    }
+
+    if (strict) Schema.validate(this.schema.gap.network);
+  }
+
+  get chainID() {
+    return this._chainID;
+  }
+
+  get data(): T {
+    return this._data;
+  }
+
+  get uid() {
+    return this._uid;
+  }
+
+  set uid(uid: Hex) {
+    this._uid = uid;
+  }
+
+  /**
+   * Create attestation to serve as Attestation data.
+   * @param data Data to attest
+   * @param schema selected schema
+   * @param from attester
+   * @param to recipient
+   * @returns
+   */
+  static factory<T = unknown>(data: T, schema: Schema, from: Hex, to: Hex) {
+    return new Attestation({
+      data: data,
+      recipient: to,
+      attester: from,
+      schema,
+      uid: '0x0',
+      createdAt: new Date(),
+      chainID: Networks[schema.gap.network].chainId,
+    });
+  }
+}

package/core/class/Fetcher.ts

@@ -0,0 +1,202 @@
+import { Hex, IAttestation, TSchemaName } from 'core/types';
+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 abstract class Fetcher extends AxiosGQL {
+  protected gap: GAP;
+
+  constructor(url: string) {
+    super(url);
+  }
+
+  set gapInstance(gap: GAP) {
+    this.gap = gap;
+  }
+
+  /**
+   * Fetch a single attestation by its UID.
+   * @param uid
+   */
+  abstract attestation<T = unknown>(uid: Hex): Promise<Attestation<T>>;
+
+  /**
+   * Fetch attestations of a schema.
+   * @param schemaName
+   * @param search if set, will search decodedDataJson by the value.
+   * @returns
+   */
+  abstract attestations(
+    schemaName: TSchemaName,
+    search?: string
+  ): Promise<IAttestation[]>;
+
+  /**
+   * Fetch attestations of a schema.
+   * @param schemaName
+   * @param recipient
+   * @returns
+   */
+  abstract attestationsOf(
+    schemaName: TSchemaName,
+    recipient: Hex
+  ): Promise<IAttestation[]>;
+
+  /**
+   * Fetch attestations of a schema for a specific recipient.
+   * @param schemaName
+   * @param recipient
+   * @returns
+   */
+  abstract attestationsTo(
+    schemaName: TSchemaName,
+    recipient: Hex
+  ): Promise<IAttestation[]>;
+
+  /**
+   * Fetch all available communities with details and grantees uids.
+   *
+   * If search is defined, will try to find communities by the search string.
+   * @param search
+   * @returns
+   */
+  abstract communities(search?: string): Promise<Community[]>;
+
+  /**
+   * Fetch all available communities with details for a grantee;
+   *
+   * If search is defined, will try to find communities by the search string.
+   * @param address grantee address
+   * @param withGrants if true, will get community grants.
+   * @returns
+   */
+  abstract communitiesOf(
+    address: Hex,
+    withGrants?: boolean
+  ): Promise<Community[]>;
+
+  /**
+   * Fetch a set of communities by their ids.
+   * @param uids
+   * @returns
+   */
+  abstract communitiesByIds(uids: Hex[]): Promise<Community[]>;
+
+  /**
+   * Fetch a community by its name with details, grants and milestones.
+   *
+   * It is possible that the resulted community is not the one you are looking for.
+   * @param name
+   * @returns
+   */
+  abstract communityBySlug(slug: string): Promise<Community>;
+
+  /**
+   * Fetch a community by its id. This method will also return the
+   * community details and projects.
+   */
+  abstract communityById(uid: Hex): Promise<Community>;
+
+  /**
+   * Fetch a project by its id.
+   * @param uid
+   * @returns
+   */
+  abstract projectById(uid: Hex): Promise<Project>;
+
+  /**
+   * Fetch a project by its slug.
+   * @param slug
+   * @returns
+   */
+  abstract projectBySlug(slug: string): Promise<Project>;
+
+  /**
+   * Search projects by name. This method will return a list of projects
+   * __Must be implemented by the indexer__
+   * @param query
+   */
+  abstract searchProjects(query: string): Promise<Project[]>;
+
+  /**
+   * Fetch projects with details and members.
+   * @param name if set, will search by the name.
+   * @returns
+   */
+  abstract projects(name?: string): Promise<Project[]>;
+
+  /**
+   * Fetch projects with details and members.
+   * @param grantee the public address of the grantee
+   * @returns
+   */
+  abstract projectsOf(grantee: Hex): Promise<Project[]>;
+
+  /**
+   * Fetch Grantee with details and projects.
+   * @param address
+   * @param withProjects if true, will get grantee project details.
+   * @returns
+   */
+  abstract grantee(address: Hex): Promise<Grantee>;
+
+  /**
+   * Fetch all Grantees with details.
+   * @returns
+   */
+  abstract grantees(): Promise<Grantee[]>;
+
+  /**
+   * Fetches the grantes related to a grantee address (recipient).
+   * @param grantee grantee address
+   * @returns
+   */
+  abstract grantsOf(grantee: Hex, withCommunity?: boolean): Promise<Grant[]>;
+
+  /**
+   * Fetch grants for an array of projects with milestones.
+   * @param projects
+   * @returns
+   */
+  abstract grantsFor(
+    projects: Project[],
+    withCommunity?: boolean
+  ): Promise<Grant[]>;
+
+  /**
+   * Fetch a grants that belongs to a community.
+   * @param uid community uid
+   * @returns
+   */
+  abstract grantsByCommunity(uid: Hex);
+
+  /**
+   * Fetch all milestones related to an array of Grants.
+   * @param grants
+   * @returns
+   */
+  abstract milestonesOf(grants: Grant[]): Promise<Milestone[]>;
+
+  /**
+   * Bulk fetch members with details of an array of Projects.
+   * @param projects
+   * @returns
+   */
+  abstract membersOf(projects: Project[]): Promise<MemberOf[]>;
+
+  /**
+   * Check if a name is already in use.
+   * @param slug
+   * @returns
+   */
+  abstract slugExists(slug: string): Promise<boolean>;
+
+  /**
+   * Get grants for a project by an external uid
+   * > Works only for the indexed projects
+   * @param projectExtId
+   */
+  abstract grantsForExtProject(projectExtId: string): Promise<Grant[]>;
+}

package/core/class/GAP.d.ts

@@ -205,7 +205,9 @@ export declare class GAP extends Facade {
      * Get the multicall contract
      * @param signer
      */
-    static getProjectResolver(signer: SignerOrProvider, chainId?: number): ethers.Contract;
+    static getProjectResolver(signer: SignerOrProvider & {
+        getChainId?: () => Promise<number>;
+    }, chainId?: number): Promise<ethers.Contract>;
     get schemas(): GapSchema[];
     /**
      * Defined if the transactions will be gasless or not.

package/core/class/GAP.js

@@ -186,9 +186,12 @@ class GAP extends types_1.Facade {
      * Get the multicall contract
      * @param signer
      */
-    static getProjectResolver(signer, chainId) {
+    static async getProjectResolver(signer, chainId) {
+        const currentChainId = chainId ||
+            Number((await signer.provider.getNetwork())?.chainId ||
+                (await signer.getChainId()));
         const provider = chainId ? (0, get_web3_provider_1.getWeb3Provider)(chainId) : signer;
-        const network = Object.values(consts_1.Networks).find((n) => +n.chainId === Number(chainId));
+        const network = Object.values(consts_1.Networks).find((n) => +n.chainId === Number(currentChainId));
         const address = network.contracts.projectResolver;
         return new ethers_1.ethers.Contract(address, ProjectResolver_json_1.default, provider);
     }