@dorafactory/maci-sdk 0.0.20 → 0.0.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dorafactory/maci-sdk",
-  "version": "0.0.20",
+  "version": "0.0.21",
   "description": "SDK for interacting with maci",
   "keywords": [
     "maci",

package/src/libs/contract/contract.ts

@@ -27,7 +27,11 @@ import {
   CreateMaciRoundParams,
   CreateOracleMaciRoundParams,
 } from './types';
-import { getCircuitType, getContractParams } from './utils';
+import {
+  getAMaciRoundCircuitFee,
+  getCircuitType,
+  getContractParams,
+} from './utils';
 import { QTR_LIB } from './vars';
 import { MaciRoundType, MaciCertSystemType } from '../../types';
 import { decompressPublicKey } from '../../utils';
@@ -82,26 +86,33 @@ export class Contract {
       contractAddress: this.registryAddress,
     });
 
+    const requiredFee = getAMaciRoundCircuitFee(maxVoter, maxOption);
+
     preDeactivateRoot = preDeactivateRoot || '0';
-    const res = await client.createRound({
-      operator,
-      preDeactivateRoot,
-      voiceCreditAmount,
-      whitelist,
-      roundInfo: {
-        title,
-        description: description || '',
-        link: link || '',
-      },
-      votingTime: {
-        start_time,
-        end_time,
+    const res = await client.createRound(
+      {
+        operator,
+        preDeactivateRoot,
+        voiceCreditAmount,
+        whitelist,
+        roundInfo: {
+          title,
+          description: description || '',
+          link: link || '',
+        },
+        votingTime: {
+          start_time,
+          end_time,
+        },
+        maxVoter: maxVoter.toString(),
+        maxOption: maxOption.toString(),
+        certificationSystem: '0',
+        circuitType,
       },
-      maxVoter,
-      maxOption,
-      certificationSystem: '0',
-      circuitType,
-    });
+      'auto',
+      undefined,
+      [requiredFee]
+    );
     let contractAddress = '';
     res.events.map((event) => {
       if (event.type === 'wasm') {
@@ -208,8 +219,8 @@ export class Contract {
       MaciRoundType.ORACLE_MACI,
       circuitType,
       MaciCertSystemType.GROTH16,
-      '0',
-      '0'
+      0,
+      0
     );
     const instantiateResponse = await client.instantiate(
       address,

package/src/libs/contract/types.ts

@@ -18,8 +18,8 @@ export type CreateRoundParams = {
 };
 
 export type CreateAMaciRoundParams = {
-  maxVoter: string;
-  maxOption: string;
+  maxVoter: number;
+  maxOption: number;
   operator: string;
   whitelist: RegistryWhitelist;
   voiceCreditAmount: string;
@@ -27,8 +27,8 @@ export type CreateAMaciRoundParams = {
 } & CreateRoundParams;
 
 export type CreateMaciRoundParams = {
-  maxVoter: string;
-  maxOption: string;
+  maxVoter: number;
+  maxOption: number;
   operatorPubkey: string;
   whitelist: MaciWhitelist;
   certSystemType: MaciCertSystemType;

package/src/libs/contract/utils.ts

@@ -50,8 +50,8 @@ export function getContractParams(
   type: MaciRoundType,
   circuitType: MaciCircuitType,
   proofSystem: MaciCertSystemType,
-  maxVoter: string,
-  maxOption: string
+  maxVoter: number,
+  maxOption: number
 ) {
   let parameters: {
     state_tree_depth: string;
@@ -92,7 +92,7 @@ export function getContractParams(
       );
   }
 
-  if (Number(maxVoter) <= 25 && Number(maxOption) <= 5) {
+  if (maxVoter <= 25 && maxOption <= 5) {
     // state_tree_depth: 2
     // vote_option_tree_depth: 1
     parameters = CIRCUIT_INFO['2-1-1-5'].parameter;
@@ -103,7 +103,7 @@ export function getContractParams(
       plonkProcessVkey = CIRCUIT_INFO['2-1-1-5']['plonk']?.process_vkey;
       plonkTallyVkey = CIRCUIT_INFO['2-1-1-5']['plonk']?.tally_vkey;
     }
-  } else if (Number(maxVoter) <= 625 && Number(maxOption) <= 25) {
+  } else if (maxVoter <= 625 && maxOption <= 25) {
     // state_tree_depth: 4
     // vote_option_tree_depth: 2
     parameters = CIRCUIT_INFO['4-2-2-25'].parameter;
@@ -114,7 +114,7 @@ export function getContractParams(
       plonkProcessVkey = CIRCUIT_INFO['4-2-2-25']['plonk']?.process_vkey;
       plonkTallyVkey = CIRCUIT_INFO['4-2-2-25']['plonk']?.tally_vkey;
     }
-  } else if (Number(maxVoter) <= 15625 && Number(maxOption) <= 125) {
+  } else if (maxVoter <= 15625 && maxOption <= 125) {
     // state_tree_depth: 6
     // vote_option_tree_depth: 3
     parameters = CIRCUIT_INFO['6-3-3-125'].parameter;
@@ -125,7 +125,7 @@ export function getContractParams(
       plonkProcessVkey = CIRCUIT_INFO['6-3-3-125']['plonk']?.process_vkey;
       plonkTallyVkey = CIRCUIT_INFO['6-3-3-125']['plonk']?.tally_vkey;
     }
-  } else if (Number(maxVoter) <= 1953125 && Number(maxOption) <= 125) {
+  } else if (maxVoter <= 1953125 && maxOption <= 125) {
     // state_tree_depth: 9
     // vote_option_tree_depth: 3
     parameters = CIRCUIT_INFO['9-4-3-625'].parameter;
@@ -185,3 +185,23 @@ export function getContractParams(
       };
   }
 }
+
+export function getAMaciRoundCircuitFee(maxVoter: number, maxOption: number) {
+  let requiredFee = {
+    denom: 'peaka',
+    amount: '0',
+  };
+  if (maxVoter <= 25 && maxOption <= 5) {
+    // state_tree_depth: 2
+    // vote_option_tree_depth: 1
+    requiredFee.amount = '50000000000000000000';
+  } else if (maxVoter <= 625 && maxOption <= 25) {
+    // state_tree_depth: 4
+    // vote_option_tree_depth: 2
+    requiredFee.amount = '100000000000000000000';
+  } else {
+    throw new Error('Number of voters or options is too large.');
+  }
+
+  return requiredFee;
+}

package/src/libs/errors/types.ts

@@ -3,6 +3,9 @@ export const ERROR = {
   ERROR_CIRCUIT_NOT_FOUND: 'ERROR_CIRCUIT_NOT_FOUND',
   ERROR_OPERATOR_INVALID_ADDRESS: 'ERROR_OPERATOR_INVALID_ADDRESS',
   ERROR_OPERATOR_NOT_FOUND: 'ERROR_OPERATOR_NOT_FOUND',
+  ERROR_OPERATOR_DELAY_HISTORY_NOT_FOUND:
+    'ERROR_OPERATOR_DELAY_HISTORY_NOT_FOUND',
+  ERROR_QUERY_MISS_RATE_FAILED: 'ERROR_QUERY_MISS_RATE_FAILED',
   ERROR_OPERATORS_NOT_FOUND: 'ERROR_OPERATORS_NOT_FOUND',
   ERROR_PROOF_NOT_FOUND: 'ERROR_PROOF_NOT_FOUND',
   ERROR_ROUND_INVALID_ADDRESS: 'ERROR_ROUND_INVALID_ADDRESS',

package/src/libs/indexer/indexer.ts

@@ -10,6 +10,8 @@ import {
   CircuitsResponse,
   ProofResponse,
   SignUpEventsResponse,
+  OperatorDelayOperationsResponse,
+  MissRateResponse,
 } from '../../types';
 import { IndexerParams } from './types';
 import { Http } from '../http';
@@ -155,6 +157,25 @@ export class Indexer {
     return await this.operator.getOperatorByAddress(address);
   }
 
+  async getOperatorDelayOperationsByAddress(
+    address: string,
+    after: string,
+    limit?: number
+  ): Promise<OperatorDelayOperationsResponse> {
+    return await this.operator.getOperatorDelayOperationsByAddress(
+      address,
+      after,
+      limit
+    );
+  }
+
+  async queryMissRate(
+    address: string,
+    durationDay: number
+  ): Promise<MissRateResponse> {
+    return await this.operator.queryMissRate(address, durationDay);
+  }
+
   /**
    * @method getOperators
    * @description Get multiple operators.

package/src/libs/maci/maci.ts

@@ -253,6 +253,66 @@ export class MACI {
     return circuitType === '1';
   }
 
+  async queryRoundClaimable({
+    contractAddress,
+  }: {
+    contractAddress: string;
+  }): Promise<{
+    claimable: boolean | null;
+    balance: string | null;
+  }> {
+    try {
+      const roundInfo = await this.getRoundInfo({ contractAddress });
+
+      if (roundInfo.maciType !== 'aMACI') {
+        return {
+          claimable: null,
+          balance: null,
+        };
+      }
+
+      const votingEndTime = new Date(Number(roundInfo.votingEnd) / 10 ** 6);
+      const currentTime = new Date();
+      const threeDaysInMs = 3 * 24 * 60 * 60 * 1000;
+
+      if (currentTime.getTime() - votingEndTime.getTime() <= threeDaysInMs) {
+        return {
+          claimable: null,
+          balance: null,
+        };
+      }
+
+      const roundBalance = await this.indexer.balanceOf(contractAddress);
+      if (isErrorResponse(roundBalance)) {
+        throw new Error(
+          `Failed to query round balance: ${roundBalance.error.type} ${roundBalance.error.message}`
+        );
+      }
+
+      if (
+        roundBalance.data.balance &&
+        roundBalance.data.balance !== '0' &&
+        roundBalance.data.balance !== ''
+      ) {
+        return {
+          claimable: true,
+          balance: roundBalance.data.balance,
+        };
+      }
+
+      return {
+        claimable: false,
+        balance: roundBalance.data.balance,
+      };
+    } catch (error) {
+      console.error('Error in queryRoundClaimable:', error);
+      return {
+        claimable: null,
+        balance: null,
+      };
+    }
+  }
+
   async queryRoundGasStation({ contractAddress }: { contractAddress: string }) {
     const roundInfo = await this.getRoundInfo({ contractAddress });
 

package/src/libs/query/operator.ts

@@ -5,6 +5,12 @@ import {
   RoundsCountGraphqlResponse,
   OperatorResponse,
   OperatorsResponse,
+  OperatorDelayOperationsResponse,
+  OperatorDelayOperationsGraphqlResponse,
+  MissRateResponse,
+  MissRateType,
+  TransactionsGraphqlResponse,
+  RoundsGraphqlResponse,
 } from '../../types';
 import { isValidAddress } from '../../utils';
 import { handleError, ErrorType } from '../errors';
@@ -131,6 +137,79 @@ export class Operator {
     }
   }
 
+  async getOperatorDelayOperationsByAddress(
+    address: string,
+    after: string,
+    limit?: number
+  ): Promise<OperatorDelayOperationsResponse> {
+    try {
+      if (!isValidAddress(address)) {
+        return {
+          code: 400,
+          error: {
+            message: 'Invalid operator address format',
+            type: ERROR.ERROR_OPERATOR_INVALID_ADDRESS,
+          },
+        };
+      }
+
+      const OPERATORS_QUERY = `query ($limit: Int, $after: Cursor) {
+        operatorDelayOperations(first: $limit, after: $after, filter: {operatorAddress: {equalTo: "${address}"}}, orderBy: [TIMESTAMP_DESC]) {
+          pageInfo {
+            endCursor
+            hasNextPage
+          }
+          totalCount
+          edges {
+            cursor
+            node {
+              blockHeight
+              delayProcessDmsgCount
+              delayDuration
+              delayReason
+              delayType
+              id
+              nodeId
+              operatorAddress
+              timestamp
+              roundAddress
+            }
+          }
+        }
+      }`;
+
+      const response =
+        await this.http.fetchGraphql<OperatorDelayOperationsGraphqlResponse>(
+          OPERATORS_QUERY,
+          after,
+          limit
+        );
+
+      if (
+        !response ||
+        !response.data ||
+        !response.data.operatorDelayOperations ||
+        !response.data.operatorDelayOperations.edges ||
+        response.data.operatorDelayOperations.edges.length === 0
+      ) {
+        return {
+          code: 404,
+          error: {
+            message: `No operatorDelayOperations found for address ${address}`,
+            type: ERROR.ERROR_OPERATOR_DELAY_HISTORY_NOT_FOUND,
+          },
+        };
+      }
+      const operator: OperatorDelayOperationsResponse = {
+        code: 200,
+        data: response.data,
+      };
+      return operator;
+    } catch (error) {
+      return handleError(error as ErrorType);
+    }
+  }
+
   async getOperators(
     after: string,
     limit?: number
@@ -260,4 +339,263 @@ export class Operator {
       return handleError(error as ErrorType);
     }
   }
+
+  async queryMissRate(
+    address: string,
+    durationDay: number
+  ): Promise<MissRateResponse> {
+    try {
+      const now = new Date();
+      const startTime = new Date(
+        now.getTime() - durationDay * 24 * 60 * 60 * 1000
+      );
+      const startTimestamp = Math.floor(startTime.getTime() / 1000);
+      const endNanosTimestamp = Math.floor(startTime.getTime() * 1000000);
+      const txTimestamp = Math.floor(startTime.getTime());
+
+      const QUERY = `query ($limit: Int, $after: Cursor) {
+        operatorDelayOperations(
+          first: $limit,
+          after: $after,
+          filter: {
+            operatorAddress: {equalTo: "${address}"},
+            timestamp: { greaterThanOrEqualTo: "${startTimestamp}" }
+          },
+          orderBy: [TIMESTAMP_DESC]
+        ) {
+          edges {
+            node {
+              blockHeight
+              delayProcessDmsgCount
+              delayDuration
+              delayReason
+              delayType
+              id
+              nodeId
+              operatorAddress
+              timestamp
+              roundAddress
+            }
+          }
+        }
+      }`;
+
+      const ROUNDS_QUERY = `query ($limit: Int, $after: Cursor) {
+        rounds(first: $limit, after: $after, 
+              filter: {
+                operator: {equalTo: "${address}"},
+                votingEnd: { greaterThanOrEqualTo: "${endNanosTimestamp}" }
+              },
+              orderBy: [TIMESTAMP_DESC]
+            ){
+              pageInfo {
+                endCursor
+                hasNextPage
+              }
+              totalCount
+              edges {
+                node {
+                  id
+                  blockHeight
+                  txHash
+                  caller
+                  admin
+                  operator
+                  contractAddress
+                  circuitName
+                  timestamp
+                  votingStart
+                  votingEnd
+                  status
+                  period
+                  actionType
+                  roundTitle
+                  roundDescription
+                  roundLink
+                  coordinatorPubkeyX
+                  coordinatorPubkeyY
+                  voteOptionMap
+                  results
+                  allResult
+                  gasStationEnable
+                  totalGrant
+                  baseGrant
+                  totalBond
+                  circuitType
+                  circuitPower
+                  certificationSystem
+                  codeId
+                  maciType
+                  voiceCreditAmount
+                  preDeactivateRoot
+                }
+                cursor
+              }
+            }
+          }
+      `;
+
+      const roundsResponse =
+        await this.http.fetchGraphql<RoundsGraphqlResponse>(
+          ROUNDS_QUERY,
+          '',
+          9999
+        );
+      const roundContractAddresses =
+        roundsResponse?.data?.rounds?.edges?.map(
+          (edge) => edge.node.contractAddress
+        ) || [];
+
+      const TRANSACTIONS_QUERY = `query transactions($limit: Int, $after: Cursor) {
+        transactions(first: $limit, after: $after, 
+          filter: {
+            timestamp: { greaterThanOrEqualTo: "${txTimestamp}" },
+            type: { equalTo: "op:procDeactivate" },
+            contractAddress: { in: ${JSON.stringify(roundContractAddresses)} }
+          },
+          orderBy: [TIMESTAMP_DESC]
+        ){
+          pageInfo {
+            endCursor
+            hasNextPage
+          }
+          totalCount
+          edges {
+            cursor
+            node {
+              id
+              blockHeight
+              txHash
+              timestamp
+              type
+              status
+              circuitName
+              fee
+              gasUsed
+              gasWanted
+              caller
+              contractAddress
+            }
+          }
+        }
+      }`;
+
+      const [delayResponse, transactionsResponse] = await Promise.all([
+        this.http.fetchGraphql<OperatorDelayOperationsGraphqlResponse>(
+          QUERY,
+          '',
+          9999
+        ),
+        this.http.fetchGraphql<TransactionsGraphqlResponse>(
+          TRANSACTIONS_QUERY,
+          '',
+          9999
+        ),
+      ]);
+
+      const dailyStats = new Map<string, MissRateType>();
+
+      const endDate = new Date();
+      for (let i = 0; i < durationDay; i++) {
+        const date = new Date(endDate.getTime() - i * 24 * 60 * 60 * 1000)
+          .toISOString()
+          .split('T')[0];
+        dailyStats.set(date, {
+          delayCount: 0,
+          deactivateDelay: {
+            count: 0,
+            dmsgCount: 0,
+          },
+          tallyDelay: {
+            count: 0,
+          },
+          totalDelayDuration: 0,
+          avgDelayDuration: 0,
+          tallyCount: 0,
+          deactivateCount: 0,
+          missRate: 0,
+        });
+      }
+
+      delayResponse.data.operatorDelayOperations.edges.forEach(({ node }) => {
+        const date = new Date(parseInt(node.timestamp) * 1000)
+          .toISOString()
+          .split('T')[0];
+
+        if (dailyStats.has(date)) {
+          const stats = dailyStats.get(date)!;
+          stats.delayCount++;
+          stats.totalDelayDuration += parseInt(node.delayDuration);
+          if (node.delayType === 'deactivate_delay') {
+            stats.deactivateDelay.count++;
+            stats.deactivateDelay.dmsgCount += node.delayProcessDmsgCount;
+          } else if (node.delayType === 'tally_delay') {
+            stats.tallyDelay.count++;
+          }
+        }
+      });
+
+      if (roundsResponse?.data?.rounds?.edges) {
+        roundsResponse.data.rounds.edges.forEach(({ node }) => {
+          const date = new Date(parseInt(node.votingEnd) / 1000000)
+            .toISOString()
+            .split('T')[0];
+          if (dailyStats.has(date)) {
+            const stats = dailyStats.get(date)!;
+            stats.tallyCount++;
+          }
+        });
+      }
+
+      if (transactionsResponse?.data?.transactions?.edges) {
+        transactionsResponse.data.transactions.edges.forEach(({ node }) => {
+          const date = new Date(parseInt(node.timestamp))
+            .toISOString()
+            .split('T')[0];
+          if (dailyStats.has(date)) {
+            const stats = dailyStats.get(date)!;
+            stats.deactivateCount++;
+          }
+        });
+      }
+
+      return {
+        code: 200,
+        data: {
+          missRate: Array.from(dailyStats.entries())
+            .map(([date, stats]) => ({
+              date,
+              delayCount: stats.delayCount,
+              deactivateDelay: stats.deactivateDelay,
+              tallyDelay: stats.tallyDelay,
+              totalDelayDuration: stats.totalDelayDuration,
+              avgDelayDuration:
+                stats.delayCount > 0
+                  ? stats.totalDelayDuration / stats.delayCount
+                  : 0,
+              tallyCount: stats.tallyCount,
+              deactivateCount: stats.deactivateCount,
+              missRate:
+                stats.deactivateCount + stats.tallyCount > 0
+                  ? parseFloat(
+                      (
+                        (stats.deactivateDelay.count + stats.tallyDelay.count) /
+                        (stats.deactivateCount + stats.tallyCount)
+                      ).toFixed(2)
+                    )
+                  : 0,
+            }))
+            .sort((a, b) => b.date.localeCompare(a.date)),
+        },
+      };
+    } catch (error) {
+      return {
+        code: 404,
+        error: {
+          message: 'Query miss rate failed',
+          type: ERROR.ERROR_QUERY_MISS_RATE_FAILED,
+        },
+      };
+    }
+  }
 }