@dorafactory/maci-sdk 0.0.19 → 0.0.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dorafactory/maci-sdk",
-  "version": "0.0.19",
+  "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/http/http.ts

@@ -116,11 +116,12 @@ export class Http {
     }
   }
 
-  async fetchRest(path: string): Promise<any> {
+  async fetchRest(path: string, options?: any): Promise<any> {
     try {
       const fetchFn = this.getFetch();
       const response = await fetchFn(`${this.restEndpoint}${path}`, {
         ...this.defaultOptions,
+        ...options,
       });
 
       if (!response.ok) {

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

@@ -107,6 +107,28 @@ export class MACI {
     return response.data.signUpEvents[0].stateIdx;
   }
 
+  async feegrantAllowance({
+    address,
+    contractAddress,
+  }: {
+    address: string;
+    contractAddress: string;
+  }) {
+    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,
@@ -231,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/oracle-certificate/oracle-certificate.ts

@@ -3,6 +3,7 @@ import {
   OracleCertificateParams,
   SignatureRequest,
   SignatureResponse,
+  FeegrantAllowanceResponse,
 } from './types';
 
 export class OracleCertificate {
@@ -33,4 +34,19 @@ export class OracleCertificate {
 
     return signatureData;
   }
+
+  async feegrantAllowance(
+    granter: string,
+    grantee: string
+  ): Promise<FeegrantAllowanceResponse> {
+    const response = await this.http.fetchRest(
+      `/cosmos/feegrant/v1beta1/allowance/${granter}/${grantee}`
+    );
+
+    return {
+      granter,
+      grantee,
+      spend_limit: response.allowance.allowance.allowance.spend_limit,
+    };
+  }
 }

package/src/libs/oracle-certificate/types.ts

@@ -18,3 +18,12 @@ export type SignatureResponse = {
   amount: string;
   snapshotHeight: string;
 };
+
+export type FeegrantAllowanceResponse = {
+  granter: string;
+  grantee: string;
+  spend_limit: {
+    denom: string;
+    amount: string;
+  }[];
+};