@dorafactory/maci-sdk 0.1.2 → 0.1.3-pre.10

package/src/libs/contract/ts/Registry.client.ts

@@ -17,12 +17,14 @@ import {
   Uint256,
   Timestamp,
   Uint64,
+  Decimal,
   PubKey,
   RoundInfo,
   VotingTime,
-  Whitelist,
-  WhitelistConfig,
+  WhitelistBase,
+  WhitelistBaseConfig,
   ValidatorSet,
+  CircuitChargeConfig,
   QueryMsg,
   AdminResponse,
   String,
@@ -38,6 +40,7 @@ export interface RegistryReadOnlyInterface {
   getValidatorOperator: ({ address }: { address: Addr }) => Promise<Addr>;
   getMaciOperatorPubkey: ({ address }: { address: Addr }) => Promise<PubKey>;
   getMaciOperatorIdentity: ({ address }: { address: Addr }) => Promise<String>;
+  getCircuitChargeConfig: () => Promise<CircuitChargeConfig>;
 }
 export class RegistryQueryClient implements RegistryReadOnlyInterface {
   client: CosmWasmClient;
@@ -53,6 +56,7 @@ export class RegistryQueryClient implements RegistryReadOnlyInterface {
     this.getValidatorOperator = this.getValidatorOperator.bind(this);
     this.getMaciOperatorPubkey = this.getMaciOperatorPubkey.bind(this);
     this.getMaciOperatorIdentity = this.getMaciOperatorIdentity.bind(this);
+    this.getCircuitChargeConfig = this.getCircuitChargeConfig.bind(this);
   }
   admin = async (): Promise<AdminResponse> => {
     return this.client.queryContractSmart(this.contractAddress, {
@@ -116,6 +120,11 @@ export class RegistryQueryClient implements RegistryReadOnlyInterface {
       },
     });
   };
+  getCircuitChargeConfig = async (): Promise<CircuitChargeConfig> => {
+    return this.client.queryContractSmart(this.contractAddress, {
+      get_circuit_charge_config: {},
+    });
+  };
 }
 export interface RegistryInterface extends RegistryReadOnlyInterface {
   contractAddress: string;
@@ -154,25 +163,27 @@ export interface RegistryInterface extends RegistryReadOnlyInterface {
     {
       certificationSystem,
       circuitType,
-      maxOption,
       maxVoter,
       operator,
+      oracleWhitelistPubkey,
       preDeactivateRoot,
       roundInfo,
       voiceCreditAmount,
+      voteOptionMap,
       votingTime,
       whitelist,
     }: {
       certificationSystem: Uint256;
       circuitType: Uint256;
-      maxOption: Uint256;
       maxVoter: Uint256;
       operator: Addr;
+      oracleWhitelistPubkey?: string;
       preDeactivateRoot: Uint256;
       roundInfo: RoundInfo;
       voiceCreditAmount: Uint256;
+      voteOptionMap: string[];
       votingTime: VotingTime;
-      whitelist?: Whitelist;
+      whitelist?: WhitelistBase;
     },
     fee?: number | StdFee | 'auto',
     memo?: string,
@@ -218,6 +229,16 @@ export interface RegistryInterface extends RegistryReadOnlyInterface {
     memo?: string,
     _funds?: Coin[]
   ) => Promise<ExecuteResult>;
+  changeChargeConfig: (
+    {
+      config,
+    }: {
+      config: CircuitChargeConfig;
+    },
+    fee?: number | StdFee | 'auto',
+    memo?: string,
+    _funds?: Coin[]
+  ) => Promise<ExecuteResult>;
 }
 export class RegistryClient
   extends RegistryQueryClient
@@ -243,6 +264,7 @@ export class RegistryClient
     this.removeValidator = this.removeValidator.bind(this);
     this.updateAmaciCodeId = this.updateAmaciCodeId.bind(this);
     this.changeOperator = this.changeOperator.bind(this);
+    this.changeChargeConfig = this.changeChargeConfig.bind(this);
   }
   setMaciOperator = async (
     {
@@ -317,25 +339,27 @@ export class RegistryClient
     {
       certificationSystem,
       circuitType,
-      maxOption,
       maxVoter,
       operator,
+      oracleWhitelistPubkey,
       preDeactivateRoot,
       roundInfo,
       voiceCreditAmount,
+      voteOptionMap,
       votingTime,
       whitelist,
     }: {
       certificationSystem: Uint256;
       circuitType: Uint256;
-      maxOption: Uint256;
       maxVoter: Uint256;
       operator: Addr;
+      oracleWhitelistPubkey?: string;
       preDeactivateRoot: Uint256;
       roundInfo: RoundInfo;
       voiceCreditAmount: Uint256;
+      voteOptionMap: string[];
       votingTime: VotingTime;
-      whitelist?: Whitelist;
+      whitelist?: WhitelistBase;
     },
     fee: number | StdFee | 'auto' = 'auto',
     memo?: string,
@@ -348,12 +372,13 @@ export class RegistryClient
         create_round: {
           certification_system: certificationSystem,
           circuit_type: circuitType,
-          max_option: maxOption,
           max_voter: maxVoter,
           operator,
+          oracle_whitelist_pubkey: oracleWhitelistPubkey,
           pre_deactivate_root: preDeactivateRoot,
           round_info: roundInfo,
           voice_credit_amount: voiceCreditAmount,
+          vote_option_map: voteOptionMap,
           voting_time: votingTime,
           whitelist,
         },
@@ -455,4 +480,27 @@ export class RegistryClient
       _funds
     );
   };
+  changeChargeConfig = async (
+    {
+      config,
+    }: {
+      config: CircuitChargeConfig;
+    },
+    fee: number | StdFee | 'auto' = 'auto',
+    memo?: string,
+    _funds?: Coin[]
+  ): Promise<ExecuteResult> => {
+    return await this.client.execute(
+      this.sender,
+      this.contractAddress,
+      {
+        change_charge_config: {
+          config,
+        },
+      },
+      fee,
+      memo,
+      _funds
+    );
+  };
 }

package/src/libs/contract/ts/Registry.types.ts

@@ -30,14 +30,15 @@ export type ExecuteMsg =
       create_round: {
         certification_system: Uint256;
         circuit_type: Uint256;
-        max_option: Uint256;
         max_voter: Uint256;
         operator: Addr;
+        oracle_whitelist_pubkey?: string | null;
         pre_deactivate_root: Uint256;
         round_info: RoundInfo;
         voice_credit_amount: Uint256;
+        vote_option_map: string[];
         voting_time: VotingTime;
-        whitelist?: Whitelist | null;
+        whitelist?: WhitelistBase | null;
       };
     }
   | {
@@ -59,10 +60,16 @@ export type ExecuteMsg =
       change_operator: {
         address: Addr;
       };
+    }
+  | {
+      change_charge_config: {
+        config: CircuitChargeConfig;
+      };
     };
 export type Uint256 = string;
 export type Timestamp = Uint64;
 export type Uint64 = string;
+export type Decimal = string;
 export interface PubKey {
   x: Uint256;
   y: Uint256;
@@ -76,15 +83,18 @@ export interface VotingTime {
   end_time: Timestamp;
   start_time: Timestamp;
 }
-export interface Whitelist {
-  users: WhitelistConfig[];
+export interface WhitelistBase {
+  users: WhitelistBaseConfig[];
 }
-export interface WhitelistConfig {
+export interface WhitelistBaseConfig {
   addr: Addr;
 }
 export interface ValidatorSet {
   addresses: Addr[];
 }
+export interface CircuitChargeConfig {
+  fee_rate: Decimal;
+}
 export type QueryMsg =
   | {
       admin: {};
@@ -119,6 +129,9 @@ export type QueryMsg =
       get_maci_operator_identity: {
         address: Addr;
       };
+    }
+  | {
+      get_circuit_charge_config: {};
     };
 export interface AdminResponse {
   admin: Addr;

package/src/libs/contract/types.ts

@@ -1,7 +1,7 @@
 import { OfflineSigner } from '@cosmjs/proto-signing';
 import { StdFee } from '@cosmjs/amino';
 
-import { Whitelist as RegistryWhitelist } from './ts/Registry.types';
+import { WhitelistBase as RegistryWhitelist } from './ts/Registry.types';
 import { Whitelist as MaciWhitelist } from './ts/Maci.types';
 import {
   MaciCircuitType,
@@ -22,11 +22,12 @@ export type CreateRoundParams = {
 
 export type CreateAMaciRoundParams = {
   maxVoter: number;
-  maxOption: number;
+  voteOptionMap: string[];
   operator: string;
-  whitelist: RegistryWhitelist;
+  whitelist?: RegistryWhitelist;
   voiceCreditAmount: string;
   preDeactivateRoot?: string;
+  oracleWhitelistPubkey?: string;
 } & CreateRoundParams;
 
 export type CreateMaciRoundParams = {
@@ -58,3 +59,15 @@ export type CreateSaasOracleMaciRoundParams = {
   gasStation?: boolean;
   fee?: StdFee | 'auto' | number;
 } & CreateRoundParams;
+
+export type CreateApiSaasAmaciRoundParams = {
+  maxVoter: number;
+  voteOptionMap: string[];
+  operator: string;
+  whitelist?: RegistryWhitelist;
+  voiceCreditAmount: string;
+  preDeactivateRoot?: string;
+  oracleWhitelistPubkey?: string;
+  gasStation?: boolean;
+  fee?: StdFee | 'auto' | number;
+} & CreateRoundParams;

package/src/libs/crypto/bigintUtils.ts

@@ -29,3 +29,31 @@ export const bigInt2Buffer = (i: bigint) => {
   }
   return Buffer.from(hex, 'hex');
 };
+
+export const buffer2Bigint = (buffer: Buffer | Uint8Array): bigint => {
+  const buf = Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer);
+  const hex = buf.toString('hex');
+  return BigInt('0x' + hex);
+};
+
+export const destringizing = (
+  o: MixedData<string>,
+  path: MixedData<string>[] = []
+): MixedData<bigint> => {
+  if (path.includes(o)) {
+    throw new Error('loop nesting!');
+  }
+  const newPath = [...path, o];
+
+  if (Array.isArray(o)) {
+    return o.map((item) => destringizing(item, newPath));
+  } else if (typeof o === 'object' && o !== null) {
+    const output: { [key: string]: MixedData<bigint> } = {};
+    for (const key in o) {
+      output[key] = destringizing(o[key], newPath);
+    }
+    return output;
+  } else {
+    return BigInt(o);
+  }
+};

package/src/libs/maci/maci.ts

@@ -469,7 +469,7 @@ export class MACI {
     contractAddress: string;
     maciKeypair?: Keypair;
     oracleCertificate?: {
-      amount: string;
+      amount?: string;
       signature: string;
     };
     gasStation?: boolean;
@@ -489,23 +489,93 @@ export class MACI {
         signer,
       });
 
-      if (oracleCertificate) {
+      // If oracleCertificate has data and amount has data, use signupOracle
+      if (oracleCertificate && oracleCertificate.amount) {
         return await this.signupOracle({
           client,
           address,
           pubKey: maciKeypair.pubKey,
           contractAddress,
-          oracleCertificate,
+          oracleCertificate: {
+            amount: oracleCertificate.amount,
+            signature: oracleCertificate.signature,
+          },
           gasStation,
           fee,
         });
       } else {
+        // If oracleCertificate has data but amount is missing, or oracleCertificate is missing, use signupSimple
         return await this.signupSimple({
           client,
           address,
           pubKey: maciKeypair.pubKey,
           contractAddress,
+          certificate: oracleCertificate?.signature,
+          gasStation,
+          fee,
+        });
+      }
+    } catch (error) {
+      throw Error(`Signup failed! ${error}`);
+    }
+  }
+
+  async rawSignup({
+    signer,
+    address,
+    contractAddress,
+    pubKey,
+    oracleCertificate,
+    gasStation = false,
+    granter,
+    fee,
+  }: {
+    signer: OfflineSigner;
+    address?: string;
+    contractAddress: string;
+    pubKey: PubKey;
+    oracleCertificate?: {
+      amount?: string;
+      signature: string;
+    };
+    gasStation?: boolean;
+    granter?: string;
+    fee?: StdFee | 'auto' | number;
+  }) {
+    try {
+      if (!address) {
+        address = (await signer.getAccounts())[0].address;
+      }
+
+      const client = await this.contract.contractClient({
+        signer,
+      });
+
+      // If oracleCertificate has data and amount has data, use signupOracle
+      if (oracleCertificate && oracleCertificate.amount) {
+        return await this.signupOracle({
+          client,
+          address,
+          pubKey,
+          contractAddress,
+          oracleCertificate: {
+            amount: oracleCertificate.amount,
+            signature: oracleCertificate.signature,
+          },
+          gasStation,
+          granter,
+          fee,
+        });
+      } else {
+        // If oracleCertificate has data but amount is missing, or oracleCertificate is missing, use signupSimple
+        return await this.signupSimple({
+          client,
+          address,
+          pubKey,
+          contractAddress,
+          certificate: oracleCertificate?.signature,
           gasStation,
+          granter,
           fee,
         });
       }
@@ -673,12 +743,115 @@ export class MACI {
     }
   }
 
+  async rawVote({
+    signer,
+    address,
+    contractAddress,
+    pubKey,
+    payload,
+    gasStation = false,
+    granter,
+    fee = 1.8,
+  }: {
+    signer: OfflineSigner;
+    address?: string;
+    contractAddress: string;
+    pubKey: PubKey;
+    payload: {
+      msg: bigint[];
+      encPubkeys: PubKey;
+    }[];
+    gasStation?: boolean;
+    granter?: string;
+    fee?: StdFee | 'auto' | number;
+  }) {
+    const stateIdx = await this.getStateIdxByPubKey({
+      contractAddress,
+      pubKey,
+    });
+
+    if (stateIdx === -1) {
+      throw new Error(
+        'State index is not set, Please signup or addNewKey first'
+      );
+    }
+
+    try {
+      const round = await this.indexer.getRoundWithFields(contractAddress, [
+        'maciType',
+        'voiceCreditAmount',
+      ]);
+
+      if (isErrorResponse(round)) {
+        throw new Error(
+          `Failed to get round info: ${round.error.type} ${round.error.message}`
+        );
+      }
+
+      let voiceCreditBalance;
+      if (round.data.round.maciType === 'aMACI') {
+        const isWhiteListed = await this.isWhitelisted({
+          signer,
+          address,
+          contractAddress,
+        });
+
+        if (isWhiteListed) {
+          const round = await this.indexer.getRoundWithFields(contractAddress, [
+            'voiceCreditAmount',
+          ]);
+
+          if (!isErrorResponse(round)) {
+            if (round.data.round.voiceCreditAmount) {
+              voiceCreditBalance = round.data.round.voiceCreditAmount;
+            } else {
+              voiceCreditBalance = '0';
+            }
+          } else {
+            throw new Error(
+              `Failed to query amaci voice credit: ${round.error.type} ${round.error.message}`
+            );
+          }
+        } else {
+          voiceCreditBalance = '0';
+        }
+      } else {
+        voiceCreditBalance = await this.getVoiceCreditBalance({
+          signer,
+          stateIdx,
+          contractAddress,
+        });
+      }
+
+      if (!address) {
+        address = (await signer.getAccounts())[0].address;
+      }
+
+      const client = await this.contract.contractClient({
+        signer,
+      });
+
+      return await this.publishMessage({
+        client,
+        address,
+        payload,
+        contractAddress,
+        gasStation,
+        granter,
+        fee,
+      });
+    } catch (error) {
+      throw Error(`Vote failed! ${error}`);
+    }
+  }
+
   async publishMessage({
     client,
     address,
     payload,
     contractAddress,
     gasStation,
+    granter,
     fee = 1.8,
   }: {
     client: SigningCosmWasmClient;
@@ -689,6 +862,7 @@ export class MACI {
     }[];
     contractAddress: string;
     gasStation: boolean;
+    granter?: string;
     fee?: StdFee | 'auto' | number;
   }) {
     const msgs: MsgExecuteContractEncodeObject[] = payload.map(
@@ -728,14 +902,14 @@ export class MACI {
       const grantFee: StdFee = {
         amount: calculatedFee.amount,
         gas: calculatedFee.gas,
-        granter: contractAddress,
+        granter: granter || contractAddress,
       };
       return client.signAndBroadcast(address, msgs, grantFee);
     } else if (gasStation && typeof fee === 'object') {
       // When gasStation is true and fee is StdFee, add granter
       const grantFee: StdFee = {
         ...fee,
-        granter: contractAddress,
+        granter: granter || contractAddress,
       };
       return client.signAndBroadcast(address, msgs, grantFee);
     }
@@ -748,18 +922,23 @@ export class MACI {
     address,
     pubKey,
     contractAddress,
+    certificate,
     gasStation,
+    granter,
     fee = 1.8,
   }: {
     client: SigningCosmWasmClient;
     address: string;
     pubKey: PubKey;
     contractAddress: string;
+    certificate?: string;
     gasStation?: boolean;
+    granter?: string;
     fee?: StdFee | 'auto' | number;
   }) {
     const msg = {
       sign_up: {
+        certificate,
         pubkey: {
           x: pubKey[0].toString(),
           y: pubKey[1].toString(),
@@ -792,14 +971,14 @@ export class MACI {
       const grantFee: StdFee = {
         amount: calculatedFee.amount,
         gas: calculatedFee.gas,
-        granter: contractAddress,
+        granter: granter || contractAddress,
       };
       return client.execute(address, contractAddress, msg, grantFee);
     } else if (gasStation === true && typeof fee === 'object') {
       // When gasStation is true and fee is StdFee, add granter
       const grantFee: StdFee = {
         ...fee,
-        granter: contractAddress,
+        granter: granter || contractAddress,
       };
       return client.execute(address, contractAddress, msg, grantFee);
     }
@@ -814,6 +993,7 @@ export class MACI {
     contractAddress,
     oracleCertificate,
     gasStation,
+    granter,
     fee = 1.8,
   }: {
     client: SigningCosmWasmClient;
@@ -825,6 +1005,7 @@ export class MACI {
       signature: string;
     };
     gasStation?: boolean;
+    granter?: string;
     fee?: StdFee | 'auto' | number;
   }) {
     const msg = {
@@ -863,14 +1044,14 @@ export class MACI {
       const grantFee: StdFee = {
         amount: calculatedFee.amount,
         gas: calculatedFee.gas,
-        granter: contractAddress,
+        granter: granter || contractAddress,
       };
       return client.execute(address, contractAddress, msg, grantFee);
     } else if (gasStation === true && typeof fee === 'object') {
       // When gasStation is true and fee is StdFee, add granter
       const grantFee: StdFee = {
         ...fee,
-        granter: contractAddress,
+        granter: granter || contractAddress,
       };
       return client.execute(address, contractAddress, msg, grantFee);
     }