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

package/core/class/GapSchema.ts

@@ -0,0 +1,93 @@
+import { mapFilter } from '../utils';
+import { IGapSchema, SchemaInterface, TNetwork, TSchemaName } from '../types';
+import { Schema } from './Schema';
+import { GAP } from './GAP';
+import { MountEntities, Networks } from 'core/consts';
+
+/**
+ * Represents the GapSchema
+ * @extends Schema
+ */
+export class GapSchema extends Schema implements IGapSchema {
+  public readonly name: TSchemaName;
+  public readonly references: TSchemaName;
+  
+  constructor(
+    args: SchemaInterface<TSchemaName>,
+    gap: GAP,
+    strict = false,
+    ignoreSchema = false
+  ) {
+    super(args, gap, strict, ignoreSchema);
+
+    if (!ignoreSchema)
+      Schema.add(
+        gap.network,
+        new GapSchema(
+          {
+            name: args.name,
+            schema: args.schema.map((s) => ({ ...s })),
+            uid: args.uid,
+            references: args.references,
+            revocable: args.revocable,
+            oldSchemas: args.oldSchemas,
+          },
+          gap,
+          strict,
+          true
+        )
+      );
+  }
+
+  /**
+   * Clones a schema without references to the original.
+   * @param schema
+   * @returns
+   */
+  static clone(schema: GapSchema) {
+    return new GapSchema(
+      {
+        name: schema.name,
+        schema: schema.schema.map((s) => ({ ...s })),
+        uid: schema.uid,
+        references: schema.references,
+        revocable: schema.revocable,
+      },
+      schema.gap,
+      false,
+      true
+    );
+  }
+
+  /**
+   * Returns a copy of the original schema with no pointers.
+   * @param name
+   * @returns
+   */
+  static find(name: TSchemaName, network: TNetwork): GapSchema {
+    const found = Schema.get<TSchemaName, GapSchema>(name, network);
+    return this.clone(found);
+  }
+
+  /**
+   * Find many schemas by name and return their copies as an array in the same order.
+   * @param names
+   * @returns
+   */
+  static findMany(names: TSchemaName[], network: TNetwork): GapSchema[] {
+    const schemas = Schema.getMany<TSchemaName, GapSchema>(names, network);
+    return schemas.map((s) => this.clone(s));
+  }
+
+  /**
+   * Get all schemas that references this schema.
+   */
+  get children() {
+    return mapFilter(
+      GapSchema.schemas[this.gap.network],
+      (s) => s.references === this.name || s.references === this.uid,
+      (s: Schema<TSchemaName>) => new GapSchema(s, s.gap, false, true)
+    );
+  }
+
+}

package/core/class/Gelato/{Gelato.js → Gelato.ts}

@@ -5,11 +5,13 @@
 // /* eslint-disable class-methods-use-this */
 // /* eslint-disable no-useless-constructor */
 // /* eslint-disable import/no-extraneous-dependencies */
+
 // import { GelatoRelay } from "@gelatonetwork/relay-sdk";
 // import { ethers } from "ethers";
 // import axios from "axios";
 // import ABI from "./";
 // import { Hex } from "core/types";
+
 // enum TaskState {
 //   CheckPending = "CheckPending",
 //   ExecPending = "ExecPending",
@@ -20,12 +22,15 @@
 //   Cancelled = "Cancelled",
 //   NotFound = "NotFound",
 // }
+
 // export class DelegateRegistryContract extends GelatoRelay {
 //   contract: ethers.Contract;
+
 //   constructor(readonly contractAddress: Hex) {
 //     super();
 //     this.contract = new ethers.Contract(contractAddress, ABI);
 //   }
+
 //   /**
 //    * Returns the r, s, v values of a signature
 //    * @param signature
@@ -37,6 +42,7 @@
 //     const v = `0x${signature.slice(130, 132)}`;
 //     return { r, s, v };
 //   }
+
 //   /**
 //    * Returns the nonce of a delegate
 //    * @param address
@@ -50,11 +56,13 @@
 //       args: [address],
 //       chainId: 10,
 //     });
+
 //     return {
 //       nonce: Number(nonce),
 //       next: Number(nonce + 1n),
 //     };
 //   }
+
 //   /**
 //    * Waits for a transaction to be mined at Gelato Network
 //    * @param taskId
@@ -92,12 +100,14 @@
 //             );
 //             break;
 //           }
+
 //           await new Promise((r) => setTimeout(r, 500));
 //         }
 //       };
 //       loop();
 //     });
 //   }
+
 //   /**
 //    * Executes a transaction on the DelegateRegistry contract
 //    * @param fn the function to call
@@ -117,6 +127,7 @@
 //       wait: () => waitForTransaction({ hash }),
 //     };
 //   }
+
 //   public async registerDelegate(data: DelegateWithProfile) {
 //     return this.transaction("registerDelegate", [
 //       data.tokenAddress,
@@ -124,6 +135,7 @@
 //       JSON.stringify(data.profile),
 //     ]);
 //   }
+
 //   /**
 //    * Creates the payload for register delegate by signature
 //    * returning the payload
@@ -137,7 +149,9 @@
 //     const { nonce } = await this.getNonce(address);
 //     // 2 minutes expiry
 //     const expiry = ((Date.now() + 1000 * 120) / 1000).toFixed(0);
+
 //     const metadata = JSON.stringify(data.profile);
+
 //     const types = {
 //       RegisterDelegate: [
 //         { name: "tokenAddress", type: "address" },
@@ -164,7 +178,9 @@
 //       primaryType: "RegisterDelegate",
 //       types,
 //     });
+
 //     const { r, s, v } = this.getRSV(signature);
+
 //     const { data: payload } =
 //       await this.contract.populateTransaction.registerDelegateBySig(
 //         address,
@@ -177,6 +193,7 @@
 //         r,
 //         s
 //       );
+
 //     // eslint-disable-next-line no-console
 //     console.log({ payload, signature, r, s, v });
 //     if (!payload) throw new Error("Payload is undefined");
@@ -192,6 +209,7 @@
 //       },
 //     ];
 //   }
+
 //   /**
 //    * Sends a sponsored call to the DelegateRegistry contract using GelatoRelay
 //    * @param payload
@@ -200,11 +218,13 @@
 //   static async sendGelato(...params: Parameters<GelatoRelay["sponsoredCall"]>) {
 //     const client = new this(params[0].target as Hex);
 //     const relayResponse = await client.sponsoredCall(...params);
+
 //     return {
 //       taskId: relayResponse.taskId,
 //       wait: () => client.wait(relayResponse.taskId),
 //     };
 //   }
+
 //   /**
 //    * Deregisters a delegate on the DelegateRegistry contract
 //    * @param tokenAddress
@@ -214,6 +234,7 @@
 //   public deregisterDelegate(tokenAddress: string, tokenChainId: number) {
 //     return this.transaction("deregisterDelegate", [tokenAddress, tokenChainId]);
 //   }
+
 //   /**
 //    * Returns a delegate from the DelegateRegistry contract
 //    * @param delegateAddress
@@ -244,6 +265,7 @@
 //           interests
 //         }
 //       }`;
+
 //     const {
 //       data: {
 //         data: { delegates },
@@ -251,6 +273,7 @@
 //     } = await axios.post<{ data: DelegateStatementRes }>(this.subgraphUrl, {
 //       query,
 //     });
+
 //     return delegates.map((item) => {
 //       if (Array.isArray(item?.interests))
 //         return item as DelegateRegistryWithInterests;

package/core/class/GrantProgramRegistry/Allo.ts

@@ -0,0 +1,188 @@
+import { ethers, formatEther } from "ethers";
+import AlloContractABI from "../../abi/Allo.json";
+import { AlloContracts } from "../../consts";
+import { Address } from "../types/allo";
+import { AbiCoder } from "ethers";
+import { Allo } from "@allo-team/allo-v2-sdk/";
+import { CreatePoolArgs } from "@allo-team/allo-v2-sdk/dist/Allo/types";
+import { TransactionData } from "@allo-team/allo-v2-sdk/dist/Common/types";
+import axios from "axios";
+
+// ABI fragment for the Initialized event
+const INITIALIZED_EVENT = ["event Initialized(uint256 poolId, bytes data)"];
+
+export class AlloBase {
+  private signer: ethers.Signer;
+  private contract: ethers.Contract;
+  private allo: Allo;
+  private pinataJWTToken: string;
+
+  constructor(signer: ethers.Signer, pinataJWTToken: string, chainId: number) {
+    this.signer = signer;
+    this.contract = new ethers.Contract(
+      AlloContracts.alloProxy,
+      AlloContractABI,
+      signer
+    );
+    this.allo = new Allo({ chain: chainId });
+    this.pinataJWTToken = pinataJWTToken;
+  }
+
+  async saveAndGetCID(
+    data: any,
+    pinataMetadata = { name: "via karma-gap-sdk" }
+  ) {
+    try {
+      const res = await axios.post(
+        "https://api.pinata.cloud/pinning/pinJSONToIPFS",
+        {
+          pinataContent: data,
+          pinataMetadata: pinataMetadata,
+        },
+        {
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.pinataJWTToken}`,
+          },
+        }
+      );
+      return res.data.IpfsHash;
+    } catch (error) {
+      console.log(error);
+    }
+  }
+
+  async encodeStrategyInitData(
+    applicationStart: number,
+    applicationEnd: number,
+    roundStart: number,
+    roundEnd: number,
+    payoutToken: string
+  ) {
+    const encoder = new AbiCoder();
+    const initStrategyData = encoder.encode(
+      ["bool", "bool", "uint256", "uint256", "uint256", "uint256", "address[]"],
+      [
+        false, // useRegistryAnchor
+        true, // metadataRequired
+        applicationStart, // Eg. Curr + 1 hour later   registrationStartTime
+        applicationEnd, // Eg. Curr +  5 days later   registrationEndTime
+        roundStart, // Eg. Curr + 2 hours later  allocationStartTime
+        roundEnd, // Eg. Curr + 10 days later  allocaitonEndTime
+        [payoutToken],
+      ]
+    );
+
+    return initStrategyData;
+  }
+
+  async createGrant(args: any, callback?: Function) {
+    console.log("Creating grant...");
+    const walletBalance = await this.signer.provider.getBalance(
+      await this.signer.getAddress()
+    );
+
+    console.log(
+      "Wallet balance:",
+      formatEther(walletBalance.toString()),
+      " ETH"
+    );
+
+    try {
+      const metadata_cid = await this.saveAndGetCID({
+        round: args.roundMetadata,
+        application: args.applicationMetadata,
+      });
+
+      const metadata = {
+        protocol: BigInt(1),
+        pointer: metadata_cid,
+      };
+
+      const initStrategyData = (await this.encodeStrategyInitData(
+        args.applicationStart,
+        args.applicationEnd,
+        args.roundStart,
+        args.roundEnd,
+        args.payoutToken
+      )) as Address;
+
+      const createPoolArgs: CreatePoolArgs = {
+        profileId: args.profileId,
+        strategy: args.strategy,
+        initStrategyData: initStrategyData, // unique to the strategy
+        token: args.payoutToken,
+        amount: BigInt(args.matchingFundAmt),
+        metadata: metadata,
+        managers: args.managers,
+      };
+
+      callback?.("preparing");
+      const txData: TransactionData = this.allo.createPool(createPoolArgs);
+
+      const tx = await this.signer.sendTransaction({
+        data: txData.data,
+        to: txData.to,
+        value: BigInt(txData.value),
+      });
+      callback?.("pending");
+      const receipt = await tx.wait();
+      callback?.("confirmed");
+
+      // Create interface to parse the logs
+      const iface = new ethers.Interface(INITIALIZED_EVENT);
+      let poolId;
+
+      // Find the Initialized event in the logs
+      const initializedLog = receipt.logs.find((log) => {
+        try {
+          const parsed = iface.parseLog(log);
+          return parsed.name === "Initialized";
+        } catch {
+          return false;
+        }
+      });
+
+      if (initializedLog) {
+        const parsedLog = iface.parseLog(initializedLog);
+        poolId = parsedLog.args.poolId.toString();
+        console.log(`Transaction ${tx.hash} - Found poolId: ${poolId}`);
+      } else {
+        poolId = receipt.logs[receipt.logs.length - 1].topics[1]; // Fallback to Initialized order logic
+        console.log(`No Initialized event found in tx ${tx.hash}`);
+      }
+
+      return {
+        poolId: BigInt(poolId).toString(),
+        txHash: tx.hash,
+      };
+    } catch (error) {
+      console.error(`Failed to create pool: ${error}`);
+      throw new Error(`Failed to create pool metadata: ${error}`);
+    }
+  }
+
+  async updatePoolMetadata(
+    poolId: string,
+    poolMetadata: any,
+    callback?: Function
+  ) {
+    try {
+      callback?.("preparing");
+      const metadata_cid = await this.saveAndGetCID(poolMetadata);
+      const metadata = {
+        protocol: 1,
+        pointer: metadata_cid,
+      };
+
+      const tx = await this.contract.updatePoolMetadata(poolId, metadata);
+      callback?.("pending");
+      const receipt = await tx.wait();
+      callback?.("confirmed");
+      return receipt;
+    } catch (error) {
+      console.error(`Failed to update pool metadata: ${error}`);
+      throw new Error(`Failed to update pool metadata: ${error}`);
+    }
+  }
+}

package/core/class/GrantProgramRegistry/AlloRegistry.ts

@@ -0,0 +1,101 @@
+import { ethers } from "ethers";
+import AlloRegistryABI from "../../abi/AlloRegistry.json";
+import { AlloContracts } from "../../consts";
+import { ProfileMetadata } from "../types/allo";
+import axios from "axios";
+
+export class AlloRegistry {
+  private contract: ethers.Contract;
+  private pinataJWTToken: string;
+
+  constructor(signer: ethers.Signer, pinataJWTToken: string) {
+    this.contract = new ethers.Contract(
+      AlloContracts.registry,
+      AlloRegistryABI,
+      signer
+    );
+
+    this.pinataJWTToken = pinataJWTToken;
+  }
+
+  async saveAndGetCID(
+    data: any,
+    pinataMetadata = { name: "via karma-gap-sdk" }
+  ) {
+    try {
+      const res = await axios.post(
+        "https://api.pinata.cloud/pinning/pinJSONToIPFS",
+        {
+          pinataContent: data,
+          pinataMetadata: pinataMetadata,
+        },
+        {
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.pinataJWTToken}`,
+          },
+        }
+      );
+      return res.data.IpfsHash;
+    } catch (error) {
+      console.log(error);
+    }
+  }
+
+  async createProgram(
+    nonce: number,
+    name: string,
+    profileMetadata: ProfileMetadata,
+    owner: string,
+    members: string[]
+  ) {
+    console.log("Creating program...");
+    try {
+      const metadata_cid = await this.saveAndGetCID(profileMetadata);
+      const metadata = {
+        protocol: 1,
+        pointer: metadata_cid,
+      };
+
+      const tx = await this.contract.createProfile(
+        nonce,
+        name,
+        metadata,
+        owner,
+        members
+      );
+      const receipt = await tx.wait();
+
+      // Get ProfileCreated event
+      const profileCreatedEvent = receipt.logs.find(
+        (event) => event.eventName === "ProfileCreated"
+      );
+
+      return {
+        profileId: profileCreatedEvent.args[0],
+        txHash: receipt.hash,
+      };
+    } catch (error) {
+      console.error(`Failed to register program: ${error}`);
+    }
+  }
+
+  async updateProgramMetadata(
+    profileId: string,
+    profileMetadata: ProfileMetadata
+  ) {
+    try {
+      const metadata_cid = await this.saveAndGetCID(profileMetadata);
+      const metadata = {
+        protocol: 1,
+        pointer: metadata_cid,
+      };
+
+      const tx = await this.contract.updateProfileMetadata(profileId, metadata);
+      const receipt = await tx.wait();
+      return receipt;
+    } catch (error) {
+      console.error(`Failed to update profile metadata: ${error}`);
+    }
+  }
+}

package/core/class/GraphQL/AxiosGQL.ts

@@ -0,0 +1,29 @@
+import type { AxiosInstance } from "axios";
+import axios from "axios";
+
+export abstract class AxiosGQL {
+  protected client: AxiosInstance;
+
+  constructor(url: string) {
+    this.client = axios.create({
+      baseURL: url,
+      headers: {
+        "Content-Type": "application/json",
+      },
+    });
+  }
+
+  protected async query<R = unknown, T = unknown>(
+    query: string,
+    variables?: T
+  ): Promise<R> {
+    const {
+      data: { data },
+    } = await this.client.post<{ data: R }>("", {
+      query,
+      variables,
+    });
+
+    return data;
+  }
+}

package/core/class/GraphQL/EASClient.ts

@@ -0,0 +1,34 @@
+import { Networks } from "../../consts";
+import { EASNetworkConfig, Hex, TNetwork } from "../../types";
+import { AxiosGQL } from "./AxiosGQL";
+
+interface EASClientProps {
+  network: TNetwork;
+}
+
+export class EASClient extends AxiosGQL implements EASClientProps {
+  private readonly _network: EASNetworkConfig & { name: TNetwork };
+
+  constructor(args: EASClientProps) {
+    const { network } = args;
+    super(Networks[network].url);
+
+    this.assert(args);
+
+    this._network = { ...Networks[network], name: network };
+  }
+
+  /**
+   * Validate the constructor arguments
+   * @param args
+   */
+  private assert(args: EASClientProps) {
+    if (!Networks[args.network]) {
+      throw new Error("Invalid network");
+    }
+  }
+
+  get network(): TNetwork {
+    return this._network.name;
+  }
+}