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

package/core/scripts/create-grant.ts

@@ -0,0 +1,102 @@
+import { AlloBase } from "../class/GrantProgramRegistry/Allo";
+import { ethers } from "ethers";
+import { Networks } from "../consts";
+import { ApplicationMetadata, RoundMetadata } from "../class/types/allo";
+import keys from "../../config/keys.json";
+import { AlloContracts } from "../consts";
+import { GrantArgs, Address } from "../class/types/allo";
+
+const networkName = "sepolia";
+const chainId = Networks[networkName].chainId;
+const web3 = new ethers.JsonRpcProvider(Networks[networkName].rpcUrl);
+const wallet = new ethers.Wallet(keys.privateKey, web3);
+const signer = wallet.connect(web3);
+
+export async function main() {
+  const allo = new AlloBase(signer, keys.ipfsToken, chainId);
+
+  const _currentTimestamp = (await signer?.provider?.getBlock(
+    await signer?.provider?.getBlockNumber()
+  ))!.timestamp;
+  const owner = wallet.address;
+
+  const profileId =
+    "0x812f0ae5dc7dd0a3a66e52f71f2da56c61a23bb06f1a149975424d6f73519ed1"; // Karma Test Program 3
+  const matchinFundAmount = 0;
+  const roundMetadata: RoundMetadata = {
+    name: "Sepolia Test Round #3",
+    support: {
+      info: "Email",
+      type: "mahesh@karmahq.xyz",
+    },
+    roundType: "public",
+    eligibility: {
+      description:
+        "This is a test round using Karma Test Program on allo-v2 for grant-program-registry.",
+      requirements: [
+        {
+          requirement: "Be awesome!",
+        },
+      ],
+    },
+    feesAddress: "",
+    feesPercentage: 0,
+    programContractAddress: "0x0613fc8c28ca79d110a104c274b2d1eacef52355", // Some Contract Address
+
+    // TODO: Additional metadata
+    category: "zk-rollups",
+    source: "grant-program-registry",
+    // type: 'Proactive',
+    // ecosystem: 'EMV',
+    // status: 'Active',
+    // size: 3000,
+  };
+  const applicationMetadata: ApplicationMetadata = {
+    version: "1.0.0",
+    lastUpdatedOn: new Date().getTime(),
+    applicationSchema: {
+      questions: [
+        {
+          id: 0,
+          info: "Email Address",
+          type: "email",
+          title: "Email Address",
+          hidden: false,
+          required: true,
+          encrypted: false,
+        },
+      ],
+      requirements: {
+        github: {
+          required: false,
+          verification: false,
+        },
+        twitter: {
+          required: false,
+          verification: false,
+        },
+        // Potentially add more requirements here if they exist in the data
+      },
+    },
+  };
+
+  const args: GrantArgs = {
+    profileId,
+    roundMetadata,
+    applicationStart: _currentTimestamp + 3600, // 1 hour later   registrationStartTime
+    applicationEnd: _currentTimestamp + 432000, // 5 days later   registrationEndTime
+    roundStart: _currentTimestamp + 7200, // 2 hours later  allocationStartTime
+    roundEnd: _currentTimestamp + 864000, // 10 days later  allocaitonEndTime
+    matchingFundAmt: matchinFundAmount,
+    applicationMetadata,
+    managers: [owner as Address], // managers
+    strategy: AlloContracts.strategy
+      .DonationVotingMerkleDistributionDirectTransferStrategy as Address, // strategy
+    payoutToken: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE", // Eg. ETH
+  };
+
+  const response = await allo.createGrant(args);
+  console.log(response);
+}
+
+main();

package/core/scripts/create-program.ts

@@ -0,0 +1,43 @@
+import { AlloRegistry } from "../class/GrantProgramRegistry/AlloRegistry";
+import { ethers } from "ethers";
+import { Networks } from "../consts";
+
+import keys from "../../config/keys.json";
+
+const networkName = "sepolia";
+const web3 = new ethers.JsonRpcProvider(Networks[networkName].rpcUrl);
+const wallet = new ethers.Wallet(keys.privateKey, web3);
+const signer = wallet.connect(web3);
+
+export async function main() {
+  const alloRegistry = new AlloRegistry(signer, keys.ipfsToken);
+
+  const nonce = 12310;
+  const name = "Karma Gap Registry";
+  const metadata = {
+    title: name,
+    description: `Karma Gap Registry`,
+    website: "gap.karmahq.xyz",
+    projectTwitter: "karmahq_",
+    logoImg: "gap.karmahq.xyz/logo/karma-gap-logo.svg",
+    bannerImg: "gap.karmahq.xyz/logo/karma-gap-logo.svg",
+    logoImgData: {},
+    bannerImgData: {},
+    credentials: {},
+    createdAt: new Date().getTime(),
+
+    type: "program",
+  };
+  const owner = await signer.getAddress();
+
+  const response = await alloRegistry.createProgram(
+    nonce,
+    metadata.title,
+    metadata,
+    owner,
+    [owner]
+  );
+  console.log(response);
+}
+
+main();

package/core/scripts/create-schemas.ts

@@ -0,0 +1,65 @@
+import { EAS, SchemaEncoder, SchemaRegistry } from "@ethereum-attestation-service/eas-sdk";
+import { ethers } from 'ethers';
+import keys from "../../config/keys.json";
+import { Networks, zeroAddress } from "../consts";
+import { resolve } from "path";
+
+const schemaRegistryContractAddress = "0x4200000000000000000000000000000000000020";
+
+(async () => {
+const schemaRegistry = new SchemaRegistry(schemaRegistryContractAddress);
+
+const web3 = new ethers.JsonRpcProvider("https://lisk.drpc.org");
+const wallet = new ethers.Wallet(keys.privateKey, web3);
+schemaRegistry.connect(wallet);
+
+const allSchemas = [
+{
+  name: "Project",
+  schema: "bool project",
+  resolver: "0x6dC1D6b864e8BEf815806f9e4677123496e12026"
+},
+  {
+  name: "Community",
+  schema: "bool community",
+  resolver: "0xfddb660F2F1C27d219372210745BB9f73431856E"
+},
+{
+  name: "Details",
+  schema: "string json",
+  resolver: "0xd2eD366393FDfd243931Fe48e9fb65A192B0018c"
+},
+{
+  name: "Grant",
+  schema: "bytes32 communityUID",
+  resolver: "0xd2eD366393FDfd243931Fe48e9fb65A192B0018c"
+},
+{
+  name: "GrantVerified",
+  schema: "string type, string reason",
+  resolver: "0x04D6BB799f5A8c76882C4372d1FC39Cd0DDA0A4c"
+},
+{
+  name: "MemberOf",
+  schema: "bool memberOf",
+  resolver: "0xd2eD366393FDfd243931Fe48e9fb65A192B0018c"
+},
+{
+    name: "ContributorProfile",
+    schema: "string json",
+    resolver: "0x0ab840273E4Ab6Dc642D02102Db719e1c1e3B299"
+  }
+];
+
+for(const schema of allSchemas) {
+    const transaction = await schemaRegistry.register({
+    schema: schema.schema,
+    resolverAddress: schema.resolver,
+    revocable: true,
+    }
+    );
+
+    const response = await transaction.wait();
+    console.log(`Schema ${schema.name} registered with UID: ${response}`);
+}
+})();

package/core/scripts/deploy.ts

@@ -0,0 +1,65 @@
+import { EASNetworkConfig, TNetwork } from "../types";
+import { MountEntities, Networks, zeroAddress } from "../consts";
+
+import SchemaRegistry from "../abi/SchemaRegistry.json";
+
+import { ethers } from "ethers";
+
+import keys from "../../config/keys.json";
+import { GapSchema } from "../class/GapSchema";
+import { writeFileSync } from "fs";
+
+const web3 = new ethers.JsonRpcProvider("https://eth-sepolia-public.unifra.io");
+const wallet = new ethers.Wallet(keys.privateKey, web3);
+
+const contract = new ethers.Contract(
+  Networks.sepolia.contracts.schema,
+  SchemaRegistry.abi,
+  wallet
+);
+
+async function deploy(networkName?: TNetwork) {
+  const [, , $3] = process.argv;
+  const network = Networks[networkName || $3] as EASNetworkConfig;
+  const key = keys[networkName || $3];
+
+  if (!(networkName || $3)) throw new Error("Network name is required");
+  if (!network) {
+    throw new Error(
+      `Invalid network name. Supported networks are: ${Object.keys(
+        Networks
+      ).join(", ")}`
+    );
+  }
+  if (!key) throw new Error("No keys found for this network");
+
+  const revocable = true;
+
+  const promises = Object.values(MountEntities(Networks.sepolia))
+    .slice(0, 1)
+    .map((entity) => {
+      return contract.register(
+        new GapSchema(entity, {} as any).raw,
+        zeroAddress,
+        revocable,
+        {
+          gasLimit: 5000000n,
+        }
+      );
+    });
+  const results: any[] = [];
+  for (const tx of promises) {
+    const txn = await tx;
+    const result = await txn.wait();
+    results.push(result);
+  }
+  console.log(results);
+  writeFileSync(
+    `schemas/GAP-schemas-${Date.now()}.json`,
+    JSON.stringify(results, null, 2)
+  );
+}
+
+if (process.argv[1].includes("core/scripts/deploy.ts")) deploy();
+
+export { deploy };

package/core/scripts/index.ts

@@ -0,0 +1 @@
+export * from './deploy';

package/core/scripts/milestone-multi-grants.ts

@@ -0,0 +1,125 @@
+/**
+ * Example script demonstrating how to attest a milestone to multiple grants in a single transaction.
+ */
+import { ethers } from "ethers";
+import { GAP } from "../class/GAP";
+import { Milestone } from "../class/entities/Milestone";
+import { Grant } from "../class/entities/Grant";
+import { Hex, SignerOrProvider } from "../types";
+import { GapContract } from "../class/contract/GapContract";
+import { MultiAttestPayload } from "../types";
+
+async function main() {
+  // Initialize GAP with your network and signer
+  // Replace with your actual RPC URL and private key
+  const provider = new ethers.JsonRpcProvider("YOUR_RPC_URL");
+  const signer = new ethers.Wallet("YOUR_PRIVATE_KEY", provider);
+  const gap = new GAP({
+    network: "optimism",
+    // Additional GAP options can be specified here if needed
+  });
+
+  try {
+    console.log("Attesting milestone to multiple grants example");
+
+    // Example: Retrieve existing grants
+    // Replace these with actual grant UIDs from your application
+    // Using TypeScript template literals to ensure proper Hex type matching
+    const grantUIDs: Hex[] = ["0x123" as Hex, "0x456" as Hex, "0x789" as Hex];
+
+    // Fetch grants using individual queries instead of fetchByUID
+    const grants = await Promise.all(
+      grantUIDs.map(async (uid) => {
+        return await gap.fetch.attestation<Grant>(uid);
+      })
+    );
+
+    console.log(`Retrieved ${grants.length} grants`);
+
+    // Create a new milestone
+    const milestone = new Milestone({
+      schema: gap.findSchema("Milestone"),
+      recipient: (await signer.getAddress()) as `0x${string}`,
+      data: {
+        title: "Cross-Grant Milestone",
+        description: "This milestone applies to multiple grants",
+        endsAt: Math.floor(Date.now() / 1000) + 86400 * 30, // 30 days from now
+        priority: 1,
+      },
+    });
+
+    console.log("Created milestone object");
+
+    // Function to attest a milestone directly to specific grant UIDs
+    async function attestMilestoneToSpecificGrants(
+      milestoneObj: Milestone,
+      grantIds: Hex[],
+      signerObj: SignerOrProvider
+    ) {
+      // Create a payload for each grant
+      const allPayloads: any[] = [];
+
+      // For each grant UID, create a milestone attestation with that grant as the reference
+      for (const grantUID of grantIds) {
+        // Create a new milestone that references this specific grant
+        const grantMilestone = new Milestone({
+          schema: milestoneObj.schema,
+          recipient: milestoneObj.recipient,
+          data: milestoneObj.data,
+          refUID: grantUID, // Point directly to this grant's UID
+        });
+
+        // Generate the payload for this grant
+        const payload = await grantMilestone.multiAttestPayload();
+        // Add each item from payload to allPayloads
+        payload.forEach((item) => allPayloads.push(item));
+      }
+
+      // Execute all attestations in a single transaction
+      const { uids, tx } = await GapContract.multiAttest(
+        signerObj,
+        allPayloads.map((p) => p[1]),
+        (status) => console.log(`Attestation status: ${status}`)
+      );
+
+      return { uids, tx };
+    }
+
+    // Attest the milestone to your specific grant UIDs
+    const result = await attestMilestoneToSpecificGrants(
+      milestone,
+      grantUIDs,
+      signer
+    );
+
+    console.log("Milestone attested to all grants successfully");
+    console.log("UIDs:", result.uids);
+
+    // If you need to complete the milestone for all grants
+    if (result.uids.length > 0) {
+      // Complete all the newly created milestones at once
+      const completionResult = await milestone.approveMultipleGrants(
+        signer,
+        result.uids, // UIDs of the milestones we just created
+        {
+          reason: "Milestone completed for all grants",
+          proofOfWork: "https://example.com/proof",
+        },
+        (status) => console.log(`Completion status: ${status}`)
+      );
+
+      console.log("Milestones completed for all grants");
+      console.log("Completion UIDs:", completionResult.uids);
+    }
+  } catch (error) {
+    console.error("Error:", error);
+  }
+}
+
+// Execute the script
+main()
+  .then(() => process.exit(0))
+  .catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });

package/core/shared/types.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/types.ts

@@ -0,0 +1,224 @@
+import { BytesLike } from "ethers";
+import {
+  AttestationRequestData,
+  EAS,
+  MultiAttestationRequest,
+  SchemaItem,
+} from "@ethereum-attestation-service/eas-sdk";
+// import { SignerOrProvider as EASSigner } from '@ethereum-attestation-service/eas-sdk/dist/transaction';
+import { Attestation, GAP } from "./class";
+import { Fetcher } from "./class/Fetcher";
+export type Hex = `0x${string}`;
+
+export type SignerOrProvider = any;
+// EASSigner & {
+//   address?: Hex;
+//   _address?: Hex;
+//   getAddress?: () => Promise<Hex>;
+// };
+
+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 =
+  // | "mainnet"
+  // | "base-goerli"
+  | "optimism"
+  | "celo"
+  | "optimism-sepolia"
+  | "arbitrum"
+  | "sepolia"
+  | "sei"
+  | "sei-testnet"
+  | "base-sepolia"
+  | "lisk"
+  | "scroll";
+
+/**
+ * Generic GAP Facade interface.
+ * This supplies the GAP class with the necessary properties.
+ */
+export abstract class Facade {
+  abstract readonly network: TNetwork;
+  abstract readonly schemas: SchemaInterface[];
+  abstract readonly fetch: Fetcher;
+  protected _eas: EAS;
+
+  get eas() {
+    return this._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 const enum STORAGE_TYPE {
+  IPFS = 0,
+  ARWEAVE = 1,
+  SWARM = 2,
+  UNKNOWN = 3,
+}
+
+export type TRemoteStorageOutput<T = unknown> = {
+  hash: T;
+  storageType: number;
+};