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

package/core/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./consts"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./class/GAP"), exports);
+__exportStar(require("./class/GapSchema"), exports);
+__exportStar(require("./class/types/attestations"), exports);
+__exportStar(require("./class/entities"), exports);
+__exportStar(require("./abi"), exports);

package/core/shared/types.d.ts

@@ -0,0 +1,13 @@
+export interface IGrantUpdateBase {
+    title: string;
+    text: string;
+    proofOfWork?: string;
+    completionPercentage?: string;
+    pitchDeck?: string;
+    demoVideo?: string;
+    trackExplanations?: Array<{
+        trackId: string;
+        trackName: string;
+        explanation: string;
+    }>;
+}

package/core/shared/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/core/types.d.ts

@@ -0,0 +1,131 @@
+import { BytesLike } from "ethers";
+import { AttestationRequestData, EAS, MultiAttestationRequest, SchemaItem } from "@ethereum-attestation-service/eas-sdk";
+import { Attestation } from "./class";
+import { Fetcher } from "./class/Fetcher";
+export type Hex = `0x${string}`;
+export type SignerOrProvider = any;
+export interface SchemaInterface<T extends string = string> {
+    name: string;
+    schema: SchemaItem[];
+    references?: T;
+    uid: Hex;
+    revocable?: boolean;
+    oldSchemas?: {
+        uid: string;
+        raw: SchemaItem[];
+    }[];
+}
+export interface MultiRevokeArgs {
+    uid: Hex;
+    schemaId: Hex;
+}
+export type CallbackStatus = "pending" | "confirmed" | "preparing";
+export interface AttestArgs<T = unknown> {
+    to: Hex;
+    data: T;
+    refUID?: Hex;
+    signer: SignerOrProvider;
+    callback?: (status: CallbackStatus) => void;
+}
+export type TSchemaName = "Community" | "CommunityDetails" | "Grant" | "GrantDetails" | "GrantVerified" | "MemberOf" | "MemberDetails" | "Milestone" | "MilestoneCompleted" | "MilestoneApproved" | "Project" | "ProjectDetails" | "Details" | "ProjectImpact" | "ProjectUpdate" | "ProjectUpdateStatus" | "ProjectPointer" | "GrantUpdate" | "GrantUpdateStatus" | "ProjectEndorsement" | "ProjectMilestone" | "ProjectMilestoneStatus" | "ContributorProfile";
+export type TResolvedSchemaNames = "Community" | "Grant" | "GrantVerified" | "MemberOf" | "MilestoneCompleted" | "MilestoneApproved" | "Project" | "Details" | "ProjectUpdateStatus" | "GrantUpdateStatus" | "ProjectUpdateStatus" | "ProjectMilestoneStatus" | "ContributorProfile";
+export type TExternalLink = "twitter" | "github" | "website" | "linkedin" | "discord" | "pitchDeck" | "demoVideo" | "farcaster" | "custom";
+export type TNetwork = "optimism" | "celo" | "optimism-sepolia" | "arbitrum" | "sepolia" | "sei" | "sei-testnet" | "base-sepolia" | "lisk" | "scroll" | "base" | "polygon";
+/**
+ * Generic GAP Facade interface.
+ * This supplies the GAP class with the necessary properties.
+ */
+export declare abstract class Facade {
+    abstract readonly network: TNetwork;
+    abstract readonly schemas: SchemaInterface[];
+    abstract readonly fetch: Fetcher;
+    protected _eas: EAS;
+    get eas(): EAS;
+}
+export interface RawAttestationPayload {
+    schema: Hex;
+    data: {
+        payload: AttestationRequestData;
+        raw: AttestationRequestData;
+    };
+}
+export interface RawMultiAttestPayload {
+    payload: MultiAttestData;
+    raw: MultiAttestData;
+}
+export interface MultiAttestData {
+    uid?: Hex;
+    multiRequest: MultiAttestationRequest;
+    refIdx: number;
+}
+export type MultiAttestPayload = [Attestation, RawMultiAttestPayload][];
+export interface EASNetworkConfig {
+    url: string;
+    rpcUrl: string;
+    chainId: number;
+    contracts: {
+        eas: Hex;
+        schema: Hex;
+        multicall: Hex;
+        projectResolver: Hex;
+        communityResolver: Hex;
+        donations: Hex;
+        airdropNFT: Hex;
+    };
+    /**
+     * A tuple containing the schema name and it's UID for that network
+     */
+    schemas: Record<TResolvedSchemaNames, Hex>;
+    oldSchemas?: {
+        name: string;
+        uid: string;
+        raw: SchemaItem[];
+    }[];
+}
+export type IGapSchema = SchemaInterface<TSchemaName>;
+export type JSONStr = string;
+export interface Schemata {
+    uid: Hex;
+    schema: string;
+}
+export interface SchemataRes {
+    schemata: Schemata[];
+}
+export interface IAttestation {
+    uid: Hex;
+    attester: Hex;
+    data: BytesLike;
+    decodedDataJson: JSONStr;
+    recipient: Hex;
+    revoked: boolean;
+    createdAt: number;
+    refUID?: Hex;
+    isOffchain: boolean;
+    revocable: boolean;
+    revocationTime?: number;
+    schemaId: Hex;
+}
+export interface AttestationRes {
+    attestation: IAttestation;
+}
+export interface AttestationsRes {
+    attestations: IAttestation[];
+}
+export interface SchemaRes {
+    schema: {
+        attestations: IAttestation[];
+    };
+}
+/**
+ * Valid remote storage types
+ */
+export declare const enum STORAGE_TYPE {
+    IPFS = 0,
+    ARWEAVE = 1,
+    SWARM = 2,
+    UNKNOWN = 3
+}
+export type TRemoteStorageOutput<T = unknown> = {
+    hash: T;
+    storageType: number;
+};

package/core/types.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Facade = void 0;
+/**
+ * Generic GAP Facade interface.
+ * This supplies the GAP class with the necessary properties.
+ */
+class Facade {
+    get eas() {
+        return this._eas;
+    }
+}
+exports.Facade = Facade;

package/core/utils/gelato/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./send-gelato-txn"), exports);
+__exportStar(require("./sponsor-handler"), exports);
+__exportStar(require("./watch-gelato-txn"), exports);

package/core/utils/gelato/send-gelato-txn.d.ts

@@ -0,0 +1,55 @@
+import { GelatoRelay } from '@gelatonetwork/relay-sdk';
+import { Hex } from '../../types';
+declare function sendByUrl(...params: Parameters<GelatoRelay['sponsoredCall']>): Promise<string>;
+/**
+ * Send gelato using an explicit api key.
+ *
+ * > __This is not safe in the frontend.__
+ *
+ * @param params
+ * @returns Gelato's task id and a wait function.
+ */
+declare function sendByApiKey(...params: Parameters<GelatoRelay['sponsoredCall']>): Promise<{
+    taskId: string;
+    /**
+     * Waits for the transaction to be confirmed by Gelato.
+     * @param ttl interval between checks in ms
+     * @returns Txn id
+     */
+    wait: (ttl?: number) => Promise<string>;
+}>;
+/**
+ * Sends a sponsored call using GelatoRelay
+ * @param payload
+ * @returns txn hash
+ */
+declare function sendGelatoTxn(...params: Parameters<GelatoRelay['sponsoredCall']>): Promise<string>;
+/**
+ * Builds the arguments for a sponsored call using GelatoRelay
+ * @param data Populated contract call.
+ * @param chainId
+ * @param target target contract address (Hex)
+ *
+ * @example
+ *
+ * ```ts
+ * const { data } = await contract.populateTransaction.transfer(
+ *  recipient,
+ *  amount
+ * );
+ * const args = buildArgs(data, chainId, target);
+ * const txn = sendGelatoTxn(...args);
+ * console.log(txn) // 0xabc..
+ * ```
+ */
+declare function buildArgs(
+/**
+ * Populated transaction data.
+ */
+data: string, chainId: bigint, target: Hex): Parameters<GelatoRelay['sponsoredCall']>;
+declare const Gelato: {
+    sendByApiKey: typeof sendByApiKey;
+    sendByUrl: typeof sendByUrl;
+    buildArgs: typeof buildArgs;
+};
+export { sendGelatoTxn, Gelato };

package/core/utils/gelato/send-gelato-txn.js

@@ -0,0 +1,100 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Gelato = exports.sendGelatoTxn = void 0;
+const axios_1 = __importDefault(require("axios"));
+const relay_sdk_1 = require("@gelatonetwork/relay-sdk");
+const watch_gelato_txn_1 = require("./watch-gelato-txn");
+const GAP_1 = require("../../class/GAP");
+async function sendByUrl(...params) {
+    const { data } = await axios_1.default.post(GAP_1.GAP.gelatoOpts.sponsorUrl, params);
+    return data;
+}
+/**
+ * Send gelato using an explicit api key.
+ *
+ * > __This is not safe in the frontend.__
+ *
+ * @param params
+ * @returns Gelato's task id and a wait function.
+ */
+async function sendByApiKey(...params) {
+    const { apiKey } = GAP_1.GAP?.gelatoOpts || {};
+    if (!apiKey && params[1] === '{apiKey}')
+        throw new Error('No api key provided.');
+    if (apiKey && params[1] === '{apiKey}')
+        params[1] = apiKey;
+    const client = new relay_sdk_1.GelatoRelay();
+    const relayResponse = await client.sponsoredCall(...params);
+    return {
+        taskId: relayResponse.taskId,
+        /**
+         * Waits for the transaction to be confirmed by Gelato.
+         * @param ttl interval between checks in ms
+         * @returns Txn id
+         */
+        wait: (ttl) => (0, watch_gelato_txn_1.watchGelatoTxn)(relayResponse.taskId, ttl),
+    };
+}
+/**
+ * Sends a sponsored call using GelatoRelay
+ * @param payload
+ * @returns txn hash
+ */
+async function sendGelatoTxn(...params) {
+    if (!GAP_1.GAP.gelatoOpts)
+        throw new Error('Gelato opts not set.');
+    const { env_gelatoApiKey, sponsorUrl, useGasless, contained } = GAP_1.GAP.gelatoOpts;
+    if (!useGasless)
+        throw new Error('Gasless is not enabled.');
+    if ((sponsorUrl && contained && env_gelatoApiKey) ||
+        (sponsorUrl && !contained)) {
+        return sendByUrl(...params);
+    }
+    const { wait } = await sendByApiKey(...params);
+    return wait();
+}
+exports.sendGelatoTxn = sendGelatoTxn;
+/**
+ * Builds the arguments for a sponsored call using GelatoRelay
+ * @param data Populated contract call.
+ * @param chainId
+ * @param target target contract address (Hex)
+ *
+ * @example
+ *
+ * ```ts
+ * const { data } = await contract.populateTransaction.transfer(
+ *  recipient,
+ *  amount
+ * );
+ * const args = buildArgs(data, chainId, target);
+ * const txn = sendGelatoTxn(...args);
+ * console.log(txn) // 0xabc..
+ * ```
+ */
+function buildArgs(
+/**
+ * Populated transaction data.
+ */
+data, chainId, target) {
+    return [
+        {
+            data,
+            chainId,
+            target,
+        },
+        '{apiKey}',
+        {
+            retries: 3,
+        },
+    ];
+}
+const Gelato = {
+    sendByApiKey,
+    sendByUrl,
+    buildArgs,
+};
+exports.Gelato = Gelato;

package/core/utils/gelato/sponsor-handler.d.ts

@@ -0,0 +1,9 @@
+export interface ApiRequest {
+    method: string;
+    body: unknown;
+}
+export interface ApiResponse {
+    statusCode: number;
+    send: (body: unknown) => void;
+}
+export declare function handler(req: ApiRequest, res: ApiResponse, env_gelatoApiKey: string): Promise<void>;

package/core/utils/gelato/sponsor-handler.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = void 0;
+const send_gelato_txn_1 = require("./send-gelato-txn");
+const assertionObj = [
+    {
+        data: /0x[a-fA-F0-9]+/gim,
+        chainId: /\d+/,
+        target: /0x[a-fA-F0-9]{40}/gim,
+    },
+    /\{apiKey\}/,
+    {
+        retries: /\d+/,
+    },
+];
+function assert(body) {
+    if (!Array.isArray(body) || body.length !== assertionObj.length)
+        throw new Error("Invalid request body");
+    assertionObj.forEach((item, index) => {
+        // check if objects from assertion Object are present in body
+        // and test them using the regexp from the assertion Object
+        if (typeof item === "object") {
+            Object.entries(item).forEach(([key, value]) => {
+                if (!body[index][key]?.toString().match(value))
+                    throw new Error("Invalid request body");
+            });
+        }
+        // test other items as strings
+        else if (!body[index]?.toString().match(item))
+            throw new Error("Invalid request body");
+    });
+    return true;
+}
+async function handler(req, res, env_gelatoApiKey) {
+    if (req.method !== "POST") {
+        res.statusCode = 405;
+        res.send("Method not allowed");
+        return;
+    }
+    try {
+        const body = req.body;
+        if (!assert(body))
+            return;
+        const { [env_gelatoApiKey]: apiKey } = process.env;
+        if (!apiKey)
+            throw new Error("Api key not provided.");
+        body[1] = apiKey;
+        const result = await send_gelato_txn_1.Gelato.sendByApiKey(...body);
+        const txId = await result.wait();
+        res.send(txId);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    }
+    catch (error) {
+        // eslint-disable-next-line no-console
+        console.log(error);
+        res.statusCode = 400;
+        res.send(error.message);
+    }
+}
+exports.handler = handler;

package/core/utils/gelato/watch-gelato-txn.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Waits for a transaction to be mined at Gelato Network
+ * @param taskId
+ * @returns
+ */
+declare function watchGelatoTxn(taskId: string, ttl?: number): Promise<string>;
+export { watchGelatoTxn };

package/core/utils/gelato/watch-gelato-txn.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.watchGelatoTxn = void 0;
+const relay_sdk_1 = require("@gelatonetwork/relay-sdk");
+var TaskState;
+(function (TaskState) {
+    TaskState["CheckPending"] = "CheckPending";
+    TaskState["ExecPending"] = "ExecPending";
+    TaskState["ExecSuccess"] = "ExecSuccess";
+    TaskState["ExecReverted"] = "ExecReverted";
+    TaskState["WaitingForConfirmation"] = "WaitingForConfirmation";
+    TaskState["Blacklisted"] = "Blacklisted";
+    TaskState["Cancelled"] = "Cancelled";
+    TaskState["NotFound"] = "NotFound";
+})(TaskState || (TaskState = {}));
+/**
+ * Waits for a transaction to be mined at Gelato Network
+ * @param taskId
+ * @returns
+ */
+async function watchGelatoTxn(taskId, ttl = 500) {
+    const client = new relay_sdk_1.GelatoRelay();
+    return new Promise((resolve, reject) => {
+        const loop = async () => {
+            const oneSecond = 1;
+            try {
+                while (oneSecond) {
+                    const status = await client.getTaskStatus(taskId);
+                    // print status :D so we can debug this for now
+                    // eslint-disable-next-line no-console
+                    console.log(status);
+                    if (!status) {
+                        reject(new Error('Transaction goes wrong.'));
+                        break;
+                    }
+                    if (status && status.taskState === TaskState.ExecSuccess) {
+                        resolve(status.transactionHash || '');
+                        break;
+                    }
+                    else if ([
+                        TaskState.Cancelled,
+                        TaskState.ExecReverted,
+                        TaskState.Blacklisted,
+                    ].includes(status?.taskState)) {
+                        reject(new Error(status.lastCheckMessage
+                            ?.split(/(RegisterDelegate)|(Execution error): /)
+                            .at(-1) || ''));
+                        break;
+                    }
+                    await new Promise((r) => setTimeout(r, ttl));
+                }
+            }
+            catch {
+                // gelato may throw 429 error, so we need to retry
+                // Increase ttl to avoid too deadlocking
+                // Max ttl is 30s
+                ttl += Math.max(30000, ttl + 1000);
+            }
+        };
+        loop();
+    });
+}
+exports.watchGelatoTxn = watchGelatoTxn;

package/core/utils/get-date.d.ts

@@ -0,0 +1 @@
+export declare function getDate(date: Date | number): Date;

package/core/utils/get-date.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDate = void 0;
+function getDate(date) {
+    return typeof date === "number" ? new Date(date * 1000) : date;
+}
+exports.getDate = getDate;

package/core/utils/get-ipfs-data.d.ts

@@ -0,0 +1 @@
+export declare function getIPFSData<T>(cid: string): Promise<T>;

package/core/utils/get-ipfs-data.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIPFSData = void 0;
+const axios_1 = __importDefault(require("axios"));
+async function getIPFSData(cid) {
+    try {
+        const { data } = await axios_1.default.get(`https://ipfs.io/ipfs/${cid}`, {
+            timeout: 5000,
+        });
+        return data;
+    }
+    catch (err) {
+        console.error(err);
+        throw new Error(`Error to retrive data for CID: ${cid}`);
+    }
+}
+exports.getIPFSData = getIPFSData;

package/core/utils/get-web3-provider.d.ts

@@ -0,0 +1,2 @@
+import { ethers } from "ethers";
+export declare const getWeb3Provider: (chainId: number) => ethers.JsonRpcProvider;

package/core/utils/get-web3-provider.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWeb3Provider = void 0;
+const consts_1 = require("../consts");
+const ethers_1 = require("ethers");
+const providers = {};
+const getWeb3Provider = (chainId) => {
+    const rpcUrl = Object.values(consts_1.Networks).find((n) => n.chainId === chainId)
+        ?.rpcUrl;
+    if (!rpcUrl) {
+        throw new Error(`No rpcUrl found for chainId ${chainId}`);
+    }
+    if (!providers[chainId]) {
+        providers[chainId] = new ethers_1.ethers.JsonRpcProvider(rpcUrl);
+    }
+    return providers[chainId];
+};
+exports.getWeb3Provider = getWeb3Provider;

package/core/utils/gql-queries.d.ts

@@ -0,0 +1,12 @@
+import { Hex } from "../types";
+export declare const gqlQueries: {
+    attestation: (uid: Hex) => string;
+    attestations: (schemaId: Hex, uid: Hex) => string;
+    attestationsIn: (uids: Hex[], search?: string) => string;
+    attestationsFrom: (schemaId: Hex, attester: Hex) => string;
+    attestationsTo: (schemaId: Hex, recipient: Hex) => string;
+    attestationPairs: (schemaId: Hex, attester: Hex, recipient: Hex) => string;
+    attestationsOf: (schemaId: Hex, search?: string[] | string, refUids?: Hex[]) => string;
+    dependentsOf: (refs: Hex | Hex[], schemaIds: Hex[], attesters?: Hex[]) => string;
+    schemata: (creator: Hex) => string;
+};

package/core/utils/gql-queries.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gqlQueries = void 0;
+const inStatement = (values) => `[${values.map((v) => `"${v}"`).join(",")}]`;
+const attestationFields = `
+    uid: id
+    attester
+    data
+    decodedDataJson
+    recipient
+    revoked
+    createdAt: timeCreated
+    refUID
+    isOffchain
+    revocable
+    revocationTime
+    schemaId
+`;
+const schemaQuery = (schemaId, content) => `{schema(where: {id: "${schemaId}"}) {${content}}}`;
+exports.gqlQueries = {
+    attestation: (uid) => `
+    {
+      attestation(where: {
+        id: "${uid}"
+      }) {${attestationFields}}
+    }`,
+    attestations: (schemaId, uid) => schemaQuery(schemaId, `attestations(where: {
+        revoked: {equals: false}
+        decodedDataJson: {contains: "${uid}"}
+      }) {${attestationFields}}`),
+    attestationsIn: (uids, search) => `
+    {
+      attestations(where: {
+        id:{in: ${inStatement(uids)}}
+        revoked:{equals:false}
+        ${search
+        ? `decodedDataJson:{contains:"${search}",mode:insensitive}`
+        : ""}
+      }) {${attestationFields}}
+    }`,
+    attestationsFrom: (schemaId, attester) => schemaQuery(schemaId, `attestations(orderBy:{timeCreated: desc},
+        where:{attester:{equals:"${attester}"}
+        revoked:{equals:false}
+      }){${attestationFields}}`),
+    attestationsTo: (schemaId, recipient) => schemaQuery(schemaId, `attestations(orderBy:{timeCreated: desc},
+        where:{
+          recipient:{equals:"${recipient}"}
+          revoked:{equals:false}
+        }){${attestationFields}}`),
+    attestationPairs: (schemaId, attester, recipient) => schemaQuery(schemaId, `attestations(where: {
+          attester: {equals: "${attester}"}
+          recipient: {equals: "${recipient}"}
+          revoked: {equals: false}
+        }) {${attestationFields}}`),
+    attestationsOf: (schemaId, search, refUids) => schemaQuery(schemaId, `attestations(orderBy:{timeCreated: desc},
+        where: {
+          revoked:{equals:false}
+          ${refUids && refUids.length
+        ? `refUID:{in: ${inStatement(refUids)}}`
+        : ""}
+          ${search
+        ? `OR: [
+                ${[search]
+            .flat()
+            .map((s) => `{decodedDataJson:{contains:"${s}",mode:insensitive}}`)
+            .join(",")}
+              ]`
+        : ""}
+        })
+        {${attestationFields}}`),
+    dependentsOf: (refs, schemaIds, attesters = []) => `
+    {
+      attestations(
+        orderBy:{timeCreated: desc},
+        where: {
+          refUID:{in: ${inStatement([refs].flat())}}
+          revoked:{equals: false}
+          schemaId:{in: ${inStatement(schemaIds)}}
+          ${attesters.length ? `attester:{in:${inStatement(attesters)}}` : ""}
+      }){${attestationFields}}
+    }
+  `,
+    schemata: (creator) => `
+    {
+        schemata(where: {creator: {equals: "${creator}"}}) {
+            uid: id
+            schema
+        }
+    }`,
+};