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

package/core/class/GrantProgramRegistry/Allo.ts

@@ -1,188 +0,0 @@
-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

@@ -1,101 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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;
-  }
-}