@dorafactory/maci-sdk 0.0.35 → 0.0.37

package/dist/libs/maci/maci.d.ts

@@ -0,0 +1,182 @@
+import { OfflineSigner } from '@cosmjs/proto-signing';
+import { Keypair, PubKey } from '../crypto';
+import { Contract } from '../contract';
+import { Indexer } from '../indexer';
+import { OracleCertificate } from '../oracle-certificate';
+import { SigningCosmWasmClient } from '@cosmjs/cosmwasm-stargate';
+import { CertificateEcosystem, ErrorResponse, RoundType } from '../../types';
+import { SignatureResponse } from '../oracle-certificate/types';
+import { OracleWhitelistConfig } from '../contract/ts/OracleMaci.types';
+export declare function isErrorResponse(response: unknown): response is ErrorResponse;
+export declare class MACI {
+    contract: Contract;
+    indexer: Indexer;
+    oracleCertificate: OracleCertificate;
+    maciKeypair: Keypair;
+    constructor({ contract, indexer, oracleCertificate, maciKeypair, }: {
+        contract: Contract;
+        indexer: Indexer;
+        oracleCertificate: OracleCertificate;
+        maciKeypair: Keypair;
+    });
+    getStateIdxInc({ signer, address, contractAddress, }: {
+        signer: OfflineSigner;
+        address?: string;
+        contractAddress: string;
+    }): Promise<string>;
+    getVoiceCreditBalance({ signer, stateIdx, contractAddress, }: {
+        signer: OfflineSigner;
+        stateIdx: number;
+        contractAddress: string;
+    }): Promise<string>;
+    getStateIdxByPubKey({ contractAddress, pubKey, }: {
+        contractAddress: string;
+        pubKey: bigint[];
+    }): Promise<number>;
+    feegrantAllowance({ address, contractAddress, }: {
+        address: string;
+        contractAddress: string;
+    }): Promise<import("../oracle-certificate/types").FeegrantAllowanceResponse>;
+    hasFeegrant({ address, contractAddress, }: {
+        address: string;
+        contractAddress: string;
+    }): Promise<boolean>;
+    queryWhitelistBalanceOf({ signer, address, contractAddress, certificate, mode, }: {
+        signer: OfflineSigner;
+        address?: string;
+        contractAddress: string;
+        certificate?: {
+            signature: string;
+            amount: string;
+        };
+        mode?: 'maci' | 'amaci';
+    }): Promise<string>;
+    isWhitelisted({ signer, address, contractAddress, }: {
+        signer: OfflineSigner;
+        address?: string;
+        contractAddress: string;
+    }): Promise<boolean>;
+    getOracleWhitelistConfig({ signer, contractAddress, }: {
+        signer: OfflineSigner;
+        contractAddress: string;
+    }): Promise<OracleWhitelistConfig>;
+    getRoundInfo({ contractAddress }: {
+        contractAddress: string;
+    }): Promise<RoundType>;
+    getRoundCircuitType({ contractAddress }: {
+        contractAddress: string;
+    }): Promise<string>;
+    queryRoundIsQv({ contractAddress }: {
+        contractAddress: string;
+    }): Promise<boolean>;
+    queryRoundClaimable({ contractAddress, }: {
+        contractAddress: string;
+    }): Promise<{
+        claimable: boolean | null;
+        balance: string | null;
+    }>;
+    queryAMaciChargeFee({ maxVoter, maxOption, }: {
+        maxVoter: number;
+        maxOption: number;
+    }): Promise<{
+        denom: string;
+        amount: string;
+    }>;
+    queryRoundGasStation({ contractAddress }: {
+        contractAddress: string;
+    }): Promise<boolean>;
+    parseRoundStatus(votingStart: number, votingEnd: number, status: string, currentTime: Date): string;
+    queryRoundBalance({ contractAddress }: {
+        contractAddress: string;
+    }): Promise<string>;
+    requestOracleCertificate({ signer, ecosystem, address, contractAddress, }: {
+        signer: OfflineSigner;
+        ecosystem: CertificateEcosystem;
+        address?: string;
+        contractAddress: string;
+    }): Promise<SignatureResponse>;
+    signup({ signer, address, contractAddress, maciKeypair, oracleCertificate, gasStation, }: {
+        signer: OfflineSigner;
+        address?: string;
+        contractAddress: string;
+        maciKeypair?: Keypair;
+        oracleCertificate?: {
+            amount: string;
+            signature: string;
+        };
+        gasStation?: boolean;
+    }): Promise<import("@cosmjs/cosmwasm-stargate").ExecuteResult>;
+    private processVoteOptions;
+    vote({ signer, address, stateIdx, contractAddress, selectedOptions, operatorCoordPubKey, maciKeypair, gasStation, }: {
+        signer: OfflineSigner;
+        address?: string;
+        stateIdx: number;
+        contractAddress: string;
+        selectedOptions: {
+            idx: number;
+            vc: number;
+        }[];
+        operatorCoordPubKey: PubKey;
+        maciKeypair?: Keypair;
+        gasStation?: boolean;
+    }): Promise<import("@cosmjs/cosmwasm-stargate").DeliverTxResponse>;
+    publishMessage({ client, address, payload, contractAddress, gasStation, }: {
+        client: SigningCosmWasmClient;
+        address: string;
+        payload: {
+            msg: bigint[];
+            encPubkeys: PubKey;
+        }[];
+        contractAddress: string;
+        gasStation: boolean;
+    }): Promise<import("@cosmjs/cosmwasm-stargate").DeliverTxResponse>;
+    signupSimple({ client, address, pubKey, contractAddress, gasStation, }: {
+        client: SigningCosmWasmClient;
+        address: string;
+        pubKey: PubKey;
+        contractAddress: string;
+        gasStation?: boolean;
+    }): Promise<import("@cosmjs/cosmwasm-stargate").ExecuteResult>;
+    signupOracle({ client, address, pubKey, contractAddress, oracleCertificate, gasStation, }: {
+        client: SigningCosmWasmClient;
+        address: string;
+        pubKey: PubKey;
+        contractAddress: string;
+        oracleCertificate: {
+            amount: string;
+            signature: string;
+        };
+        gasStation?: boolean;
+    }): Promise<import("@cosmjs/cosmwasm-stargate").ExecuteResult>;
+    claimAMaciRound({ signer, contractAddress, }: {
+        signer: OfflineSigner;
+        contractAddress: string;
+    }): Promise<import("@cosmjs/cosmwasm-stargate").ExecuteResult>;
+    getOracleCertificateConfig(): Promise<import("../oracle-certificate/types").EcosystemsResponse>;
+    /**
+     * Batch grant with bond (for maci)
+     * @param signer
+     * @param contractAddress
+     * @param address
+     * @param amount
+     * @returns
+     */
+    batchGrantWithBond({ signer, contractAddress, address, amount, }: {
+        signer: OfflineSigner;
+        contractAddress: string;
+        amount: string;
+        address?: string;
+    }): Promise<import("@cosmjs/cosmwasm-stargate").DeliverTxResponse>;
+    /**
+     * Batch revoke with withdraw (for maci)
+     * @param client
+     * @param contractAddress
+     * @param address
+     * @returns
+     */
+    batchRevokeWithdraw({ signer, contractAddress, address, }: {
+        signer: OfflineSigner;
+        contractAddress: string;
+        address?: string;
+    }): Promise<import("@cosmjs/cosmwasm-stargate").DeliverTxResponse>;
+}

package/dist/libs/maci/types.d.ts

@@ -0,0 +1,6 @@
+export type IAccountStatus = {
+    stateIdx: number;
+    vcbTotal: number;
+    whitelistCommitment: number;
+    feegrantStatus?: string;
+};

package/dist/libs/oracle-certificate/index.d.ts

@@ -0,0 +1 @@
+export { OracleCertificate } from './oracle-certificate';

package/dist/libs/oracle-certificate/oracle-certificate.d.ts

@@ -0,0 +1,9 @@
+import { OracleCertificateParams, SignatureRequest, SignatureResponse, FeegrantAllowanceResponse, EcosystemsResponse } from './types';
+export declare class OracleCertificate {
+    private certificateApiEndpoint;
+    private http;
+    constructor({ certificateApiEndpoint, http }: OracleCertificateParams);
+    sign(data: SignatureRequest): Promise<SignatureResponse>;
+    feegrantAllowance(granter: string, grantee: string): Promise<FeegrantAllowanceResponse>;
+    listEcosystems(): Promise<EcosystemsResponse>;
+}

package/dist/libs/oracle-certificate/types.d.ts

@@ -0,0 +1,40 @@
+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;
+};
+export type FeegrantAllowanceResponse = {
+    granter: string;
+    grantee: string;
+    spend_limit: {
+        denom: string;
+        amount: string;
+    }[];
+};
+export interface SnapshotHeightInfo {
+    lowestHeight: string;
+    latestHeight: string;
+}
+export interface Ecosystem {
+    name: string;
+    displayName: string;
+    decimals: number;
+    apiPath: string;
+    snapshotHeightInfo: SnapshotHeightInfo;
+    baseSlope: number;
+}
+export interface EcosystemsResponse {
+    ecosystems: Ecosystem[];
+}

package/dist/libs/query/account.d.ts

@@ -0,0 +1,7 @@
+import { Http } from '../http';
+import { BalanceResponse } from '../../types';
+export declare class UserAccount {
+    http: Http;
+    constructor(http: Http);
+    balanceOf(address: string): Promise<BalanceResponse>;
+}

package/dist/libs/query/circuit.d.ts

@@ -0,0 +1,8 @@
+import { Http } from '../../libs';
+import { CircuitResponse, CircuitsResponse } from '../../types';
+export declare class Circuit {
+    http: Http;
+    constructor(http: Http);
+    getCircuitByName(name: string): Promise<CircuitResponse>;
+    getCircuits(): Promise<CircuitsResponse>;
+}

package/dist/libs/query/event.d.ts

@@ -0,0 +1,7 @@
+import { Http } from '../../libs';
+import { SignUpEventsResponse } from '../../types';
+export declare class Event {
+    http: Http;
+    constructor(http: Http);
+    getSignUpEventByPubKey(contractAddress: string, pubKey: bigint[]): Promise<SignUpEventsResponse>;
+}

package/dist/libs/query/index.d.ts

@@ -0,0 +1,7 @@
+export { UserAccount } from './account';
+export { Circuit } from './circuit';
+export { Operator } from './operator';
+export { Round } from './round';
+export { Transaction } from './transaction';
+export { Proof } from './proof';
+export { Event } from './event';

package/dist/libs/query/operator.d.ts

@@ -0,0 +1,11 @@
+import { Http } from '../../libs';
+import { OperatorResponse, OperatorsResponse, OperatorDelayOperationsResponse, MissRateResponse } from '../../types';
+export declare class Operator {
+    http: Http;
+    amaciRegistryContract: string;
+    constructor(http: Http, amaciRegistryContract: string);
+    getOperatorByAddress(address: string): Promise<OperatorResponse>;
+    getOperatorDelayOperationsByAddress(address: string, after: string, limit?: number): Promise<OperatorDelayOperationsResponse>;
+    getOperators(after: string, limit?: number): Promise<OperatorsResponse>;
+    queryMissRate(address: string, durationDay: number): Promise<MissRateResponse>;
+}

package/dist/libs/query/proof.d.ts

@@ -0,0 +1,7 @@
+import { Http } from '../../libs';
+import { ProofResponse } from '../../types';
+export declare class Proof {
+    http: Http;
+    constructor(http: Http);
+    getProofByContractAddress(address: string): Promise<ProofResponse>;
+}

package/dist/libs/query/round.d.ts

@@ -0,0 +1,18 @@
+import { RoundsResponse, RoundResponse, SelectiveRoundResponse } from '../../types';
+import { Http } from '../../libs';
+export declare class Round {
+    http: Http;
+    constructor(http: Http);
+    getRoundById(address: string): Promise<RoundResponse>;
+    /**
+     * Get round information with selective fields
+     * @param address Round address
+     * @param fields Array of fields to return, returns all fields if empty
+     * @returns Round information response
+     */
+    getRoundWithFields(address: string, fields?: string[]): Promise<SelectiveRoundResponse>;
+    getRounds(after: string, limit?: number): Promise<RoundsResponse>;
+    getRoundsByCircuitName(circuitName: string, after: string, limit?: number): Promise<RoundsResponse>;
+    getRoundsByStatus(status: string, after: string, limit?: number): Promise<RoundsResponse>;
+    getRoundsByOperator(operator: string, after: string, limit?: number): Promise<RoundsResponse>;
+}

package/dist/libs/query/transaction.d.ts

@@ -0,0 +1,9 @@
+import { TransactionsResponse, TransactionResponse } from '../../types';
+import { Http } from '../../libs';
+export declare class Transaction {
+    http: Http;
+    constructor(http: Http);
+    getTransactionByHash(txHash: string): Promise<TransactionResponse>;
+    getTransactions(after: string, limit?: number): Promise<TransactionsResponse>;
+    getTransactionsByContractAddress(address: string, after: string, limit?: number): Promise<TransactionsResponse>;
+}

package/dist/maci.d.ts

@@ -0,0 +1,190 @@
+import { ClientParams, CertificateEcosystem } from './types';
+import { Http, Indexer, Contract, OracleCertificate, MACI } from './libs';
+import { CreateAMaciRoundParams, CreateMaciRoundParams, CreateOracleMaciRoundParams } from './libs/contract/types';
+import { OfflineSigner } from '@cosmjs/proto-signing';
+import { Keypair, PubKey } from './libs/crypto';
+import { OracleWhitelistConfig } from './libs/contract/ts/OracleMaci.types';
+import { SignatureResponse } from './libs/oracle-certificate/types';
+/**
+ * @class MaciClient
+ * @description This class is used to interact with Maci Client.
+ */
+export declare class MaciClient {
+    network: 'mainnet' | 'testnet';
+    rpcEndpoint: string;
+    restEndpoint: string;
+    apiEndpoint: string;
+    certificateApiEndpoint: string;
+    registryAddress: string;
+    maciCodeId: number;
+    oracleCodeId: number;
+    feegrantOperator: string;
+    whitelistBackendPubkey: string;
+    http: Http;
+    indexer: Indexer;
+    contract: Contract;
+    oracleCertificate: OracleCertificate;
+    maci: MACI;
+    maciKeypair: Keypair;
+    signer: OfflineSigner;
+    /**
+     * @constructor
+     * @param {ClientParams} params - The parameters for the Maci Client instance.
+     */
+    constructor({ signer, network, rpcEndpoint, restEndpoint, apiEndpoint, registryAddress, maciCodeId, oracleCodeId, customFetch, defaultOptions, feegrantOperator, whitelistBackendPubkey, certificateApiEndpoint, maciKeypair, }: ClientParams);
+    getSigner(signer?: OfflineSigner): OfflineSigner;
+    getMaciKeypair(): Keypair;
+    getMaciPubkey(): bigint;
+    packMaciPubkey(pubkey?: PubKey): bigint;
+    unpackMaciPubkey(pubkey: bigint | string): PubKey;
+    getAddress(signer?: OfflineSigner): Promise<string>;
+    oracleMaciClient({ signer, contractAddress, }: {
+        signer?: OfflineSigner;
+        contractAddress: string;
+    }): Promise<import("./libs/contract/ts/OracleMaci.client").OracleMaciClient>;
+    registryClient({ signer, contractAddress, }: {
+        signer?: OfflineSigner;
+        contractAddress: string;
+    }): Promise<import("./libs/contract/ts/Registry.client").RegistryClient>;
+    maciClient({ signer, contractAddress, }: {
+        signer?: OfflineSigner;
+        contractAddress: string;
+    }): Promise<import("./libs/contract/ts/Maci.client").MaciClient>;
+    amaciClient({ signer, contractAddress, }: {
+        signer?: OfflineSigner;
+        contractAddress: string;
+    }): Promise<import("./libs/contract/ts/AMaci.client").AMaciClient>;
+    createAMaciRound(params: CreateAMaciRoundParams): Promise<{
+        contractAddress: string;
+        logs: readonly import("@cosmjs/stargate/build/logs").Log[];
+        height: number;
+        transactionHash: string;
+        events: readonly import("@cosmjs/stargate").Event[];
+        gasWanted: bigint;
+        gasUsed: bigint;
+    }>;
+    createMaciRound(params: CreateMaciRoundParams): Promise<import("@cosmjs/cosmwasm-stargate").InstantiateResult>;
+    createOracleMaciRound(params: CreateOracleMaciRoundParams): Promise<import("@cosmjs/cosmwasm-stargate").InstantiateResult>;
+    genKeypairFromSign({ signer, address, }?: {
+        signer?: OfflineSigner;
+        address?: string;
+    }): Promise<Keypair>;
+    getStateIdxInc({ signer, address, contractAddress, }: {
+        signer?: OfflineSigner;
+        address?: string;
+        contractAddress: string;
+    }): Promise<string>;
+    getVoiceCreditBalance({ signer, stateIdx, contractAddress, }: {
+        signer?: OfflineSigner;
+        stateIdx: number;
+        contractAddress: string;
+    }): Promise<string>;
+    getStateIdxByPubKey({ contractAddress, pubKey, }: {
+        contractAddress: string;
+        pubKey: bigint[];
+    }): Promise<number>;
+    feegrantAllowance({ signer, address, contractAddress, }: {
+        signer?: OfflineSigner;
+        address?: string;
+        contractAddress: string;
+    }): Promise<import("./libs/oracle-certificate/types").FeegrantAllowanceResponse>;
+    hasFeegrant({ signer, address, contractAddress, }: {
+        signer?: OfflineSigner;
+        address?: string;
+        contractAddress: string;
+    }): Promise<boolean>;
+    queryWhitelistBalanceOf({ signer, address, contractAddress, certificate, mode, }: {
+        signer?: OfflineSigner;
+        address?: string;
+        contractAddress: string;
+        certificate?: {
+            signature: string;
+            amount: string;
+        };
+        mode?: 'maci' | 'amaci';
+    }): Promise<string>;
+    isWhitelisted({ signer, address, contractAddress, }: {
+        signer?: OfflineSigner;
+        address?: string;
+        contractAddress: string;
+    }): Promise<boolean>;
+    getOracleWhitelistConfig({ signer, contractAddress, }: {
+        signer?: OfflineSigner;
+        contractAddress: string;
+    }): Promise<OracleWhitelistConfig>;
+    getRoundInfo({ contractAddress }: {
+        contractAddress: string;
+    }): Promise<import("./types").RoundType>;
+    getRoundCircuitType({ contractAddress }: {
+        contractAddress: string;
+    }): Promise<string>;
+    queryRoundIsQv({ contractAddress }: {
+        contractAddress: string;
+    }): Promise<boolean>;
+    queryRoundClaimable({ contractAddress, }: {
+        contractAddress: string;
+    }): Promise<{
+        claimable: boolean | null;
+        balance: string | null;
+    }>;
+    queryAMaciChargeFee({ maxVoter, maxOption, }: {
+        maxVoter: number;
+        maxOption: number;
+    }): Promise<{
+        denom: string;
+        amount: string;
+    }>;
+    queryRoundGasStation({ contractAddress }: {
+        contractAddress: string;
+    }): Promise<boolean>;
+    parseRoundStatus(votingStart: number, votingEnd: number, status: string, currentTime: Date): string;
+    queryRoundBalance({ contractAddress }: {
+        contractAddress: string;
+    }): Promise<string>;
+    requestOracleCertificate({ signer, ecosystem, address, contractAddress, }: {
+        signer?: OfflineSigner;
+        ecosystem: CertificateEcosystem;
+        address?: string;
+        contractAddress: string;
+    }): Promise<SignatureResponse>;
+    signup({ signer, address, contractAddress, maciKeypair, oracleCertificate, gasStation, }: {
+        signer?: OfflineSigner;
+        address?: string;
+        contractAddress: string;
+        maciKeypair?: Keypair;
+        oracleCertificate?: {
+            amount: string;
+            signature: string;
+        };
+        gasStation?: boolean;
+    }): Promise<import("@cosmjs/cosmwasm-stargate").ExecuteResult>;
+    vote({ signer, address, stateIdx, contractAddress, selectedOptions, operatorCoordPubKey, maciKeypair, gasStation, }: {
+        signer?: OfflineSigner;
+        address?: string;
+        stateIdx: number;
+        contractAddress: string;
+        selectedOptions: {
+            idx: number;
+            vc: number;
+        }[];
+        operatorCoordPubKey: PubKey;
+        maciKeypair?: Keypair;
+        gasStation?: boolean;
+    }): Promise<import("@cosmjs/stargate").DeliverTxResponse>;
+    claimAMaciRound({ signer, contractAddress, }: {
+        signer?: OfflineSigner;
+        contractAddress: string;
+    }): Promise<import("@cosmjs/cosmwasm-stargate").ExecuteResult>;
+    getOracleCertificateConfig(): Promise<import("./libs/oracle-certificate/types").EcosystemsResponse>;
+    batchGrantWithBond({ signer, contractAddress, address, amount, }: {
+        signer?: OfflineSigner;
+        contractAddress: string;
+        address?: string;
+        amount: string;
+    }): Promise<import("@cosmjs/stargate").DeliverTxResponse>;
+    batchRevokeWithdraw({ signer, contractAddress, address, }: {
+        signer?: OfflineSigner;
+        contractAddress: string;
+        address?: string;
+    }): Promise<import("@cosmjs/stargate").DeliverTxResponse>;
+}