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

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

@@ -0,0 +1,114 @@
+import axios from 'axios';
+import { GelatoRelay } from '@gelatonetwork/relay-sdk';
+import { watchGelatoTxn } from './watch-gelato-txn';
+import { GAP } from '../../class/GAP';
+import { Hex } from '../../types';
+
+async function sendByUrl(...params: Parameters<GelatoRelay['sponsoredCall']>) {
+  const { data } = await axios.post<string>(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: Parameters<GelatoRelay['sponsoredCall']>
+) {
+  const { apiKey } = 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 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?: number) => watchGelatoTxn(relayResponse.taskId, ttl),
+  };
+}
+
+/**
+ * Sends a sponsored call using GelatoRelay
+ * @param payload
+ * @returns txn hash
+ */
+async function sendGelatoTxn(
+  ...params: Parameters<GelatoRelay['sponsoredCall']>
+) {
+  if (!GAP.gelatoOpts) throw new Error('Gelato opts not set.');
+  const { env_gelatoApiKey, sponsorUrl, useGasless, contained } =
+    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();
+}
+
+/**
+ * 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: string,
+  chainId: bigint,
+  target: Hex
+): Parameters<GelatoRelay['sponsoredCall']> {
+  return [
+    {
+      data,
+      chainId,
+      target,
+    },
+    '{apiKey}', // filled in the api
+    {
+      retries: 3,
+    },
+  ];
+}
+
+const Gelato = {
+  sendByApiKey,
+  sendByUrl,
+  buildArgs,
+};
+
+export { sendGelatoTxn, Gelato };

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

@@ -0,0 +1,77 @@
+import { GelatoRelay } from "@gelatonetwork/relay-sdk";
+import { GAP } from "../../class/GAP";
+import { Gelato, sendGelatoTxn } from "./send-gelato-txn";
+
+export interface ApiRequest {
+  method: string;
+  body: unknown;
+}
+
+export interface ApiResponse {
+  statusCode: number;
+  send: (body: unknown) => void;
+}
+
+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: any): body is Parameters<GelatoRelay["sponsoredCall"]> {
+  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;
+}
+
+export async function handler(
+  req: ApiRequest,
+  res: ApiResponse,
+  env_gelatoApiKey: string
+) {
+  if (req.method !== "POST") {
+    res.statusCode = 405;
+    res.send("Method not allowed");
+    return;
+  }
+  try {
+    const body = req.body as unknown;
+
+    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 Gelato.sendByApiKey(...body);
+    const txId = await result.wait();
+    res.send(txId);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  } catch (error: any) {
+    // eslint-disable-next-line no-console
+    console.log(error);
+    res.statusCode = 400;
+    res.send(error.message);
+  }
+}

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

@@ -0,0 +1,67 @@
+import { GelatoRelay } from '@gelatonetwork/relay-sdk';
+
+enum TaskState {
+  CheckPending = 'CheckPending',
+  ExecPending = 'ExecPending',
+  ExecSuccess = 'ExecSuccess',
+  ExecReverted = 'ExecReverted',
+  WaitingForConfirmation = 'WaitingForConfirmation',
+  Blacklisted = 'Blacklisted',
+  Cancelled = 'Cancelled',
+  NotFound = 'NotFound',
+}
+
+/**
+ * Waits for a transaction to be mined at Gelato Network
+ * @param taskId
+ * @returns
+ */
+async function watchGelatoTxn(taskId: string, ttl = 500): Promise<string> {
+  const client = new 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();
+  });
+}
+
+export { watchGelatoTxn };

package/core/utils/get-date.ts

@@ -0,0 +1,3 @@
+export function getDate(date: Date | number) {
+  return typeof date === "number" ? new Date(date * 1000) : date;
+}

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

@@ -0,0 +1,13 @@
+import axios from 'axios';
+
+export async function getIPFSData<T>(cid: string): Promise<T> {
+  try {
+    const { data } = await axios.get(`https://ipfs.io/ipfs/${cid}`, {
+      timeout: 5000,
+    });
+    return data as T;
+  } catch (err) {
+    console.error(err);
+    throw new Error(`Error to retrive data for CID: ${cid}`);
+  }
+}

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

@@ -0,0 +1,18 @@
+import { Networks } from "../consts";
+import { ethers } from "ethers";
+
+const providers: Record<number, ethers.JsonRpcProvider> = {};
+
+export const getWeb3Provider = (chainId: number): ethers.JsonRpcProvider => {
+  const rpcUrl = Object.values(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.JsonRpcProvider(rpcUrl);
+  }
+  return providers[chainId];
+};

package/core/utils/gql-queries.ts

@@ -0,0 +1,133 @@
+import { nullRef } from "../consts";
+import { Hex } from "../types";
+
+const inStatement = (values: (string | number)[]) =>
+  `[${values.map((v) => `"${v}"`).join(",")}]`;
+
+const attestationFields = `
+    uid: id
+    attester
+    data
+    decodedDataJson
+    recipient
+    revoked
+    createdAt: timeCreated
+    refUID
+    isOffchain
+    revocable
+    revocationTime
+    schemaId
+`;
+
+const schemaQuery = (schemaId: Hex, content: string) =>
+  `{schema(where: {id: "${schemaId}"}) {${content}}}`;
+
+export const gqlQueries = {
+  attestation: (uid: Hex) => `
+    {
+      attestation(where: {
+        id: "${uid}"
+      }) {${attestationFields}}
+    }`,
+  attestations: (schemaId: Hex, uid: Hex) =>
+    schemaQuery(
+      schemaId,
+      `attestations(where: {
+        revoked: {equals: false}
+        decodedDataJson: {contains: "${uid}"}
+      }) {${attestationFields}}`
+    ),
+  attestationsIn: (uids: Hex[], search?: string) => `
+    {
+      attestations(where: {
+        id:{in: ${inStatement(uids)}}
+        revoked:{equals:false}
+        ${
+          search
+            ? `decodedDataJson:{contains:"${search}",mode:insensitive}`
+            : ""
+        }
+      }) {${attestationFields}}
+    }`,
+  attestationsFrom: (schemaId: Hex, attester: Hex) =>
+    schemaQuery(
+      schemaId,
+      `attestations(orderBy:{timeCreated: desc},
+        where:{attester:{equals:"${attester}"}
+        revoked:{equals:false}
+      }){${attestationFields}}`
+    ),
+  attestationsTo: (schemaId: Hex, recipient: Hex) =>
+    schemaQuery(
+      schemaId,
+      `attestations(orderBy:{timeCreated: desc},
+        where:{
+          recipient:{equals:"${recipient}"}
+          revoked:{equals:false}
+        }){${attestationFields}}`
+    ),
+  attestationPairs: (schemaId: Hex, attester: Hex, recipient: Hex) =>
+    schemaQuery(
+      schemaId,
+      `attestations(where: {
+          attester: {equals: "${attester}"}
+          recipient: {equals: "${recipient}"}
+          revoked: {equals: false}
+        }) {${attestationFields}}`
+    ),
+  attestationsOf: (
+    schemaId: Hex,
+    search?: string[] | string,
+    refUids?: Hex[]
+  ) =>
+    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: Hex | Hex[],
+    schemaIds: Hex[],
+    attesters: Hex[] = []
+  ) => `
+    {
+      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: Hex) => `
+    {
+        schemata(where: {creator: {equals: "${creator}"}}) {
+            uid: id
+            schema
+        }
+    }`,
+};

package/core/utils/map-filter.ts

@@ -0,0 +1,21 @@
+/**
+ * Filters an array by its condition then maps it to the desired format.
+ * @param arr
+ * @param condition
+ * @param mapTo
+ * @returns
+ */
+export function mapFilter<T = unknown, U = unknown>(
+  arr: U[],
+  condition: (item: U) => boolean,
+  mapTo: (item: U) => T
+): T[] {
+  const newArray: T[] = [];
+
+  for (const item of arr) {
+    if (condition(item)) {
+      newArray.push(mapTo(item));
+    }
+  }
+  return newArray;
+}

package/core/utils/serialize-bigint.ts

@@ -0,0 +1,7 @@
+export function serializeWithBigint(value: unknown) {
+  return JSON.stringify(
+    value,
+    (this,
+    (key, value) => (typeof value === "bigint" ? value.toString() : value))
+  );
+}

package/core/utils/to-unix.ts

@@ -0,0 +1,18 @@
+export function toUnix(value: number | Date | string) {
+  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;
+  }
+}

package/create-community-example.ts

@@ -0,0 +1,119 @@
+import { ethers } from "ethers";
+import { GAP } from "./core/class/GAP";
+import { GapIndexerClient } from "./core/class/karma-indexer/GapIndexerClient";
+import { Community } from "./core/class/entities/Community";
+import { ICommunityDetails } from "./core/class/types/attestations";
+import { Hex } from "./core/types";
+import * as dotenv from "dotenv";
+
+// Load environment variables
+dotenv.config();
+
+// Configuration
+const API_URL = process.env.API_URL || "https://gapstagapi.karmahq.xyz";
+const RPC_URL = process.env.RPC_URL || "https://sepolia.optimism.io"; // Replace with your RPC URL
+const PRIVATE_KEY = process.env.PRIVATE_KEY; // Your private key from .env file
+
+if (!PRIVATE_KEY) {
+  throw new Error("PRIVATE_KEY not found in .env file");
+}
+
+// Community data
+const COMMUNITY_DATA = {
+  name: "Polygon",
+  description: "A polygon community",
+  imageURL:
+    "https://polygontechnology.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F51562dc1-1dc5-4484-bf96-2aeac848ae2f%2Ff0ed090e-4957-4520-8b0c-56d5ec80a17f%2FPolygon_Icon_White_Purple_Rn-3.png?id=fdedfbfe-e6e1-430e-ac7c-b2fb988b47b9&table=block&spaceId=51562dc1-1dc5-4484-bf96-2aeac848ae2f&width=2000&userId=&cache=v2",
+  slug: "polygon", // Optional - will be auto-generated if not provided
+  links: [],
+  type: "community-details",
+};
+async function main() {
+  try {
+    console.log("=== Creating Community ===\n");
+
+    // Initialize provider and signer
+    const provider = new ethers.JsonRpcProvider(RPC_URL);
+    const signer = new ethers.Wallet(PRIVATE_KEY, provider);
+    const signerAddress = (await signer.getAddress()) as `0x${string}`;
+
+    console.log(`Using signer address: ${signerAddress}`);
+
+    // Initialize GAP SDK
+    const gap = new GAP({
+      globalSchemas: false,
+      network: "optimism-sepolia", // Change to your target network (e.g., "optimism", "arbitrum")
+      apiClient: new GapIndexerClient(API_URL),
+    });
+
+    console.log("GAP SDK initialized\n");
+
+    // Generate a unique slug if not provided
+    let communityDetails: ICommunityDetails = { ...COMMUNITY_DATA };
+    if (!communityDetails.slug) {
+      console.log("Generating slug...");
+      communityDetails.slug = await gap.generateSlug(communityDetails.name);
+      console.log(`Generated slug: ${communityDetails.slug}\n`);
+    }
+
+    // Create the community attestation
+    console.log("Creating community attestation...");
+    const community = new Community({
+      schema: gap.findSchema("Community"),
+      recipient: signerAddress,
+      data: {
+        community: true,
+      },
+    });
+
+    // Attest the community with its details
+    console.log("Attesting community to blockchain...\n");
+    const result = await community.attest(
+      signer,
+      communityDetails,
+      (status: string) => {
+        console.log(`Status: ${status}`);
+      }
+    );
+
+    console.log("\n✅ Community created successfully!");
+    console.log(`Community UID: ${result.uids[0]}`);
+    if (result.uids[1]) {
+      console.log(`Community Details UID: ${result.uids[1]}`);
+    }
+    console.log(`Transaction Hash: ${result.tx[0].hash}`);
+    console.log(
+      `\nYou can view your community at: https://gap.karmahq.xyz/community/${communityDetails.slug}`
+    );
+
+    // Fetch the created community to verify
+    console.log("\nVerifying community creation...");
+    const fetchedCommunity = await gap.fetch.communityBySlug(
+      communityDetails.slug
+    );
+
+    if (fetchedCommunity) {
+      console.log("✅ Community verified!");
+      console.log(`Community Name: ${fetchedCommunity.details?.name}`);
+      console.log(
+        `Community Description: ${fetchedCommunity.details?.description}`
+      );
+    } else {
+      console.log("⚠️ Community not yet indexed (this may take a few moments)");
+    }
+  } catch (error) {
+    console.error("\n❌ Error creating community:", error);
+    throw error;
+  }
+}
+
+// Run the script
+main()
+  .then(() => {
+    console.log("\n✅ Script completed successfully");
+    process.exit(0);
+  })
+  .catch((error) => {
+    console.error("\n❌ Script failed:", error);
+    process.exit(1);
+  });

package/csv-upload/README.md

@@ -0,0 +1,74 @@
+# Configuration
+
+This directory contains configuration files for the application.
+
+## Files
+
+### `config.ts`
+
+Contains non-sensitive configuration and constants:
+
+- `CHAIN_IDS`: Chain IDs for different networks
+- `DEFAULT_CONFIG`: Default configuration values
+- `API_ENDPOINTS`: API endpoint paths
+- `LINK_TYPES`: Types of links supported
+- `GRANT_UPDATE_TYPES`: Types of grant updates
+
+### `keys.json`
+
+Contains sensitive configuration (not committed to version control). Copy `keys.example.json` to `keys.json` and fill in your values.
+
+Required structure:
+```json
+{
+  "optimism": {
+    "privateKey": "your_private_key_here",
+    "rpcURL": "your_rpc_url_here",
+    "gapAPI": "your_gap_api_url_here",
+    "ipfsKey": "your_ipfs_key_here"
+  },
+  // ... other networks with same structure
+  "gapAccessToken": "your_gap_access_token_here"
+}
+```
+
+## Networks Supported
+
+- optimism
+- optimism-sepolia
+- sepolia
+- arbitrum
+- base-sepolia
+- celo
+- sei
+- sei-testnet
+- lisk
+- scroll
+
+## Setup
+
+1. Copy `keys.example.json` to `keys.json`
+2. Fill in your values in `keys.json`
+3. Never commit `keys.json` to version control
+
+## Environment Variables
+
+The following environment variables can override configuration values if present:
+
+- `GAP_NETWORK`: Override the default network
+- `GAP_API_URL`: Override the GAP API URL
+- `MAINNET_RPC_URL`: Override the mainnet RPC URL
+
+## Usage
+
+Import configuration values from `config.ts`:
+
+```typescript
+import { 
+  CHAIN_IDS, 
+  DEFAULT_CONFIG, 
+  API_ENDPOINTS,
+  LINK_TYPES,
+  GRANT_UPDATE_TYPES 
+} from "./config/config";
+```