@show-karma/karma-gap-sdk 0.1.29

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 {
+    static get eas() {
+        return this._eas;
+    }
+}
+exports.Facade = Facade;

package/core/utils/gelato/index.d.ts

@@ -0,0 +1,3 @@
+export * from './send-gelato-txn';
+export * from './sponsor-handler';
+export * from './watch-gelato-txn';

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,54 @@
+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.
+     * @returns Txn id
+     */
+    wait: () => 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,99 @@
+"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.
+         * @returns Txn id
+         */
+        wait: () => (0, watch_gelato_txn_1.watchGelatoTxn)(relayResponse.taskId),
+    };
+}
+/**
+ * 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): Promise<string>;
+export { watchGelatoTxn };

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

@@ -0,0 +1,55 @@
+"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) {
+    const client = new relay_sdk_1.GelatoRelay();
+    return new Promise((resolve, reject) => {
+        const loop = async () => {
+            const oneSecond = 1;
+            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, 500));
+            }
+        };
+        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/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
+        }
+    }`,
+};

package/core/utils/index.d.ts

@@ -0,0 +1,6 @@
+export * from './gelato';
+export * from './get-date';
+export * from './gql-queries';
+export * from './map-filter';
+export * from './serialize-bigint';
+export * from './to-unix';

package/core/utils/index.js

@@ -0,0 +1,22 @@
+"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("./gelato"), exports);
+__exportStar(require("./get-date"), exports);
+__exportStar(require("./gql-queries"), exports);
+__exportStar(require("./map-filter"), exports);
+__exportStar(require("./serialize-bigint"), exports);
+__exportStar(require("./to-unix"), exports);

package/core/utils/map-filter.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Filters an array by its condition then maps it to the desired format.
+ * @param arr
+ * @param condition
+ * @param mapTo
+ * @returns
+ */
+export declare function mapFilter<T = unknown, U = unknown>(arr: U[], condition: (item: U) => boolean, mapTo: (item: U) => T): T[];

package/core/utils/map-filter.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapFilter = void 0;
+/**
+ * Filters an array by its condition then maps it to the desired format.
+ * @param arr
+ * @param condition
+ * @param mapTo
+ * @returns
+ */
+function mapFilter(arr, condition, mapTo) {
+    const newArray = [];
+    for (const item of arr) {
+        if (condition(item)) {
+            newArray.push(mapTo(item));
+        }
+    }
+    return newArray;
+}
+exports.mapFilter = mapFilter;

package/core/utils/serialize-bigint.d.ts

@@ -0,0 +1 @@
+export declare function serializeWithBigint(value: unknown): string;

package/core/utils/serialize-bigint.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeWithBigint = void 0;
+function serializeWithBigint(value) {
+    return JSON.stringify(value, (this,
+        (key, value) => (typeof value === "bigint" ? value.toString() : value)));
+}
+exports.serializeWithBigint = serializeWithBigint;

package/core/utils/to-unix.d.ts

@@ -0,0 +1 @@
+export declare function toUnix(value: number | Date | string): number;

package/core/utils/to-unix.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toUnix = void 0;
+function toUnix(value) {
+    switch (typeof value) {
+        case "number":
+            value = Math.round(value);
+            if (value.toString().length > 13)
+                throw new Error("Invalid timestamp length");
+            if (value.toString().length === 10)
+                return value;
+            return Math.floor(value / 1000);
+        case "string":
+            if (/\D/.test(value))
+                return null;
+            return toUnix(+value);
+        case "object":
+            if (value instanceof Date)
+                return toUnix(value.getTime());
+            return null;
+        default:
+            return null;
+    }
+}
+exports.toUnix = toUnix;

package/index.d.ts

@@ -0,0 +1 @@
+export * from "./core";

package/index.js

@@ -0,0 +1,17 @@
+"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("./core"), exports);

package/package.json

@@ -0,0 +1,37 @@
+{
+    "name": "@show-karma/karma-gap-sdk",
+    "publishConfig": {
+        "access": "public"
+    },
+    "version": "0.1.29",
+    "description": "Simple and easy interface between EAS and Karma GAP.",
+    "main": "dist/index.js",
+    "author": "KarmaHQ",
+    "license": "MIT",
+    "private": false,
+    "repository": {
+        "url": "https://github.com/show-karma/karma-gap-sdk",
+        "type": "git"
+    },
+    "scripts": {
+        "deploy": "npx ts-node ./core/scripts/deploy.ts",
+        "csv-upload": "npx ts-node ./csv-upload/scripts/run.ts"
+    },
+    "dependencies": {
+        "@ethereum-attestation-service/eas-sdk": "^1.1.0-beta.2",
+        "@gelatonetwork/relay-sdk": "^5.2.0",
+        "@types/sha256": "^0.2.0",
+        "axios": "^1.4.0",
+        "ethers": "5.7",
+        "sha256": "^0.2.0",
+        "simple-ts-job-runner": "^1.0.12"
+    },
+    "devDependencies": {
+        "@types/node": "^20.5.0",
+        "eslint": "^8.47.0",
+        "fast-csv": "^4.3.6",
+        "husky": "^8.0.3",
+        "prettier": "^3.0.1",
+        "typescript": "^5.1.6"
+    }
+}