@dorafactory/maci-sdk 0.0.1

package/src/libs/http/http.ts

@@ -0,0 +1,152 @@
+import {
+  BaseError,
+  HttpError,
+  GraphQLError,
+  ParseError,
+} from '../errors';
+
+export type FetchOptions = RequestInit & {
+  next?: {
+    revalidate?: boolean | number;
+  };
+};
+
+export class Http {
+  private apiEndpoint: string;
+  private restEndpoint: string;
+  private defaultOptions?: FetchOptions;
+
+  constructor(
+    apiEndpoint: string,
+    restEndpoint: string,
+    private customFetch?: typeof fetch,
+    defaultOptions?: FetchOptions
+  ) {
+    this.apiEndpoint = apiEndpoint;
+    this.restEndpoint = restEndpoint;
+    this.defaultOptions = defaultOptions;
+  }
+
+  private getFetch() {
+    return this.customFetch || fetch;
+  }
+
+  async fetch(url: string): Promise<Response> {
+    try {
+      const fetchFn = this.getFetch();
+      const response = await fetchFn(url, {
+        ...this.defaultOptions,
+      });
+
+      if (!response.ok) {
+        throw new HttpError(
+          `HTTP error! status: ${response.status}`,
+          response.status
+        );
+      }
+
+      return response;
+    } catch (error) {
+      if (error instanceof HttpError) {
+        throw error;
+      }
+      throw new HttpError(`Failed to fetch: ${(error as Error).message}`, 500);
+    }
+  }
+
+  async fetchGraphql<T>(
+    query: string,
+    after: string,
+    limit: number | null = 10
+  ): Promise<T> {
+    try {
+      const isFirstPage = after === 'first';
+      const fetchFn = this.getFetch();
+
+      const response = await fetchFn(this.apiEndpoint, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Accept: 'application/json',
+        },
+        body: JSON.stringify({
+          query,
+          variables: { limit, after: isFirstPage ? undefined : after },
+        }),
+        ...this.defaultOptions,
+      });
+
+      if (!response.ok) {
+        const errorData = await response.json();
+
+        if (errorData.errors?.[0]?.message?.includes('Syntax Error')) {
+          throw new GraphQLError(
+            `GraphQL syntax error: ${errorData.errors[0].message}`
+          );
+        }
+
+        if (errorData.errors?.length > 0) {
+          throw new GraphQLError(
+            errorData.errors[0].message || 'Unknown GraphQL error'
+          );
+        }
+
+        throw new HttpError(
+          `HTTP error: ${JSON.stringify(errorData)}`,
+          response.status
+        );
+      }
+
+      const data = await response.json();
+
+      if (data.errors) {
+        throw new GraphQLError(
+          data.errors[0]?.message || 'GraphQL query failed'
+        );
+      }
+
+      return data;
+    } catch (error) {
+      if (error instanceof BaseError) {
+        throw error;
+      }
+      if (error instanceof SyntaxError) {
+        throw new ParseError('Failed to parse JSON response');
+      }
+      throw new HttpError(
+        `Failed to fetch GraphQL: ${(error as Error).message}`,
+        500
+      );
+    }
+  }
+
+  async fetchRest(path: string): Promise<any> {
+    try {
+      const fetchFn = this.getFetch();
+      const response = await fetchFn(`${this.restEndpoint}${path}`, {
+        ...this.defaultOptions,
+      });
+
+      if (!response.ok) {
+        throw new HttpError(
+          `HTTP error! status: ${response.status}`,
+          response.status
+        );
+      }
+
+      try {
+        return await response.json();
+      } catch (error) {
+        throw new ParseError('Failed to parse JSON response');
+      }
+    } catch (error) {
+      if (error instanceof BaseError) {
+        throw error;
+      }
+      throw new HttpError(
+        `Failed to fetch REST: ${(error as Error).message}`,
+        500
+      );
+    }
+  }
+}

package/src/libs/http/index.ts

@@ -0,0 +1 @@
+export { Http } from './http';

package/src/libs/index.ts

@@ -0,0 +1,4 @@
+export { Http } from './http';
+export * from './query';
+export * from './indexer';
+export * from './contract';

package/src/libs/indexer/index.ts

@@ -0,0 +1 @@
+export { Indexer } from './indexer';

package/src/libs/indexer/indexer.ts

@@ -0,0 +1,240 @@
+import {
+  BalanceResponse,
+  RoundResponse,
+  RoundsResponse,
+  OperatorResponse,
+  OperatorsResponse,
+  CircuitResponse,
+  TransactionResponse,
+  TransactionsResponse,
+  CircuitsResponse,
+  ProofResponse,
+} from '../../types';
+import { IndexerParams } from './types';
+import { Http } from '../http';
+import {
+  Round,
+  Account,
+  Circuit,
+  Operator,
+  Proof,
+  Transaction,
+} from '../query';
+
+/**
+ * @class Indexer
+ * @description This class is used to interact with Maci Indexer.
+ */
+export class Indexer {
+  public restEndpoint: string;
+  public apiEndpoint: string;
+  public registryAddress: string;
+
+  public http: Http;
+  public round: Round;
+  public account: Account;
+  public circuit: Circuit;
+  public operator: Operator;
+  public proof: Proof;
+  public transaction: Transaction;
+
+  /**
+   * @constructor
+   * @param {IndexerParams} params - The parameters for the Maci Indexer instance.
+   */
+  constructor({
+    restEndpoint,
+    apiEndpoint,
+    registryAddress,
+    http,
+  }: IndexerParams) {
+    this.http = http;
+
+    this.restEndpoint = restEndpoint;
+    this.apiEndpoint = apiEndpoint;
+    this.registryAddress = registryAddress;
+
+    this.round = new Round(this.http);
+    this.account = new Account(this.http);
+    this.circuit = new Circuit(this.http);
+    this.operator = new Operator(this.http, this.registryAddress);
+    this.proof = new Proof(this.http);
+    this.transaction = new Transaction(this.http);
+  }
+
+  /**
+   * @method balanceOf
+   * @description Get the balance of a specific address.
+   * @param {string} address - The address to check the balance for.
+   * @returns {Promise<BalanceResponse>} The balance response.
+   */
+  async balanceOf(address: string): Promise<BalanceResponse> {
+    return await this.account.balanceOf(address);
+  }
+
+  /**
+   * @method getRoundById
+   * @description Get a round by its ID.
+   * @param {string} id - The ID of the round.
+   * @returns {Promise<RoundResponse>} The round response.
+   */
+  async getRoundById(id: string): Promise<RoundResponse> {
+    return await this.round.getRoundById(id);
+  }
+
+  /**
+   * @method getRounds
+   * @description Get multiple rounds.
+   * @param {string} after - The cursor to start after.
+   * @param {number} [limit] - The number of rounds to retrieve.
+   * @returns {Promise<RoundsResponse>} The rounds response.
+   */
+  async getRounds(after: string, limit?: number): Promise<RoundsResponse> {
+    return await this.round.getRounds(after, limit);
+  }
+
+  /**
+   * @method getRoundsByStatus
+   * @description Get rounds by their status.
+   * @param {string} status - The status of the rounds to retrieve.
+   * @param {string} after - The cursor to start after.
+   * @param {number} [limit] - The number of rounds to retrieve.
+   * @returns {Promise<RoundsResponse>} The rounds response.
+   */
+  async getRoundsByStatus(
+    status: string,
+    after: string,
+    limit?: number
+  ): Promise<RoundsResponse> {
+    return await this.round.getRoundsByStatus(status, after, limit);
+  }
+
+  /**
+   * @method getRoundsByCircuitName
+   * @description Get rounds by their circuit name.
+   * @param {string} name - The name of the circuit.
+   * @param {string} after - The cursor to start after.
+   * @param {number} [limit] - The number of rounds to retrieve.
+   * @returns {Promise<RoundsResponse>} The rounds response.
+   */
+  async getRoundsByCircuitName(
+    name: string,
+    after: string,
+    limit?: number
+  ): Promise<RoundsResponse> {
+    return await this.round.getRoundsByCircuitName(name, after, limit);
+  }
+
+  /**
+   * @method getRoundsByOperator
+   * @description Get rounds by their operator address.
+   * @param {string} address - The address of the operator.
+   * @param {string} after - The cursor to start after.
+   * @param {number} [limit] - The number of rounds to retrieve.
+   * @returns {Promise<RoundsResponse>} The rounds response.
+   */
+  async getRoundsByOperator(
+    address: string,
+    after: string,
+    limit?: number
+  ): Promise<RoundsResponse> {
+    return await this.round.getRoundsByOperator(address, after, limit);
+  }
+
+  /**
+   * @method getOperatorByAddress
+   * @description Get an operator by their address.
+   * @param {string} address - The address of the operator.
+   * @returns {Promise<OperatorResponse>} The operator response.
+   */
+  async getOperatorByAddress(address: string): Promise<OperatorResponse> {
+    return await this.operator.getOperatorByAddress(address);
+  }
+
+  /**
+   * @method getOperators
+   * @description Get multiple operators.
+   * @param {string} after - The cursor to start after.
+   * @param {number} [limit] - The number of operators to retrieve.
+   * @returns {Promise<OperatorsResponse>} The operators response.
+   */
+  async getOperators(
+    after: string,
+    limit?: number
+  ): Promise<OperatorsResponse> {
+    return await this.operator.getOperators(after, limit);
+  }
+
+  /**
+   * @method getCircuitByName
+   * @description Get a circuit by its name.
+   * @param {string} name - The name of the circuit.
+   * @returns {Promise<CircuitResponse>} The circuit response.
+   */
+  async getCircuitByName(name: string): Promise<CircuitResponse> {
+    return await this.circuit.getCircuitByName(name);
+  }
+
+  /**
+   * @method getCircuits
+   * @description Get all available circuits.
+   * @returns {Promise<CircuitsResponse>} The circuits response.
+   */
+  async getCircuits(): Promise<CircuitsResponse> {
+    return await this.circuit.getCircuits();
+  }
+
+  /**
+   * @method getTransactionByHash
+   * @description Get a transaction by its hash.
+   * @param {string} hash - The hash of the transaction.
+   * @returns {Promise<TransactionResponse>} The transaction response.
+   */
+  async getTransactionByHash(hash: string): Promise<TransactionResponse> {
+    return await this.transaction.getTransactionByHash(hash);
+  }
+
+  /**
+   * @method getTransactions
+   * @description Get multiple transactions.
+   * @param {string} after - The cursor to start after.
+   * @param {number} [limit] - The number of transactions to retrieve.
+   * @returns {Promise<TransactionsResponse>} The transactions response.
+   */
+  async getTransactions(
+    after: string,
+    limit?: number
+  ): Promise<TransactionsResponse> {
+    return await this.transaction.getTransactions(after, limit);
+  }
+
+  /**
+   * @method getTransactionsByContractAddress
+   * @description Get transactions by contract address.
+   * @param {string} address - The contract address.
+   * @param {string} after - The cursor to start after.
+   * @param {number} [limit] - The number of transactions to retrieve.
+   * @returns {Promise<TransactionsResponse>} The transactions response.
+   */
+  async getTransactionsByContractAddress(
+    address: string,
+    after: string,
+    limit?: number
+  ): Promise<TransactionsResponse> {
+    return await this.transaction.getTransactionsByContractAddress(
+      address,
+      after,
+      limit
+    );
+  }
+
+  /**
+   * @method getProofByContractAddress
+   * @description Get proof data by contract address.
+   * @param {string} address - The contract address.
+   * @returns {Promise<ProofResponse>} The proof response.
+   */
+  async getProofByContractAddress(address: string): Promise<ProofResponse> {
+    return await this.proof.getProofByContractAddress(address);
+  }
+}

package/src/libs/indexer/types.ts

@@ -0,0 +1,8 @@
+import { FetchOptions, Http } from '../http/http';
+
+export type IndexerParams = {
+  restEndpoint: string;
+  apiEndpoint: string;
+  registryAddress: string;
+  http: Http;
+};

package/src/libs/query/account.ts

@@ -0,0 +1,39 @@
+import { Http } from '../http';
+import { BalanceResponse } from '../../types';
+import { handleError, ErrorType } from '../errors';
+import { ERROR } from '../errors/types';
+
+export class Account {
+  public http: Http;
+
+  constructor(http: Http) {
+    this.http = http;
+  }
+
+  async balanceOf(address: string): Promise<BalanceResponse> {
+    try {
+      const path = `/cosmos/bank/v1beta1/balances/${address}/by_denom?denom=peaka`;
+      const data = await this.http.fetchRest(path);
+
+      if (data['code'] === undefined) {
+        const response: BalanceResponse = {
+          code: 200,
+          data: {
+            balance: data['balance']['amount'],
+          },
+        };
+        return response;
+      } else {
+        return {
+          code: 404,
+          error: {
+            message: 'Address not found',
+            type: ERROR.ERROR_ADDRESS_NOT_FOUND,
+          },
+        };
+      }
+    } catch (error) {
+      return handleError(error as ErrorType);
+    }
+  }
+}

package/src/libs/query/circuit.ts

@@ -0,0 +1,99 @@
+import { Http } from '../../libs';
+import {
+  CircuitResponse,
+  CircuitsCountGraphqlResponse,
+  CircuitType,
+  CircuitsResponse,
+} from '../../types';
+import { circuits } from '../const';
+import { handleError, ErrorType } from '../errors';
+import { ERROR } from '../errors/types';
+
+export class Circuit {
+  public http: Http;
+
+  constructor(http: Http) {
+    this.http = http;
+  }
+
+  async getCircuitByName(name: string): Promise<CircuitResponse> {
+    try {
+      const circuitName = name;
+      const circuitData: CircuitType = circuits[circuitName];
+
+      if (circuitData === undefined) {
+        return {
+          code: 404,
+          error: {
+            message: `Circuit ${circuitName} not found`,
+            type: ERROR.ERROR_CIRCUIT_NOT_FOUND,
+          },
+        };
+      }
+
+      const CIRCUIT_ROUNDS_COUNT_QUERY = `
+    query {
+      rounds(filter: { circuitName: { equalTo: "${circuitData.displayName}" } }) {
+        totalCount
+      }
+    }
+    `;
+      const circuitRoundsCountResponse =
+        await this.http.fetchGraphql<CircuitsCountGraphqlResponse>(
+          CIRCUIT_ROUNDS_COUNT_QUERY,
+          ''
+        );
+
+      circuitData.roundCount =
+        circuitRoundsCountResponse.data.rounds.totalCount;
+
+      const response: CircuitResponse = {
+        code: 200,
+        data: {
+          circuit: circuitData,
+        },
+      };
+
+      return response;
+    } catch (error) {
+      return handleError(error as ErrorType);
+    }
+  }
+
+  async getCircuits(): Promise<CircuitsResponse> {
+    try {
+      const circuitsArray: CircuitType[] = Object.values(circuits).sort(
+        (a, b) => a.displayName.localeCompare(b.displayName)
+      );
+
+      const circuitsWithRoundCount = await Promise.all(
+        circuitsArray.map(async (circuit) => {
+          const CIRCUIT_ROUNDS_COUNT_QUERY = `
+            query {
+              rounds(filter: { circuitName: { equalTo: "${circuit.displayName}" } }) {
+                totalCount
+              }
+            }
+          `;
+          const circuitRoundsCountResponse: CircuitsCountGraphqlResponse =
+            await this.http.fetchGraphql(CIRCUIT_ROUNDS_COUNT_QUERY, '');
+          return {
+            ...circuit,
+            roundCount: circuitRoundsCountResponse.data.rounds.totalCount,
+          };
+        })
+      );
+
+      const response: CircuitsResponse = {
+        code: 200,
+        data: {
+          circuits: circuitsWithRoundCount,
+        },
+      };
+
+      return response;
+    } catch (error) {
+      return handleError(error as ErrorType);
+    }
+  }
+}

package/src/libs/query/index.ts

@@ -0,0 +1,6 @@
+export { Account } from './account';
+export { Circuit } from './circuit';
+export { Operator } from './operator';
+export { Round } from './round';
+export { Transaction } from './transaction';
+export { Proof } from './proof';