@dorafactory/maci-sdk 0.0.7 → 0.0.9

package/src/libs/maci/maci.ts

@@ -1,19 +1,258 @@
 import { OfflineSigner } from '@cosmjs/proto-signing';
 import { batchGenMessage, Circom, PublicKey, stringizing } from '../circom';
 import { Contract } from '../contract';
+import { Indexer } from '../indexer';
+import { OracleCertificate } from '../oracle-certificate';
 import {
   MsgExecuteContractEncodeObject,
   SigningCosmWasmClient,
 } from '@cosmjs/cosmwasm-stargate';
 import { GasPrice, calculateFee, StdFee } from '@cosmjs/stargate';
 import { MsgExecuteContract } from 'cosmjs-types/cosmwasm/wasm/v1/tx';
+import { CertificateEcosystem, ErrorResponse } from '../../types';
+import { SignatureResponse } from '../oracle-certificate/types';
+import { OracleWhitelistConfig } from '../contract/ts/OracleMaci.types';
+
+export function isErrorResponse(response: unknown): response is ErrorResponse {
+  return (
+    typeof response === 'object' &&
+    response !== null &&
+    'error' in response &&
+    typeof (response as ErrorResponse).error === 'object' &&
+    'message' in (response as ErrorResponse).error
+  );
+}
 
 export class MACI {
   public circom: Circom;
   public contract: Contract;
-  constructor({ circom, contract }: { circom: Circom; contract: Contract }) {
+  public indexer: Indexer;
+  public oracleCertificate: OracleCertificate;
+  constructor({
+    circom,
+    contract,
+    indexer,
+    oracleCertificate,
+  }: {
+    circom: Circom;
+    contract: Contract;
+    indexer: Indexer;
+    oracleCertificate: OracleCertificate;
+  }) {
     this.circom = circom;
     this.contract = contract;
+    this.indexer = indexer;
+    this.oracleCertificate = oracleCertificate;
+  }
+
+  async getStateIdxInc({
+    signer,
+    address,
+    contractAddress,
+  }: {
+    signer: OfflineSigner;
+    address: string;
+    contractAddress: string;
+  }) {
+    const client = await this.contract.maciClient({
+      signer,
+      contractAddress,
+    });
+
+    const stateIdx = await client.getStateIdxInc({ address });
+    return stateIdx;
+  }
+
+  async getVoiceCreditBalance({
+    signer,
+    stateIdx,
+    contractAddress,
+  }: {
+    signer: OfflineSigner;
+    stateIdx: number;
+    contractAddress: string;
+  }) {
+    const client = await this.contract.maciClient({
+      signer,
+      contractAddress,
+    });
+
+    const voiceCredit = await client.getVoiceCreditBalance({
+      index: stateIdx.toString(),
+    });
+    return voiceCredit;
+  }
+
+  async getStateIdxByPubKey({
+    contractAddress,
+    pubKey,
+  }: {
+    contractAddress: string;
+    pubKey: bigint[];
+  }) {
+    const response = await this.indexer.getSignUpEventByPubKey(
+      contractAddress,
+      pubKey
+    );
+
+    if (isErrorResponse(response)) {
+      return -1;
+    }
+    return response.data.signUpEvents[0].stateIdx;
+  }
+
+  // only for maci and oracle maci, amaci will set the voice credit when deploy the contract
+  async queryWhitelistBalanceOf({
+    signer,
+    address,
+    contractAddress,
+    certificate,
+    mode = 'maci',
+  }: {
+    signer: OfflineSigner;
+    address: string;
+    contractAddress: string;
+    certificate?: string;
+    mode?: 'maci' | 'amaci';
+  }): Promise<string> {
+    if (mode === 'amaci') {
+      const isWhiteListed = await this.isWhitelisted({
+        signer,
+        address,
+        contractAddress,
+      });
+
+      if (isWhiteListed) {
+        const round = await this.indexer.getRoundById(contractAddress);
+
+        if (!isErrorResponse(round)) {
+          return round.data.round.voiceCreditAmount;
+        } else {
+          throw new Error(
+            `Failed to query amaci voice credit: ${round.error.type}`
+          );
+        }
+      } else {
+        return '0';
+      }
+    }
+
+    if (certificate) {
+      const client = await this.contract.oracleMaciClient({
+        signer,
+        contractAddress,
+      });
+
+      const balance = await client.whiteBalanceOf({
+        amount: address,
+        certificate,
+        sender: address,
+      });
+
+      return balance;
+    } else {
+      const client = await this.contract.maciClient({
+        signer,
+        contractAddress,
+      });
+
+      const balance = await client.whiteBalanceOf({
+        sender: address,
+      });
+
+      return balance;
+    }
+  }
+
+  async isWhitelisted({
+    signer,
+    address,
+    contractAddress,
+  }: {
+    signer: OfflineSigner;
+    address: string;
+    contractAddress: string;
+  }) {
+    const client = await this.contract.amaciClient({
+      signer,
+      contractAddress,
+    });
+
+    const isWhitelisted = await client.isWhiteList({
+      sender: address,
+    });
+
+    return isWhitelisted;
+  }
+
+  async getOracleWhitelistConfig({
+    signer,
+    contractAddress,
+  }: {
+    signer: OfflineSigner;
+    contractAddress: string;
+  }): Promise<OracleWhitelistConfig> {
+    const client = await this.contract.oracleMaciClient({
+      signer,
+      contractAddress,
+    });
+
+    const snapshotHeight = await client.queryOracleWhitelistConfig();
+    return snapshotHeight;
+  }
+
+  async getRoundInfo({ contractAddress }: { contractAddress: string }) {
+    const roundInfo = await this.indexer.getRoundById(contractAddress);
+
+    if (isErrorResponse(roundInfo)) {
+      throw new Error(`Failed to get round info: ${roundInfo.error.type}`);
+    }
+
+    return roundInfo.data.round;
+  }
+
+  async getRoundCircuitType({ contractAddress }: { contractAddress: string }) {
+    const roundInfo = await this.getRoundInfo({ contractAddress });
+
+    return roundInfo.circuitType; // 0: 1p1v, 1: qv
+  }
+
+  async queryRoundIsQv({ contractAddress }: { contractAddress: string }) {
+    const circuitType = await this.getRoundCircuitType({ contractAddress });
+
+    return circuitType === '1';
+  }
+
+  async queryRoundGasStation({ contractAddress }: { contractAddress: string }) {
+    const roundInfo = await this.getRoundInfo({ contractAddress });
+
+    return roundInfo.gasStationEnable;
+  }
+
+  async requestOracleCertificate({
+    signer,
+    ecosystem,
+    address,
+    contractAddress,
+  }: {
+    signer: OfflineSigner;
+    ecosystem: CertificateEcosystem;
+    address: string;
+    contractAddress: string;
+  }): Promise<SignatureResponse> {
+    const oracleWhitelistConfig = await this.getOracleWhitelistConfig({
+      signer,
+      contractAddress,
+    });
+
+    const signResponse = await this.oracleCertificate.sign({
+      ecosystem,
+      address,
+      contractAddress,
+      height: oracleWhitelistConfig.snapshot_height,
+    });
+
+    return signResponse;
   }
 
   async signup({
@@ -40,7 +279,7 @@ export class MACI {
       });
 
       if (oracleCertificate) {
-        await this.signupOracle({
+        return await this.signupOracle({
           client,
           address,
           pubKey: maciAccount.pubKey,
@@ -49,7 +288,7 @@ export class MACI {
           gasStation,
         });
       } else {
-        await this.signupSimple({
+        return await this.signupSimple({
           client,
           address,
           pubKey: maciAccount.pubKey,
@@ -62,7 +301,46 @@ export class MACI {
     }
   }
 
-  submit = async ({
+  private async processVoteOptions({
+    selectedOptions,
+    contractAddress,
+    voiceCreditBalance,
+  }: {
+    selectedOptions: {
+      idx: number;
+      vc: number;
+    }[];
+    contractAddress: string;
+    voiceCreditBalance: string;
+  }) {
+    // Check for duplicate options
+    const idxSet = new Set();
+    for (const option of selectedOptions) {
+      if (idxSet.has(option.idx)) {
+        throw new Error(
+          `Duplicate option index (${option.idx}) is not allowed`
+        );
+      }
+      idxSet.add(option.idx);
+    }
+
+    // Filter and sort options
+    const options = selectedOptions
+      .filter((o) => !!o.vc)
+      .sort((a, b) => a.idx - b.idx);
+
+    // Calculate used voice credits
+    const isQv = await this.queryRoundIsQv({ contractAddress });
+    const usedVc = options.reduce((s, o) => s + (isQv ? o.vc * o.vc : o.vc), 0);
+
+    if (Number(voiceCreditBalance) < usedVc) {
+      throw new Error('Insufficient voice credit balance');
+    }
+
+    return options;
+  }
+
+  async vote({
     signer,
     address,
     stateIdx,
@@ -81,10 +359,24 @@ export class MACI {
     }[];
     operatorCoordPubKey: PublicKey;
     gasStation?: boolean;
-  }) => {
-    const options = selectedOptions.filter((o) => !!o.vc);
+  }) {
+    if (stateIdx === -1) {
+      throw new Error('State index is not set, Please signup first');
+    }
 
     try {
+      const voiceCreditBalance = await this.getVoiceCreditBalance({
+        signer,
+        stateIdx,
+        contractAddress,
+      });
+
+      const options = await this.processVoteOptions({
+        selectedOptions,
+        contractAddress,
+        voiceCreditBalance,
+      });
+
       const maciAccount = await this.circom.genKeypairFromSign(signer, address);
 
       const plan = options.map((o) => {
@@ -102,7 +394,7 @@ export class MACI {
         signer,
       });
 
-      await this.submitPlan({
+      return await this.publishMessage({
         client,
         address,
         payload,
@@ -110,11 +402,11 @@ export class MACI {
         gasStation,
       });
     } catch (error) {
-      throw Error(`Submit failed! ${error}`);
+      throw Error(`Vote failed! ${error}`);
     }
-  };
+  }
 
-  async submitPlan({
+  async publishMessage({
     client,
     address,
     payload,

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

@@ -1,49 +1,9 @@
-import {
-  BalanceResponse,
-  RoundResponse,
-  RoundsResponse,
-  OperatorResponse,
-  OperatorsResponse,
-  CircuitResponse,
-  TransactionResponse,
-  TransactionsResponse,
-  CircuitsResponse,
-  ProofResponse,
-} from '../../types';
 import { Http } from '../http';
 import {
-  Round,
-  UserAccount,
-  Circuit,
-  Operator,
-  Proof,
-  Transaction,
-} from '../query';
-import { handleError, ErrorType } from '../errors';
-import { ERROR } from '../errors/types';
-import { OracleCertificateParams } from './types';
-
-/**
- * @class Indexer
- * @description This class is used to interact with Maci Indexer.
- */
-export interface SignatureRequest {
-  address: string;
-  height: string;
-  contractAddress: string;
-  amount?: string;
-}
-
-export interface SignatureResponse {
-  code: number;
-  data?: {
-    signature: string;
-  };
-  error?: {
-    message: string;
-    type: string;
-  };
-}
+  OracleCertificateParams,
+  SignatureRequest,
+  SignatureResponse,
+} from './types';
 
 export class OracleCertificate {
   private certificateApiEndpoint: string;
@@ -55,36 +15,22 @@ export class OracleCertificate {
   }
 
   async sign(data: SignatureRequest): Promise<SignatureResponse> {
-    try {
-      const response = await fetch(
-        `${this.certificateApiEndpoint}/cosmoshub/sign`,
-        {
-          method: 'POST',
-          headers: {
-            'Content-Type': 'application/json',
-          },
-          body: JSON.stringify(data),
-        }
-      );
-
-      if (!response.ok) {
-        return {
-          code: response.status,
-          error: {
-            message: `Signature request failed: ${response.status} ${response.statusText}`,
-            type: 'error',
-          },
-        };
+    const response = await this.http.fetch(
+      `${this.certificateApiEndpoint}/${data.ecosystem}/sign`,
+      {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          address: data.address,
+          height: data.height,
+          contractAddress: data.contractAddress,
+        }),
       }
+    );
+    const signatureData = await response.json();
 
-      const signatureData = await response.json();
-
-      return {
-        code: 200,
-        data: signatureData,
-      };
-    } catch (error) {
-      return handleError(error as ErrorType);
-    }
+    return signatureData;
   }
 }

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

@@ -1,6 +1,20 @@
-import { FetchOptions, Http } from '../http/http';
+import { CertificateEcosystem } from '../../types';
+import { Http } from '../http/http';
 
 export type OracleCertificateParams = {
   certificateApiEndpoint: string;
   http: Http;
 };
+
+export type SignatureRequest = {
+  ecosystem: CertificateEcosystem;
+  address: string;
+  height: string;
+  contractAddress: string;
+};
+
+export type SignatureResponse = {
+  signature: string;
+  amount: string;
+  snapshotHeight: string;
+};

package/src/libs/query/event.ts

@@ -0,0 +1,78 @@
+import { Http } from '../../libs';
+import { SignUpEventsGraphqlResponse, SignUpEventsResponse } from '../../types';
+import { handleError, ErrorType } from '../errors';
+import { ERROR } from '../errors/types';
+
+export class Event {
+  public http: Http;
+
+  constructor(http: Http) {
+    this.http = http;
+  }
+
+  async getSignUpEventByPubKey(
+    contractAddress: string,
+    pubKey: bigint[]
+  ): Promise<SignUpEventsResponse> {
+    try {
+      const STATE_IDX_BY_PUB_KEY_QUERY = `
+query signUpEvents($limit: Int, $after: Cursor) {
+	signUpEvents(
+    first: $limit, after: $after,
+		filter: {
+			contractAddress: {
+				equalTo: "${contractAddress}"
+			}
+			pubKey: {
+				equalTo: "${pubKey.map((n) => `\\"${n}\\"`).join(',')}"
+			}
+		}) {
+		nodes {
+			id
+			blockHeight
+			txHash
+			contractAddress
+			timestamp
+			pubKey
+			stateIdx
+			balance
+		}
+	}
+}
+    `;
+
+      const response =
+        await this.http.fetchGraphql<SignUpEventsGraphqlResponse>(
+          STATE_IDX_BY_PUB_KEY_QUERY,
+          ''
+        );
+
+      if (
+        !response ||
+        !response.data ||
+        !response.data.signUpEvents ||
+        !response.data.signUpEvents.nodes ||
+        response.data.signUpEvents.nodes.length === 0
+      ) {
+        return {
+          code: 404,
+          error: {
+            message: `No signUpEvents found for pubKey ${pubKey
+              .map((n) => `"${n}"`)
+              .join(',')}`,
+            type: ERROR.ERROR_SIGN_UP_EVENTS_NOT_FOUND,
+          },
+        };
+      }
+
+      return {
+        code: 200,
+        data: {
+          signUpEvents: response.data.signUpEvents.nodes,
+        },
+      };
+    } catch (error: any) {
+      return handleError(error as ErrorType);
+    }
+  }
+}

package/src/libs/query/index.ts

@@ -4,3 +4,4 @@ export { Operator } from './operator';
 export { Round } from './round';
 export { Transaction } from './transaction';
 export { Proof } from './proof';
+export { Event } from './event';

package/src/maci.ts

@@ -11,7 +11,14 @@ import {
   CircuitsResponse,
   ProofResponse,
 } from './types';
-import { Http, Indexer, Contract } from './libs';
+import {
+  Http,
+  Indexer,
+  Contract,
+  OracleCertificate,
+  Circom,
+  MACI,
+} from './libs';
 import { getDefaultParams } from './libs/const';
 import {
   CreateAMaciRoundParams,
@@ -19,7 +26,6 @@ import {
   CreateOracleMaciRoundParams,
 } from './libs/contract/types';
 import { OfflineSigner } from '@cosmjs/proto-signing';
-import { Circom } from './libs/circom';
 
 /**
  * @class MaciClient
@@ -29,17 +35,20 @@ export class MaciClient {
   public rpcEndpoint: string;
   public restEndpoint: string;
   public apiEndpoint: string;
+  public certificateApiEndpoint: string;
+
   public registryAddress: string;
   public maciCodeId: number;
   public oracleCodeId: number;
+  public feegrantOperator: string;
+  public whitelistBackendPubkey: string;
 
   public http: Http;
   public indexer: Indexer;
   public contract: Contract;
   public circom: Circom;
-
-  public feegrantOperator: string;
-  public whitelistBackendPubkey: string;
+  public oracleCertificate: OracleCertificate;
+  public maci: MACI;
 
   /**
    * @constructor
@@ -57,12 +66,15 @@ export class MaciClient {
     defaultOptions,
     feegrantOperator,
     whitelistBackendPubkey,
+    certificateApiEndpoint,
   }: ClientParams) {
     const defaultParams = getDefaultParams(network);
 
     this.rpcEndpoint = rpcEndpoint || defaultParams.rpcEndpoint;
     this.restEndpoint = restEndpoint || defaultParams.restEndpoint;
     this.apiEndpoint = apiEndpoint || defaultParams.apiEndpoint;
+    this.certificateApiEndpoint =
+      certificateApiEndpoint || defaultParams.certificateApiEndpoint;
     this.registryAddress = registryAddress || defaultParams.registryAddress;
     this.maciCodeId = maciCodeId || defaultParams.maciCodeId;
     this.oracleCodeId = oracleCodeId || defaultParams.oracleCodeId;
@@ -92,6 +104,16 @@ export class MaciClient {
       whitelistBackendPubkey: this.whitelistBackendPubkey,
     });
     this.circom = new Circom({ network });
+    this.oracleCertificate = new OracleCertificate({
+      certificateApiEndpoint: this.certificateApiEndpoint,
+      http: this.http,
+    });
+    this.maci = new MACI({
+      circom: this.circom,
+      contract: this.contract,
+      indexer: this.indexer,
+      oracleCertificate: this.oracleCertificate,
+    });
   }
 
   async oracleMaciClient({

package/src/types/index.ts

@@ -17,11 +17,14 @@ export enum MaciRoundType {
   ORACLE_MACI = '2',
 }
 
+export type CertificateEcosystem = 'cosmoshub' | 'doravota';
+
 export type ClientParams = {
   network: 'mainnet' | 'testnet';
   rpcEndpoint?: string;
   restEndpoint?: string;
   apiEndpoint?: string;
+  certificateApiEndpoint?: string;
   registryAddress?: string;
   maciCodeId?: number;
   oracleCodeId?: number;
@@ -133,6 +136,17 @@ export type CircuitType = {
   roundCount?: number;
 };
 
+export type SignUpEventType = {
+  id: string;
+  blockHeight: string;
+  txHash: string;
+  contractAddress: string;
+  timestamp: string;
+  pubKey: string;
+  stateIdx: number;
+  balance: string;
+};
+
 export type CircuitsCountGraphqlResponse = {
   data: {
     rounds: {
@@ -320,3 +334,17 @@ export type ProofGraphqlResponse = {
     proofData: ProofType;
   };
 };
+
+export type SignUpEventsResponse =
+  | SuccessResponse<{
+      signUpEvents: SignUpEventType[];
+    }>
+  | ErrorResponse;
+
+export type SignUpEventsGraphqlResponse = {
+  data: {
+    signUpEvents: {
+      nodes: SignUpEventType[];
+    };
+  };
+};