@show-karma/karma-gap-sdk 0.1.29

package/core/class/Schema.js

@@ -0,0 +1,434 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Schema = void 0;
+const eas_sdk_1 = require("@ethereum-attestation-service/eas-sdk");
+const SchemaError_1 = require("./SchemaError");
+const ethers_1 = require("ethers");
+const consts_1 = require("../consts");
+const GAP_1 = require("./GAP");
+const GapContract_1 = require("./contract/GapContract");
+/**
+ * Represents the EAS Schema and provides methods to encode and decode the schema,
+ * and validate the schema references.
+ *
+ * Also provides a set of static methods to manage the schema list.
+ *
+ * @example
+ * ```
+ * // You may or not attribute a schema to a variable.
+ * new Schema({
+ *  name: "Grantee",
+ *  schema: [{ type: "bool", name: "grantee", value: true }],
+ *  uid: "0x000000000
+ * });
+ *
+ * const granteeDetails = new Schema({
+ *  name: "GranteeDetails",
+ *  schema: [
+ *    { type: "bool", name: "name", value: null }
+ *    { type: "bool", name: "description", value: null }
+ *    { type: "bool", name: "imageURL", value: null }
+ *  ],
+ *  uid: "0x000000000,
+ *  references: "Grantee"
+ * });
+ *
+ * // Validate if references are correct and all of them exist.
+ * Schema.validate();
+ *
+ * // Gets the schema by name.
+ * const grantee = Schema.get("Grantee");
+ *
+ * // Sets a single schema value.
+ * grantee.setValue("grantee", true);
+ *
+ * // Sets multiple schema values.
+ * granteeDetails.setValues({ name: "John Doe", description: "A description", imageURL: "https://example.com/image.png" });
+ *
+ * // Gets the schema encoded data, used to create an attestation.
+ * const encodedGrantee = grantee.encode();
+ *
+ * // Verify if schema exists
+ * Schema.exists("Grantee"); // true
+ * Schema.exists("GranteeDetails"); // true
+ * Schema.exists("GranteeDetails2"); // false
+ *
+ * // Get all schemas.
+ * Schema.getAll(); // [grantee, granteeDetails]
+ *
+ * // Get all schema names.
+ * Schema.getNames(); // ["Grantee", "GranteeDetails"]
+ *
+ * // Get many schemas by name. Throws an error if schema does not exist.
+ * Schema.getMany(["Grantee", "GranteeDetails"]); // [grantee, granteeDetails]
+ *
+ * // Replace all schemas. Throws an error if schema does not exist.
+ * Schema.replaceAll([grantee, granteeDetails]);
+ *
+ * // Replace one schema. This will replace a schema using the inbound schema name.. Throws an error if schema does not exist.
+ * Schema.replaceOne(grantee);
+ *
+ * // Converts a raw schema string (e.g. "uint256 id, string name") to a SchemaItem[].
+ * const schema = Schema.rawToObject("uint256 id, string name");
+ * ```
+ */
+class Schema {
+    /**
+     * 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, strict = false, ignoreSchema = false) {
+        this._schema = [];
+        this.assert(args, strict);
+        this._schema = args.schema;
+        this.uid = args.uid;
+        this.name = args.name;
+        this.references = args.references;
+        this.revocable = args.revocable || true;
+        this.encoder = new eas_sdk_1.SchemaEncoder(this.raw);
+    }
+    /**
+     * Encode the schema to be used as payload in the attestation
+     * @returns
+     */
+    encode(schema) {
+        return this.encoder.encodeData(schema || this.schema);
+    }
+    /**
+     * Set a schema field value.
+     * @param key
+     * @param value
+     */
+    setValue(key, value) {
+        const idx = this._schema.findIndex((item) => item.name === key);
+        if (!~idx)
+            throw new SchemaError_1.SchemaError("INVALID_SCHEMA_FIELD", `Field ${key} not found in schema ${this.name}`);
+        this.assertField(this._schema[idx], value);
+        this._schema[idx].value = value;
+    }
+    /**
+     * Tests if the current schema is a JSON Schema.
+     *
+     * @returns boolean
+     */
+    isJsonSchema() {
+        return !!this.schema.find((s) => s.name === "json" && s.type === "string");
+    }
+    assertField(item, value) {
+        const { type, name } = item;
+        if (type.includes("uint") && /\D/.test(value)) {
+            throw new SchemaError_1.SchemaError("INVALID_SCHEMA_FIELD", `Field ${name} is of type ${type} but value is not a number.`);
+        }
+        if (type.includes("address") &&
+            !ethers_1.ethers.utils.isAddress(value) &&
+            value !== consts_1.zeroAddress) {
+            throw new SchemaError_1.SchemaError("INVALID_SCHEMA_FIELD", `Field ${name} is of type ${type} but value is not a valid address.`);
+        }
+        if (type.includes("bytes") && !value.startsWith("0x")) {
+            throw new SchemaError_1.SchemaError("INVALID_SCHEMA_FIELD", `Field ${name} is of type ${type} but value is not a valid hex string.`);
+        }
+        if (type.includes("bool") &&
+            (!["true", "false", true, false].includes(value) ||
+                typeof value !== "boolean")) {
+            throw new SchemaError_1.SchemaError("INVALID_SCHEMA_FIELD", `Field ${name} is of type ${type} but value is not a valid boolean.`);
+        }
+        if (type.includes("tuple") && !Array.isArray(value)) {
+            throw new SchemaError_1.SchemaError("INVALID_SCHEMA_FIELD", `Field ${name} is of type ${type} but value is not a valid array.`);
+        }
+        if (type === "string" && name === "json") {
+            try {
+                JSON.parse(value);
+            }
+            catch (error) {
+                throw new SchemaError_1.SchemaError("INVALID_SCHEMA_FIELD", `Field ${name} is of type ${type} but value is not a valid JSON string.`);
+            }
+        }
+    }
+    /**
+     * Asserts if schema is valid.
+     * > Does not check references if `strict = false`. To check references use `Schema.validate()`
+     * @param args
+     */
+    assert(args, strict = false) {
+        const { name, schema, uid, references } = args;
+        if (!name) {
+            throw new SchemaError_1.SchemaError("MISSING_FIELD", "Schema name is required");
+        }
+        if (!schema && !Array.isArray(schema)) {
+            throw new SchemaError_1.SchemaError("MISSING_FIELD", "Schema must be an array.");
+        }
+        // if (!uid) {
+        //   throw new SchemaError("MISSING_FIELD", "Schema uid is required");
+        // }
+        if (strict && references && !Schema.exists(references)) {
+            throw new SchemaError_1.SchemaError("INVALID_REFERENCE", `Schema ${name} references ${references} but it does not exist.`);
+        }
+    }
+    /**
+     * Attest off chain data
+     * @returns
+     */
+    async attestOffchain({ data, signer, to, refUID }) {
+        const eas = await GAP_1.GAP.eas.getOffchain();
+        const payload = {
+            data,
+            version: eas.version,
+            revocable: this.revocable,
+            expirationTime: 0n,
+            recipient: to,
+            refUID,
+            schema: this.raw,
+            time: BigInt((Date.now() / 1000).toFixed(0)),
+        };
+        return eas.signOffchainAttestation(payload, signer);
+    }
+    /**
+     * Revokes one off chain attestation by its UID.
+     * @param uid
+     * @param signer
+     * @returns
+     */
+    async revokeOffchain(uid, signer) {
+        const eas = GAP_1.GAP.eas.connect(signer);
+        return eas.revokeOffchain(uid);
+    }
+    /**
+     * Revokes multiple off chain attestations by their UIDs.
+     * @param uids
+     * @param signer
+     * @returns
+     */
+    async multiRevokeOffchain(uids, signer) {
+        const eas = GAP_1.GAP.eas.connect(signer);
+        return eas.multiRevokeOffchain(uids);
+    }
+    /**
+     * Attest for a schema.
+     * @param param0
+     * @returns
+     */
+    async attest({ data, to, signer, refUID }) {
+        const eas = GAP_1.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()) {
+            this.setValue("json", JSON.stringify(data));
+        }
+        else {
+            Object.entries(data).forEach(([key, value]) => {
+                this.setValue(key, value);
+            });
+        }
+        const payload = {
+            schema: this.uid,
+            data: {
+                raw: {
+                    recipient: to,
+                    expirationTime: 0n,
+                    revocable: true,
+                    data: this.schema,
+                    refUID,
+                    value: 0n,
+                },
+                payload: {
+                    recipient: to,
+                    expirationTime: 0n,
+                    revocable: true,
+                    data: this.encode(this.schema),
+                    refUID,
+                    value: 0n,
+                },
+            },
+        };
+        if (consts_1.useDefaultAttestation.includes(this.name)) {
+            const tx = await eas.attest({
+                schema: this.uid,
+                data: payload.data.payload,
+            });
+            return tx.wait();
+        }
+        const uid = await GapContract_1.GapContract.attest(signer, payload);
+        return uid;
+    }
+    /**
+     * Bulk attest a set of attestations.
+     * @param signer
+     * @param entities
+     * @returns
+     */
+    async multiAttest(signer, entities = []) {
+        entities.forEach((entity) => {
+            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 entityBySchema = entities.reduce((acc, entity) => {
+            const schema = entity.schema.uid;
+            if (!acc[schema])
+                acc[schema] = [];
+            acc[schema].push(entity);
+            return acc;
+        }, {});
+        const payload = Object.entries(entityBySchema).map(([schema, ents]) => ({
+            schema,
+            data: ents.map((e) => ({
+                data: e.schema.encode(),
+                refUID: e.refUID,
+                recipient: e.recipient,
+                expirationTime: 0n,
+            })),
+        }));
+        const tx = await eas.multiAttest(payload, {
+            gasLimit: 5000000n,
+        });
+        return tx.wait();
+    }
+    /**
+     * Revokes a set of attestations by their UIDs.
+     * @param signer
+     * @param uids
+     * @returns
+     */
+    async multiRevoke(signer, toRevoke) {
+        const groupBySchema = toRevoke.reduce((acc, { uid, schemaId }) => {
+            if (!acc[schemaId])
+                acc[schemaId] = [];
+            acc[schemaId].push(uid);
+            return acc;
+        }, {});
+        const eas = GAP_1.GAP.eas.connect(signer);
+        const payload = Object.entries(groupBySchema).map(([schema, uids]) => ({
+            schema,
+            data: uids.map((uid) => ({ uid })),
+        }));
+        const tx = await eas.multiRevoke(payload, {
+            gasLimit: 5000000n,
+        });
+        return tx.wait();
+    }
+    static exists(name) {
+        return this.schemas.find((schema) => schema.name === name);
+    }
+    /**
+     * Adds the schema signature to a shares list. Use Schema.get("SchemaName") to get the schema.
+     *
+     * __Note that this will make the schema available to all instances
+     * of the class AND its data can be overriden by any changes.__
+     * @param schemas
+     */
+    static add(...schemas) {
+        schemas.forEach((schema) => {
+            if (!this.exists(schema.name))
+                this.schemas.push(schema);
+            else
+                throw new SchemaError_1.SchemaError("SCHEMA_ALREADY_EXISTS", `Schema ${schema.name} already exists.`);
+        });
+    }
+    static getAll() {
+        return this.schemas;
+    }
+    static get(name) {
+        const schema = this.schemas.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()}`);
+        return schema;
+    }
+    /**
+     * Find many schemas by name and return them as an array in the same order.
+     * @param names
+     * @returns
+     */
+    static getMany(names) {
+        return names.map((name) => this.get(name));
+    }
+    static getNames() {
+        return Schema.schemas.map((schema) => schema.name);
+    }
+    /**
+     * Validade references
+     * @throws {SchemaError} if any reference is not valid
+     * @returns {true} if references are valid
+     */
+    static validate() {
+        const errors = [];
+        this.schemas.forEach((schema) => {
+            if (!schema.references || Schema.exists(schema.references))
+                return;
+            else
+                errors.push(new SchemaError_1.SchemaError("INVALID_REFERENCE", `Schema ${schema.name} references ${schema.references} but it does not exist.`));
+        });
+        if (errors.length)
+            throw errors;
+        return true;
+    }
+    /**
+     * Replaces the schema list with a new list.
+     * @param schemas
+     */
+    static replaceAll(schemas) {
+        this.schemas = 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);
+        if (!~idx)
+            throw new SchemaError_1.SchemaError("SCHEMA_NOT_FOUND", `Schema ${schema.name} not found.`);
+        this.schemas[idx] = schema;
+    }
+    /**
+     * Transforms the given raw schema to SchemaItem[]
+     *
+     * @example
+     * ```
+     * const schema = Schema.rawToObject("uint256 id, string name");
+     * // schema = [{ type: "uint256", name: "id", value: null }, { type: "string", name: "name", value: null }]
+     * ```
+     * @param abi
+     * @returns
+     */
+    static rawToObject(abi) {
+        const items = abi.trim().replace(/,\s+/gim, ",").split(",");
+        const schema = items.map((item) => {
+            const [type, name] = item.split(" ");
+            return { type, name, value: null };
+        });
+        return schema;
+    }
+    /**
+     * Returns the raw schema string.
+     * @example
+     * ```ts
+     * const schema = new Schema({ name: "Grantee", schema: [{ type: "bool", name: "grantee", value: true }], uid: "0x000000000" });
+     * schema.raw; // "bool grantee"
+     * ```
+     */
+    get raw() {
+        return this.schema.map((item) => `${item.type} ${item.name}`).join(",");
+    }
+    get schema() {
+        return this._schema;
+    }
+    /**
+     * Get all schemas that references this schema. Note that this
+     * will return a reference to the original schema and all
+     * 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);
+    }
+    /**
+     * Asserts and sets the schema value.
+     */
+    set schema(schema) {
+        schema.forEach((item) => {
+            this.setValue(item.name, item.value);
+        });
+    }
+}
+exports.Schema = Schema;
+Schema.schemas = [];

package/core/class/SchemaError.d.ts

@@ -0,0 +1,26 @@
+declare const SchemaErrorCodes: {
+    INVALID_SCHEMA: number;
+    INVALID_SCHEMA_NAME: number;
+    INVALID_SCHEMA_TYPE: number;
+    SCHEMA_ALREADY_EXISTS: number;
+    SCHEMA_NOT_FOUND: number;
+    SCHEMA_NOT_CREATED: number;
+    MISSING_FIELD: number;
+    INVALID_REFERENCE: number;
+    INVALID_SCHEMA_FIELD: number;
+    INVALID_DATA: number;
+    REVOKE_ERROR: number;
+    ATTEST_ERROR: number;
+    INVALID_REF_UID: number;
+    REVOKATION_ERROR: number;
+    NOT_REVOCABLE: number;
+};
+export declare class SchemaError extends Error {
+    readonly code: number;
+    private readonly _message;
+    constructor(code: keyof typeof SchemaErrorCodes, append?: string);
+    get message(): string;
+}
+export declare class AttestationError extends SchemaError {
+}
+export {};

package/core/class/SchemaError.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttestationError = exports.SchemaError = void 0;
+const SchemaErrorCodes = {
+    INVALID_SCHEMA: 50001,
+    INVALID_SCHEMA_NAME: 50002,
+    INVALID_SCHEMA_TYPE: 50003,
+    SCHEMA_ALREADY_EXISTS: 50004,
+    SCHEMA_NOT_FOUND: 50005,
+    SCHEMA_NOT_CREATED: 50006,
+    MISSING_FIELD: 50007,
+    INVALID_REFERENCE: 50008,
+    INVALID_SCHEMA_FIELD: 50009,
+    INVALID_DATA: 50010,
+    REVOKE_ERROR: 50011,
+    ATTEST_ERROR: 50012,
+    INVALID_REF_UID: 50013,
+    REVOKATION_ERROR: 50014,
+    NOT_REVOCABLE: 50015,
+};
+class SchemaError extends Error {
+    constructor(code, append) {
+        super(`${code}${append ? `: ${append}` : ""}`);
+        this._message = append || code.replace(/_/g, " ");
+        this.code = SchemaErrorCodes[code];
+    }
+    get message() {
+        return this._message;
+    }
+}
+exports.SchemaError = SchemaError;
+class AttestationError extends SchemaError {
+}
+exports.AttestationError = AttestationError;

package/core/class/contract/GapContract.d.ts

@@ -0,0 +1,55 @@
+import { Hex, RawAttestationPayload, RawMultiAttestPayload, SignerOrProvider } from 'core/types';
+import { MultiRevocationRequest } from '@ethereum-attestation-service/eas-sdk';
+export declare class GapContract {
+    static nonces: {
+        [key: string]: number;
+    };
+    /**
+     * Signs a message for the delegated attestation.
+     * @param signer
+     * @param payload
+     * @returns r,s,v signature
+     */
+    private static signAttestation;
+    /**
+     * Returns the r, s, v values of a signature
+     * @param signature
+     * @returns
+     */
+    private static getRSV;
+    private static getSignerAddress;
+    /**
+     * Get nonce for the transaction
+     * @param address
+     * @returns
+     */
+    private static getNonce;
+    /**
+     * Send a single attestation
+     * @param signer
+     * @param payload
+     * @returns
+     */
+    static attest(signer: SignerOrProvider, payload: RawAttestationPayload): Promise<`0x${string}`>;
+    static attestBySig(signer: SignerOrProvider, payload: RawAttestationPayload): Promise<`0x${string}`>;
+    /**
+     * Performs a referenced multi attestation.
+     *
+     * @returns an array with the attestation UIDs.
+     */
+    static multiAttest(signer: SignerOrProvider, payload: RawMultiAttestPayload[]): Promise<Hex[]>;
+    /**
+     * Performs a referenced multi attestation.
+     *
+     * @returns an array with the attestation UIDs.
+     */
+    static multiAttestBySig(signer: SignerOrProvider, payload: RawMultiAttestPayload[]): Promise<Hex[]>;
+    static multiRevoke(signer: SignerOrProvider, payload: MultiRevocationRequest[]): Promise<any>;
+    /**
+     * Performs a referenced multi attestation.
+     *
+     * @returns an array with the attestation UIDs.
+     */
+    static multiRevokeBySig(signer: SignerOrProvider, payload: MultiRevocationRequest[]): Promise<void>;
+    private static getTransactionLogs;
+}