@dorafactory/maci-sdk 0.0.19 → 0.0.21

package/dist/index.js

@@ -256,11 +256,12 @@ var Http = class {
       );
     }
   }
-  async fetchRest(path) {
+  async fetchRest(path, options) {
     try {
       const fetchFn = this.getFetch();
       const response = await fetchFn(`${this.restEndpoint}${path}`, {
-        ...this.defaultOptions
+        ...this.defaultOptions,
+        ...options
       });
       if (!response.ok) {
         throw new HttpError(
@@ -291,6 +292,8 @@ var 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",
@@ -717,6 +720,64 @@ var Operator = class {
       return handleError(error);
     }
   }
+  async getOperatorDelayOperationsByAddress(address, after, limit) {
+    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(
+        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 = {
+        code: 200,
+        data: response.data
+      };
+      return operator;
+    } catch (error) {
+      return handleError(error);
+    }
+  }
   async getOperators(after, limit) {
     try {
       const OPERATORS_QUERY = `query ($limit: Int, $after: Cursor) {
@@ -820,6 +881,228 @@ var Operator = class {
       return handleError(error);
     }
   }
+  async queryMissRate(address, durationDay) {
+    try {
+      const now = /* @__PURE__ */ new Date();
+      const startTime = new Date(
+        now.getTime() - durationDay * 24 * 60 * 60 * 1e3
+      );
+      const startTimestamp = Math.floor(startTime.getTime() / 1e3);
+      const endNanosTimestamp = Math.floor(startTime.getTime() * 1e6);
+      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(
+        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(
+          QUERY,
+          "",
+          9999
+        ),
+        this.http.fetchGraphql(
+          TRANSACTIONS_QUERY,
+          "",
+          9999
+        )
+      ]);
+      const dailyStats = /* @__PURE__ */ new Map();
+      const endDate = /* @__PURE__ */ new Date();
+      for (let i = 0; i < durationDay; i++) {
+        const date = new Date(endDate.getTime() - i * 24 * 60 * 60 * 1e3).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) * 1e3).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) / 1e6).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
+        }
+      };
+    }
+  }
 };
 
 // src/libs/query/round.ts
@@ -1647,6 +1930,16 @@ var Indexer = class {
   async getOperatorByAddress(address) {
     return await this.operator.getOperatorByAddress(address);
   }
+  async getOperatorDelayOperationsByAddress(address, after, limit) {
+    return await this.operator.getOperatorDelayOperationsByAddress(
+      address,
+      after,
+      limit
+    );
+  }
+  async queryMissRate(address, durationDay) {
+    return await this.operator.queryMissRate(address, durationDay);
+  }
   /**
    * @method getOperators
    * @description Get multiple operators.
@@ -3783,7 +4076,7 @@ function getContractParams(type, circuitType, proofSystem, maxVoter, maxOption)
         `Invalid proof system ${proofSystem}, only support GROTH16 and PLONK`
       );
   }
-  if (Number(maxVoter) <= 25 && Number(maxOption) <= 5) {
+  if (maxVoter <= 25 && maxOption <= 5) {
     parameters = CIRCUIT_INFO["2-1-1-5"].parameter;
     if (proofSystem === "groth16" /* GROTH16 */) {
       groth16ProcessVkey = CIRCUIT_INFO["2-1-1-5"]["groth16"].process_vkey;
@@ -3792,7 +4085,7 @@ function getContractParams(type, circuitType, proofSystem, maxVoter, maxOption)
       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) {
     parameters = CIRCUIT_INFO["4-2-2-25"].parameter;
     if (proofSystem === "groth16" /* GROTH16 */) {
       groth16ProcessVkey = CIRCUIT_INFO["4-2-2-25"]["groth16"].process_vkey;
@@ -3801,7 +4094,7 @@ function getContractParams(type, circuitType, proofSystem, maxVoter, maxOption)
       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) {
     parameters = CIRCUIT_INFO["6-3-3-125"].parameter;
     if (proofSystem === "groth16" /* GROTH16 */) {
       groth16ProcessVkey = CIRCUIT_INFO["6-3-3-125"]["groth16"].process_vkey;
@@ -3810,7 +4103,7 @@ function getContractParams(type, circuitType, proofSystem, maxVoter, maxOption)
       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) {
     parameters = CIRCUIT_INFO["9-4-3-625"].parameter;
     if (proofSystem === "groth16" /* GROTH16 */) {
       if (circuitType === "0" /* IP1V */) {
@@ -3864,6 +4157,20 @@ function getContractParams(type, circuitType, proofSystem, maxVoter, maxOption)
       };
   }
 }
+function getAMaciRoundCircuitFee(maxVoter, maxOption) {
+  let requiredFee = {
+    denom: "peaka",
+    amount: "0"
+  };
+  if (maxVoter <= 25 && maxOption <= 5) {
+    requiredFee.amount = "50000000000000000000";
+  } else if (maxVoter <= 625 && maxOption <= 25) {
+    requiredFee.amount = "100000000000000000000";
+  } else {
+    throw new Error("Number of voters or options is too large.");
+  }
+  return requiredFee;
+}
 
 // src/libs/contract/contract.ts
 var Contract = class {
@@ -3904,26 +4211,32 @@ var Contract = class {
       wallet: signer,
       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",
+      void 0,
+      [requiredFee]
+    );
     let contractAddress = "";
     res.events.map((event) => {
       if (event.type === "wasm") {
@@ -4023,8 +4336,8 @@ var Contract = class {
       "2" /* ORACLE_MACI */,
       circuitType,
       "groth16" /* GROTH16 */,
-      "0",
-      "0"
+      0,
+      0
     );
     const instantiateResponse = await client.instantiate(
       address,
@@ -4135,6 +4448,16 @@ var OracleCertificate = class {
     const signatureData = await response.json();
     return signatureData;
   }
+  async feegrantAllowance(granter, grantee) {
+    const response = await this.http.fetchRest(
+      `/cosmos/feegrant/v1beta1/allowance/${granter}/${grantee}`
+    );
+    return {
+      granter,
+      grantee,
+      spend_limit: response.allowance.allowance.allowance.spend_limit
+    };
+  }
 };
 
 // src/libs/circom/index.ts
@@ -4460,6 +4783,24 @@ var MACI = class {
     }
     return response.data.signUpEvents[0].stateIdx;
   }
+  async feegrantAllowance({
+    address,
+    contractAddress
+  }) {
+    try {
+      const response = await this.oracleCertificate.feegrantAllowance(
+        contractAddress,
+        address
+      );
+      return response;
+    } catch (error) {
+      return {
+        granter: contractAddress,
+        grantee: address,
+        spend_limit: []
+      };
+    }
+  }
   // only for maci and oracle maci, amaci will set the voice credit when deploy the contract
   async queryWhitelistBalanceOf({
     signer,
@@ -4551,6 +4892,50 @@ var MACI = class {
     const circuitType = await this.getRoundCircuitType({ contractAddress });
     return circuitType === "1";
   }
+  async queryRoundClaimable({
+    contractAddress
+  }) {
+    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 = /* @__PURE__ */ new Date();
+      const threeDaysInMs = 3 * 24 * 60 * 60 * 1e3;
+      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 }) {
     const roundInfo = await this.getRoundInfo({ contractAddress });
     return roundInfo.gasStationEnable;