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

package/core/class/Schema.d.ts

@@ -0,0 +1,233 @@
+import { SchemaEncoder, SchemaItem, SchemaValue } from "@ethereum-attestation-service/eas-sdk";
+import { AttestArgs, Hex, MultiRevokeArgs, SchemaInterface, SignerOrProvider, TNetwork } from "../types";
+import { ethers } from "ethers";
+import { GAP } from "./GAP";
+import { Attestation } from "./Attestation";
+import { AttestationWithTx } from "./types/attestations";
+/**
+ * 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");
+ * ```
+ */
+export declare abstract class Schema<T extends string = string> implements SchemaInterface<T> {
+    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;
+    readonly oldSchemas?: {
+        uid: string;
+        raw: SchemaItem[];
+    }[];
+    /**
+     * 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>, gap?: GAP, strict?: boolean, ignoreSchema?: boolean);
+    /**
+     * Encode the schema to be used as payload in the attestation
+     * @returns
+     */
+    encode(schema?: SchemaItem[]): string;
+    /**
+     * Set a schema field value.
+     * @param key
+     * @param value
+     */
+    setValue(key: string, value: SchemaValue): void;
+    /**
+     * Tests if the current schema is a JSON Schema.
+     *
+     * @returns boolean
+     */
+    isJsonSchema(): boolean;
+    private assertField;
+    /**
+     * Asserts if schema is valid.
+     * > Does not check references if `strict = false`. To check references use `Schema.validate()`
+     * @param args
+     */
+    protected assert(args: SchemaInterface, strict?: boolean): void;
+    /**
+     * Attest off chain data
+     * @returns
+     */
+    attestOffchain({ data, signer, to, refUID }: AttestArgs): Promise<import("@ethereum-attestation-service/eas-sdk").SignedOffchainAttestation>;
+    /**
+     * Revokes one off chain attestation by its UID.
+     * @param uid
+     * @param signer
+     * @returns
+     */
+    revokeOffchain(uid: Hex, signer: SignerOrProvider): Promise<import("@ethereum-attestation-service/eas-sdk/dist/transaction").Transaction<bigint>>;
+    /**
+     * Revokes multiple off chain attestations by their UIDs.
+     * @param uids
+     * @param signer
+     * @returns
+     */
+    multiRevokeOffchain(uids: Hex[], signer: SignerOrProvider): Promise<import("@ethereum-attestation-service/eas-sdk/dist/transaction").Transaction<bigint[]>>;
+    /**
+     * Validates and attests a given schema.
+     *
+     * This function checks a schema against predefined standards or rules. If the 'ipfsKey' parameter is enabled,
+     * it uploads the data to the IPFS (InterPlanetary File System). Upon successful upload, the function
+     * returns the CID (Content Identifier) within the Attestation Body, providing a reference to the data on IPFS.
+     *
+     * Usage:
+     * - Ensure that the schema to be attested conforms to the required format.
+     * - Enable 'ipfsKey' if you wish to store the data on IPFS and retrieve its CID.
+     *
+     * @param {Object} param0 - An object containing the schema and other optional settings.
+     * @returns {Object} An object containing the attestation results, including the CID if 'ipfsKey' is enabled.
+     */
+    attest<T>({ data, to, signer, refUID, callback, }: AttestArgs<T>): Promise<AttestationWithTx>;
+    /**
+     * Bulk attest a set of attestations.
+     * @param signer
+     * @param entities
+     * @returns
+     */
+    multiAttest(signer: SignerOrProvider, entities?: Attestation[], callback?: Function): Promise<AttestationWithTx>;
+    /**
+     * Revokes a set of attestations by their UIDs.
+     * @param signer
+     * @param uids
+     * @returns
+     */
+    multiRevoke(signer: SignerOrProvider, toRevoke: MultiRevokeArgs[], callback?: Function): Promise<{
+        tx: ethers.Transaction[];
+        uids: `0x${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.
+     *
+     * __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<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[], 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(network: TNetwork): true;
+    /**
+     * Replaces the schema list with a new list.
+     * @param schemas
+     */
+    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, network: TNetwork): void;
+    /**
+     * 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: string): SchemaItem[];
+    /**
+     * 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(): string;
+    get schema(): SchemaItem[];
+    /**
+     * 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(): Schema<string>[];
+    /**
+     * Asserts and sets the schema value.
+     */
+    set schema(schema: SchemaItem[]);
+}