@show-karma/karma-gap-sdk 0.3.2 → 0.3.4

package/core/class/entities/Project.ts

@@ -0,0 +1,370 @@
+import { Attestation } from '../Attestation';
+import {
+  Grantee,
+  MemberDetails,
+  ProjectDetails,
+  Tag,
+} from '../types/attestations';
+import {
+  Hex,
+  MultiAttestPayload,
+  SignerOrProvider,
+  TNetwork,
+} from 'core/types';
+import { GapSchema } from '../GapSchema';
+import { AttestationError } from '../SchemaError';
+import { mapFilter } from '../../utils';
+import { Grant } from './Grant';
+import { nullRef } from '../../consts';
+import { MemberOf } from './MemberOf';
+import { GapContract } from '../contract/GapContract';
+
+interface _Project extends Project {}
+
+export interface IProject {
+  project: true;
+}
+
+export class Project extends Attestation<IProject> {
+  details?: ProjectDetails;
+  members: MemberOf[] = [];
+  grants: Grant[] = [];
+  grantee: Grantee;
+
+  /**
+   * Creates the payload for a multi-attestation.
+   *
+   * > if Current payload is set, it'll be used as the base payload
+   * and the project should refer to an index of the current payload,
+   * usually the community position.
+   *
+   * @param payload
+   * @param communityIdx
+   */
+  async multiAttestPayload(
+    currentPayload: MultiAttestPayload = [],
+    communityIdx = 0
+  ): Promise<MultiAttestPayload> {
+    const payload = [...currentPayload];
+    const projectIdx =
+      payload.push([this, await this.payloadFor(communityIdx)]) - 1;
+
+    if (this.details) {
+      payload.push([this.details, await this.details.payloadFor(projectIdx)]);
+    }
+
+    if (this.members?.length) {
+      await Promise.all(
+        this.members.map(async (m) =>
+          payload.push(...(await m.multiAttestPayload(payload, projectIdx)))
+        )
+      );
+    }
+
+    if (this.grants?.length) {
+      await Promise.all(
+        this.grants.map(async (g) =>
+          payload.push(...(await g.multiAttestPayload(payload, projectIdx)))
+        )
+      );
+    }
+
+    return payload.slice(currentPayload.length, payload.length);
+  }
+
+  async attest(signer: SignerOrProvider): Promise<void> {
+    const payload = await this.multiAttestPayload();
+    const uids = await GapContract.multiAttest(
+      signer,
+      payload.map((p) => p[1])
+    );
+
+    uids.forEach((uid, index) => {
+      payload[index][0].uid = uid;
+    });
+  }
+
+  async transferOwnership(signer: SignerOrProvider, newOwner: Hex) {
+    await GapContract.transferProjectOwnership(signer, this.uid, newOwner);
+  }
+
+  isOwner(signer: SignerOrProvider): Promise<boolean> {
+    return GapContract.isProjectOwner(signer, this.uid, this.chainID);
+  }
+
+  /**
+   * Add new members to the project.
+   * If any member in the array already exists in the project
+   * it'll be ignored.
+   * @param members
+   */
+  pushMembers(...members: Hex[]) {
+    this.members.push(
+      ...mapFilter(
+        members,
+        (member) => !!this.members.find((m) => m.recipient === member),
+        (member) =>
+          new MemberOf({
+            data: { memberOf: true },
+            refUID: this.uid,
+            schema: this.schema.gap.findSchema('MemberOf'),
+            recipient: member,
+            uid: nullRef,
+          })
+      )
+    );
+  }
+
+  /**
+   * Add new members to the project.
+   * If any member in the array already exists in the project
+   * it'll be ignored.
+   *
+   * __To modify member details, use `addMemberDetails(signer, MemberDetails[])` instead.__
+   * @param signer
+   * @param members
+   */
+  async attestMembers(signer: SignerOrProvider, members: MemberDetails[]) {
+    const newMembers = mapFilter(
+      members,
+      (member) => !this.members.find((m) => m.recipient === member.recipient),
+      // (member) => !!member,
+      (details) => {
+        const member = new MemberOf({
+          data: { memberOf: true },
+          refUID: this.uid,
+          schema: this.schema.gap.findSchema('MemberOf'),
+          createdAt: Date.now(),
+          recipient: details.recipient,
+          uid: nullRef,
+        });
+        return { member, details };
+      }
+    );
+
+    if (!newMembers.length) {
+      throw new AttestationError('ATTEST_ERROR', 'No new members to add.');
+    }
+
+    console.log(`Creating ${newMembers.length} new members`);
+
+    const attestedMembers = <Hex[]>await this.schema.multiAttest(
+      signer,
+      newMembers.map((m) => m.member)
+    );
+
+    console.log('attested-members', attestedMembers);
+
+    newMembers.forEach(({ member, details }, idx) => {
+      Object.assign(member, { uid: attestedMembers[idx] });
+
+      if (!details) return;
+      Object.assign(details, { refUID: attestedMembers[idx] });
+    });
+
+    this.members.push(...newMembers.map((m) => m.member));
+
+    await this.addMemberDetails(
+      signer,
+      newMembers.map((m) => m.details)
+    );
+  }
+
+  /**
+   * Add new details to the members of a project. Note that it will overwrite
+   * any existing details.
+   *
+   * @param signer
+   * @param entities
+   */
+  private async addMemberDetails(
+    signer: SignerOrProvider,
+    entities: MemberDetails[]
+  ) {
+    // Check if any of members should be revoked (details modified)
+    const toRevoke = mapFilter(
+      this.members,
+      (member) =>
+        !!entities.find(
+          (entity) =>
+            member.uid === entity.refUID &&
+            member.details &&
+            member.details?.refUID !== entity.refUID
+        ),
+      (member) => member.uid
+    );
+
+    if (toRevoke.length) {
+      console.log('Revoking details');
+      await this.cleanDetails(signer, toRevoke);
+    }
+
+    console.log(`Creating ${entities.length} new member details`);
+
+    const attestedEntities = <Hex[]>(
+      await this.schema.multiAttest(signer, entities)
+    );
+    console.log('attested-entities', attestedEntities);
+
+    entities.forEach((entity, idx) => {
+      const member = this.members.find(
+        (member) => member.uid === entity.refUID
+      );
+      if (!member) return;
+
+      Object.assign(entity, { uid: attestedEntities[idx] });
+      member.details = entity;
+    });
+  }
+
+  /**
+   * Clean member details.
+   * @param signer
+   * @param uids
+   */
+  async cleanDetails(signer: SignerOrProvider, uids: Hex[]) {
+    if (!uids.length) {
+      throw new AttestationError('ATTEST_ERROR', 'No details to clean.');
+    }
+    const memberDetails = this.schema.gap.findSchema('MemberDetails');
+
+    await this.schema.multiRevoke(
+      signer,
+      uids.map((uid) => ({ schemaId: memberDetails.uid, uid }))
+    );
+
+    this.members.forEach((member) => {
+      if (!member.details) return;
+      if (uids.includes(member.details.uid)) {
+        member.details = undefined;
+      }
+    });
+  }
+
+  /**
+   * Remove members from the project.
+   * @param signer
+   * @param uids
+   * @returns
+   */
+  async removeMembers(signer: SignerOrProvider, uids: Hex[]) {
+    if (!uids.length) {
+      throw new AttestationError('ATTEST_ERROR', 'No members to remove.');
+    }
+    const memberOf = this.schema.gap.findSchema('MemberOf');
+
+    const details = mapFilter(
+      this.members,
+      (m) => uids.includes(m.uid) && !!m.details,
+      (m) => m.details?.uid
+    );
+
+    if (details.length) {
+      await this.cleanDetails(signer, details);
+    }
+
+    await this.schema.multiRevoke(
+      signer,
+      uids.map((uid) => ({ schemaId: memberOf.uid, uid }))
+    );
+
+    this.members = this.members.filter((m) => !uids.includes(m.uid));
+  }
+
+  /**
+   * Remove all members from the project.
+   * @param signer
+   */
+  async removeAllMembers(signer: SignerOrProvider) {
+    const members = mapFilter(
+      this.members,
+      (m) => !!m.uid,
+      (m) => m.uid
+    );
+
+    if (!members.length) {
+      throw new AttestationError('REVOKATION_ERROR', 'No members to revoke.');
+    }
+
+    const details = mapFilter(
+      this.members,
+      (m) => !!m.details,
+      (m) => m.details?.uid
+    );
+    if (details.length) {
+      await this.cleanDetails(signer, details);
+    }
+
+    await this.removeMembers(signer, members);
+    this.members.splice(0, this.members.length);
+  }
+
+  static from(attestations: _Project[], network: TNetwork): Project[] {
+    return attestations.map((attestation) => {
+      const project = new Project({
+        ...attestation,
+        data: {
+          project: true,
+        },
+        schema: GapSchema.find('Project', network),
+        chainID: attestation.chainID,
+      });
+
+      if (attestation.details) {
+        const { details } = attestation;
+        project.details = new ProjectDetails({
+          ...details,
+          data: {
+            ...details.data,
+          },
+          schema: GapSchema.find('ProjectDetails', network),
+          chainID: attestation.chainID,
+        });
+
+        project.details.links = details.data.links || [];
+        project.details.tags = details.data.tags || [];
+
+        if ((attestation.data as any).links) {
+          project.details.links = (attestation.data as any).links;
+        }
+
+        if ((attestation.data as any).tags) {
+          project.details.tags = (attestation as any).tags;
+        }
+      }
+
+      if (attestation.members) {
+        project.members = attestation.members.map((m) => {
+          const member = new MemberOf({
+            ...m,
+            data: {
+              memberOf: true,
+            },
+            schema: GapSchema.find('MemberOf', network),
+            chainID: attestation.chainID,
+          });
+
+          if (m.details) {
+            const { details } = m;
+            member.details = new MemberDetails({
+              ...details,
+              data: {
+                ...details.data,
+              },
+              schema: GapSchema.find('MemberDetails', network),
+              chainID: attestation.chainID,
+            });
+          }
+
+          return member;
+        });
+      }
+
+      if (attestation.grants) {
+        project.grants = Grant.from(attestation.grants, network);
+      }
+
+      return project;
+    });
+  }
+}

package/core/class/entities/index.ts

@@ -0,0 +1,5 @@
+export * from "./Grant";
+export * from "./Milestone";
+export * from "./Project";
+export * from "./Community";
+export * from "./MemberOf";

package/core/class/index.ts

@@ -0,0 +1,10 @@
+export * from './Attestation';
+export * from './GAP';
+export * from './GapSchema';
+export * from './Schema';
+export * from './SchemaError';
+export * from './entities';
+export * from './Fetcher';
+export * from './karma-indexer/GapIndexerClient';
+export * from './remote-storage/IpfsStorage';
+export * from './remote-storage/RemoteStorage';

package/core/class/karma-indexer/GapIndexerClient.ts

@@ -0,0 +1,245 @@
+import { TSchemaName, IAttestation, TNetwork, Hex } from 'core/types';
+import { Attestation } from '../Attestation';
+import { GapSchema } from '../GapSchema';
+import { Fetcher } from '../Fetcher';
+import { Community, Project, Grant, Milestone, MemberOf } from '../entities';
+import { Grantee } from '../types/attestations';
+
+const Endpoints = {
+  attestations: {
+    all: () => '/attestations',
+    byUid: (uid: Hex) => `/attestations/${uid}`,
+  },
+  communities: {
+    all: () => '/communities',
+    byUidOrSlug: (uidOrSlug: string) => `/communities/${uidOrSlug}`,
+    grants: (uidOrSlug: string) => `/communities/${uidOrSlug}/grants`,
+  },
+  grantees: {
+    all: () => '/grantees',
+    byAddress: (address: Hex) => `/grantees/${address}`,
+    grants: (address: Hex) => `/grantees/${address}/grants`,
+    projects: (address: Hex) => `/grantees/${address}/projects`,
+    communities: (address: Hex, withGrants) =>
+      `/grantees/${address}/communities${withGrants ? '?withGrants=true' : ''}`,
+  },
+  grants: {
+    all: () => '/grants',
+    byUid: (uid: Hex) => `/grants/${uid}`,
+    byExternalId: (id: string) => `/grants/external-id/${id}`,
+  },
+  project: {
+    all: () => '/projects',
+    byUidOrSlug: (uidOrSlug: string) => `/projects/${uidOrSlug}`,
+    grants: (uidOrSlug: string) => `/projects/${uidOrSlug}/grants`,
+    milestones: (uidOrSlug: string) => `/projects/${uidOrSlug}/milestones`,
+  },
+};
+
+export class GapIndexerClient extends Fetcher {
+  async attestation<T = unknown>(
+    uid: `0x${string}`
+  ): Promise<Attestation<T, GapSchema>> {
+    const { data } = await this.client.get<IAttestation>(
+      Endpoints.attestations.byUid(uid)
+    );
+
+    if (!data) throw new Error('Attestation not found');
+    return Attestation.fromInterface<Attestation<T>>(
+      [data],
+      this.gap.network
+    )[0];
+  }
+
+  async attestations(
+    schemaName: TSchemaName,
+    search?: string
+  ): Promise<IAttestation[]> {
+    const { data } = await this.client.get<IAttestation[]>(
+      Endpoints.attestations.all(),
+      {
+        params: {
+          'filter[schemaUID]': this.gap.findSchema(schemaName).uid,
+          'filter[data]': search,
+        },
+      }
+    );
+
+    return data || [];
+  }
+
+  async attestationsOf(
+    schemaName: TSchemaName,
+    attester: `0x${string}`
+  ): Promise<IAttestation[]> {
+    const { data } = await this.client.get<IAttestation[]>(
+      Endpoints.attestations.all(),
+      {
+        params: {
+          'filter[schemaUID]': this.gap.findSchema(schemaName).uid,
+          'filter[recipient]': attester,
+        },
+      }
+    );
+
+    return data || [];
+  }
+
+  attestationsTo(
+    schemaName: TSchemaName,
+    recipient: `0x${string}`
+  ): Promise<IAttestation[]> {
+    return this.attestationsOf(schemaName, recipient);
+  }
+
+  async communities(search?: string): Promise<Community[]> {
+    const { data } = await this.client.get<Community[]>(
+      Endpoints.communities.all(),
+      {
+        params: {
+          'filter[name]': search,
+        },
+      }
+    );
+
+    return Community.from(data, this.gap.network);
+  }
+
+  async communitiesOf(address: Hex, withGrants: boolean): Promise<Community[]> {
+    const { data } = await this.client.get<Community[]>(
+      Endpoints.grantees.communities(address, withGrants)
+    );
+
+    return Community.from(data, this.gap.network);
+  }
+
+  communitiesByIds(uids: `0x${string}`[]): Promise<Community[]> {
+    throw new Error('Method not implemented.');
+  }
+
+  async communityBySlug(slug: string): Promise<Community> {
+    const { data } = await this.client.get<Community>(
+      Endpoints.communities.byUidOrSlug(slug)
+    );
+
+    return Community.from([data], this.gap.network)[0];
+  }
+
+  communityById(uid: `0x${string}`): Promise<Community> {
+    return this.communityBySlug(uid);
+  }
+
+  async projectBySlug(slug: string): Promise<Project> {
+    const { data } = await this.client.get<Project>(
+      Endpoints.project.byUidOrSlug(slug)
+    );
+
+    return Project.from([data], this.gap.network)[0];
+  }
+
+  projectById(uid: `0x${string}`): Promise<Project> {
+    return this.projectBySlug(uid);
+  }
+
+  async searchProjects(query: string): Promise<Project[]> {
+    const { data } = await this.client.get<Project[]>(Endpoints.project.all(), {
+      params: {
+        q: query,
+      },
+    });
+
+    return Project.from(data, this.gap.network);
+  }
+
+  async projects(name?: string): Promise<Project[]> {
+    const { data } = await this.client.get<Project[]>(Endpoints.project.all(), {
+      params: {
+        'filter[title]': name,
+      },
+    });
+
+    return Project.from(data, this.gap.network);
+  }
+
+  async projectsOf(grantee: `0x${string}`): Promise<Project[]> {
+    const { data } = await this.client.get<Project[]>(
+      Endpoints.grantees.projects(grantee)
+    );
+
+    return Project.from(data, this.gap.network);
+  }
+
+  async grantee(address: `0x${string}`): Promise<Grantee> {
+    const { data } = await this.client.get<Grantee>(
+      Endpoints.grantees.byAddress(address)
+    );
+
+    return data;
+  }
+
+  async grantees(): Promise<Grantee[]> {
+    const { data } = await this.client.get<Grantee[]>(Endpoints.grantees.all());
+
+    return data;
+  }
+
+  async grantsOf(
+    grantee: `0x${string}`,
+    withCommunity?: boolean
+  ): Promise<Grant[]> {
+    const { data } = await this.client.get<Grant[]>(
+      Endpoints.grantees.grants(grantee)
+    );
+
+    return Grant.from(data, this.gap.network);
+  }
+
+  async grantsFor(
+    projects: Project[],
+    withCommunity?: boolean
+  ): Promise<Grant[]> {
+    const { data } = await this.client.get<Grant[]>(
+      Endpoints.project.grants(projects[0].uid)
+    );
+
+    return Grant.from(data, this.gap.network);
+  }
+
+  async grantsForExtProject(projectExtId: string): Promise<Grant[]> {
+    const { data } = await this.client.get<Grant[]>(
+      Endpoints.grants.byExternalId(projectExtId)
+    );
+
+    return Grant.from(data, this.gap.network);
+  }
+
+  async grantsByCommunity(uid: `0x${string}`) {
+    const { data } = await this.client.get<Grant[]>(
+      Endpoints.communities.grants(uid)
+    );
+
+    return Grant.from(data, this.gap.network);
+  }
+
+  async milestonesOf(grants: Grant[]): Promise<Milestone[]> {
+    const { data } = await this.client.get<Milestone[]>(
+      Endpoints.project.milestones(grants[0].uid)
+    );
+
+    return Milestone.from(data, this.gap.network);
+  }
+
+  async membersOf(projects: Project[]): Promise<MemberOf[]> {
+    throw new Error('Method not implemented.');
+  }
+
+  async slugExists(slug: string): Promise<boolean> {
+    try {
+      await this.client.get<Project>(Endpoints.project.byUidOrSlug(slug));
+
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}

package/core/class/remote-storage/IpfsStorage.ts

@@ -0,0 +1,51 @@
+import { NFTStorage } from 'nft.storage';
+import { RemoteStorage } from './RemoteStorage';
+import { RemoteStorageError } from '../SchemaError';
+import { getIPFSData } from '../../utils';
+import { STORAGE_TYPE, TRemoteStorageOutput } from 'core/types';
+
+export interface IpfsStorageOptions {
+  token: string;
+  endpoint?: URL;
+}
+
+export class IpfsStorage extends RemoteStorage<NFTStorage> {
+  constructor(
+    opts: IpfsStorageOptions,
+    /**
+     * If set, will send request to another server instead of
+     * using the local instance
+     */
+    sponsor?: RemoteStorage['sponsor']
+  ) {
+    super(STORAGE_TYPE.IPFS, sponsor);
+
+    this.assert(opts);
+    this.client = new NFTStorage({ ...opts });
+  }
+
+  private assert(opts: IpfsStorageOptions) {}
+
+  async save<T = unknown>(data: T): Promise<string> {
+    try {
+      const blob = new Blob([JSON.stringify(data)], {
+        type: 'application/json',
+      });
+      const cid = await this.client.storeBlob(blob);
+      return cid;
+    } catch (error) {
+      throw new RemoteStorageError(
+        'REMOTE_STORAGE_UPLOAD',
+        `Error adding data to IPFS`
+      );
+    }
+  }
+
+  encode(data: string): TRemoteStorageOutput<string> {
+    return { hash: data, storageType: this.storageType };
+  }
+
+  async get<T = unknown>(args: { cid: string }): Promise<T> {
+    return getIPFSData<T>(args.cid);
+  }
+}