@show-karma/karma-gap-sdk 0.4.16 → 0.4.18

package/core/abi/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abis = void 0;
+const AirdropNFT_json_1 = __importDefault(require("./AirdropNFT.json"));
+const Allo_json_1 = __importDefault(require("./Allo.json"));
+const AlloRegistry_json_1 = __importDefault(require("./AlloRegistry.json"));
+const CommunityResolverABI_json_1 = __importDefault(require("./CommunityResolverABI.json"));
+const Donations_json_1 = __importDefault(require("./Donations.json"));
+const EAS_json_1 = __importDefault(require("./EAS.json"));
+const MultiAttester_json_1 = __importDefault(require("./MultiAttester.json"));
+const ProjectResolver_json_1 = __importDefault(require("./ProjectResolver.json"));
+const SchemaRegistry_json_1 = __importDefault(require("./SchemaRegistry.json"));
+exports.abis = {
+    AirdropNFT: AirdropNFT_json_1.default,
+    Allo: Allo_json_1.default,
+    AlloRegistry: AlloRegistry_json_1.default,
+    CommunityResolverABI: CommunityResolverABI_json_1.default,
+    Donations: Donations_json_1.default,
+    EAS: EAS_json_1.default,
+    MultiAttester: MultiAttester_json_1.default,
+    ProjectResolver: ProjectResolver_json_1.default,
+    SchemaRegistry: SchemaRegistry_json_1.default,
+};

package/core/class/AllGapSchemas.d.ts

@@ -0,0 +1,9 @@
+import { SchemaInterface, TNetwork, TSchemaName } from "../types";
+import { GapSchema } from "./GapSchema";
+export declare class AllGapSchemas {
+    allSchemas: {
+        [network: string]: SchemaInterface<TSchemaName>[];
+    };
+    constructor();
+    findSchema(name: TSchemaName, network: TNetwork): GapSchema;
+}

package/core/class/AllGapSchemas.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AllGapSchemas = void 0;
+const consts_1 = require("../../core/consts");
+const GAP_1 = require("./GAP");
+const GapSchema_1 = require("./GapSchema");
+class AllGapSchemas {
+    constructor() {
+        this.allSchemas = {};
+        Object.keys(consts_1.Networks).forEach((network) => {
+            this.allSchemas[network] = Object.values((0, consts_1.MountEntities)(consts_1.Networks[network]));
+        });
+    }
+    findSchema(name, network) {
+        const schema = this.allSchemas[network].find((s) => s.name === name);
+        return new GapSchema_1.GapSchema(schema, GAP_1.GAP.getInstance({ network }), false, false);
+    }
+}
+exports.AllGapSchemas = AllGapSchemas;

package/core/class/Attestation.d.ts

@@ -0,0 +1,173 @@
+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";
+import { AttestationWithTx } from "./types/attestations";
+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 declare class Attestation<T = unknown, S extends Schema = GapSchema> implements AttestationArgs<T, S> {
+    readonly schema: S;
+    private _data;
+    protected _uid: Hex;
+    readonly refUID?: Hex;
+    readonly attester?: Hex;
+    readonly recipient: Hex;
+    readonly revoked?: boolean;
+    readonly revocationTime?: Date;
+    readonly createdAt: Date;
+    private _chainID;
+    private _reference?;
+    constructor(args: AttestationArgs<T, S>);
+    /**
+     * Encodes the schema.
+     * @returns
+     */
+    encodeSchema(schema: SchemaItem[]): string;
+    /**
+     * Sets a field in the schema.
+     */
+    setValue<K extends keyof T>(key: K, value: SchemaValue): void;
+    /**
+     * Set attestation values to be uploaded.
+     * @param values
+     */
+    setValues(values: T): void;
+    /**
+     * Returns the referenced attestation
+     */
+    reference<Ref = unknown, RefSchema extends Schema = Schema>(): Attestation<Ref, RefSchema>;
+    /**
+     * Returns the attestation data as a JSON string.
+     * @param data
+     * @returns
+     */
+    fromDecodedSchema(data: T | JSONStr): T;
+    /**
+     * Revokes this attestation.
+     * @param eas
+     * @param signer
+     * @returns
+     */
+    revoke(signer: SignerOrProvider, callback?: Function): Promise<AttestationWithTx>;
+    /**
+     * 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.
+     */
+    attest(signer: SignerOrProvider, ...args: unknown[]): Promise<AttestationWithTx>;
+    /**
+     * Validates the payload.
+     *
+     * If an attestation should have anything
+     * specifically explicit, it should be implemented in
+     * order to avoid errors.
+     * @returns
+     */
+    protected assertPayload(): boolean;
+    /**
+     * 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]
+     */
+    payloadFor(refIdx: number): Promise<{
+        payload: MultiAttestData;
+        raw: MultiAttestData;
+    }>;
+    /**
+     * Returns an Attestation instance from a JSON decoded schema.
+     * @param data
+     * @returns
+     */
+    static fromDecodedSchema<T>(data: JSONStr): T;
+    /**
+     * Transform attestation interface-based into class-based.
+     */
+    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);
+    /**
+     * 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): Attestation<T, Schema<string>>;
+}

package/core/class/Attestation.js

@@ -0,0 +1,333 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Attestation = void 0;
+const Schema_1 = require("./Schema");
+const SchemaError_1 = require("./SchemaError");
+const get_date_1 = require("../utils/get-date");
+const consts_1 = require("../consts");
+const GapContract_1 = require("./contract/GapContract");
+/**
+ * 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);
+ * ```
+ */
+class Attestation {
+    constructor(args) {
+        this.schema = args.schema;
+        this._data = this.fromDecodedSchema(args.data);
+        this.setValues(this._data);
+        this._uid = args.uid || consts_1.nullRef;
+        this.refUID = args.refUID || consts_1.nullRef;
+        this.attester = args.attester;
+        this.recipient = args.recipient;
+        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 || consts_1.Networks[this.schema.gap.network].chainId;
+    }
+    /**
+     * Encodes the schema.
+     * @returns
+     */
+    encodeSchema(schema) {
+        return this.schema.encode(schema);
+    }
+    /**
+     * Sets a field in the schema.
+     */
+    setValue(key, value) {
+        this.schema.setValue(key, value);
+    }
+    /**
+     * Set attestation values to be uploaded.
+     * @param values
+     */
+    setValues(values) {
+        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, value.value || value);
+        });
+    }
+    /**
+     * Returns the referenced attestation
+     */
+    reference() {
+        return this._reference;
+    }
+    /**
+     * Returns the attestation data as a JSON string.
+     * @param data
+     * @returns
+     */
+    fromDecodedSchema(data) {
+        return typeof data === "string"
+            ? Attestation.fromDecodedSchema(data)
+            : data;
+    }
+    /**
+     * Revokes this attestation.
+     * @param eas
+     * @param signer
+     * @returns
+     */
+    async revoke(signer, callback) {
+        try {
+            callback?.("preparing");
+            const { tx } = await GapContract_1.GapContract.multiRevoke(signer, [
+                {
+                    data: [
+                        {
+                            uid: this.uid,
+                            value: 0n,
+                        },
+                    ],
+                    schema: this.schema.uid,
+                },
+            ]).then((res) => {
+                callback?.("confirmed");
+                return res;
+            });
+            return { tx, uids: [this.uid] };
+        }
+        catch (error) {
+            console.error(error);
+            throw new SchemaError_1.SchemaError("REVOKE_ERROR", "Error revoking attestation.", error);
+        }
+    }
+    /**
+     * 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, ...args) {
+        const callback = typeof args[args.length - 1] === "function"
+            ? args.pop()
+            : null;
+        console.log(`Attesting ${this.schema.name}`);
+        try {
+            const { tx, uids } = await this.schema.attest({
+                data: this.data,
+                to: this.recipient,
+                refUID: this.refUID,
+                signer,
+                callback: callback,
+            });
+            this._uid = uids[0];
+            console.log(`Attested ${this.schema.name} with UID ${this.uid}`);
+            return { tx, uids };
+        }
+        catch (error) {
+            console.error(error);
+            throw new SchemaError_1.AttestationError("ATTEST_ERROR", "Error during attestation.", error);
+        }
+    }
+    /**
+     * Validates the payload.
+     *
+     * If an attestation should have anything
+     * specifically explicit, it should be implemented in
+     * order to avoid errors.
+     * @returns
+     */
+    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) {
+        this.assertPayload();
+        if (this.schema.isJsonSchema()) {
+            if (this.type) {
+                this._data.type = this.type;
+                this.schema.setValue("json", JSON.stringify(this._data));
+            }
+        }
+        const payload = (encode = true) => ({
+            uid: consts_1.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),
+                        recipient: this.recipient,
+                    },
+                ],
+            },
+        });
+        return {
+            payload: payload(),
+            raw: payload(false),
+        };
+    }
+    /**
+     * Returns an Attestation instance from a JSON decoded schema.
+     * @param data
+     * @returns
+     */
+    static fromDecodedSchema(data) {
+        try {
+            const parsed = JSON.parse(data);
+            if (data.length < 2 && !/\{.*\}/gim.test(data))
+                return {};
+            if (parsed.length === 1 && parsed[0].name === "json") {
+                const { value } = parsed[0];
+                return (typeof value.value === "string"
+                    ? JSON.parse(value.value)
+                    : value.value);
+            }
+            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)
+                            : Number(value);
+                    }
+                    else
+                        acc[curr.name] = value;
+                    return acc;
+                }, {});
+            }
+            throw new SchemaError_1.SchemaError("INVALID_DATA", "Data must be a valid JSON array string.");
+        }
+        catch (error) {
+            console.error(error);
+            throw new SchemaError_1.SchemaError("INVALID_DATA", "Data must be a valid JSON string.", error);
+        }
+    }
+    /**
+     * Transform attestation interface-based into class-based.
+     */
+    static fromInterface(attestations, network) {
+        const result = [];
+        attestations.forEach((attestation) => {
+            try {
+                const schema = Schema_1.Schema.get(attestation.schemaId, network);
+                result.push(new Attestation({
+                    ...attestation,
+                    schema,
+                    chainID: consts_1.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
+     */
+    assert(args, strict = false) {
+        const { schema, uid } = args;
+        if (!schema || !(schema instanceof Schema_1.Schema)) {
+            throw new SchemaError_1.SchemaError("MISSING_FIELD", "Schema must be an array.");
+        }
+        if (!uid) {
+            throw new SchemaError_1.SchemaError("MISSING_FIELD", "Schema uid is required");
+        }
+        if (strict)
+            Schema_1.Schema.validate(this.schema.gap.network);
+    }
+    get chainID() {
+        return this._chainID;
+    }
+    get data() {
+        return this._data;
+    }
+    get uid() {
+        return this._uid;
+    }
+    set uid(uid) {
+        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(data, schema, from, to) {
+        return new Attestation({
+            data: data,
+            recipient: to,
+            attester: from,
+            schema,
+            uid: "0x0",
+            createdAt: new Date(),
+            chainID: consts_1.Networks[schema.gap.network].chainId,
+        });
+    }
+}
+exports.Attestation = Attestation;