@injectivelabs/sdk-ts 1.15.0 → 1.15.2

package/dist/esm/client/indexer/grpc/IndexerGrpcAccountApi.js

@@ -0,0 +1,205 @@
+import { GeneralException, UnspecifiedErrorCode, grpcErrorCodeToErrorCode, GrpcUnaryRequestException, } from '@injectivelabs/exceptions';
+import { InjectiveAccountRpc } from '@injectivelabs/indexer-proto-ts';
+import BaseGrpcConsumer from '../../base/BaseIndexerGrpcConsumer.js';
+import { IndexerModule } from '../types/index.js';
+import { IndexerGrpcAccountTransformer } from '../transformers/index.js';
+/**
+ * @category Indexer Grpc API
+ */
+export class IndexerGrpcAccountApi extends BaseGrpcConsumer {
+    module = IndexerModule.Account;
+    client;
+    constructor(endpoint) {
+        super(endpoint);
+        this.client = new InjectiveAccountRpc.InjectiveAccountsRPCClientImpl(this.getGrpcWebImpl(endpoint));
+    }
+    /**
+     * @deprecated - use IndexerGrpcAccountPortfolioApi.fetchPortfolio instead
+     */
+    async fetchPortfolio(_address) {
+        throw new GeneralException(new Error('deprecated - use IndexerGrpcAccountPortfolioApi.fetchPortfolio'));
+    }
+    async fetchRewards({ address, epoch }) {
+        const request = InjectiveAccountRpc.RewardsRequest.create();
+        request.accountAddress = address;
+        if (epoch) {
+            request.epoch = epoch.toString();
+        }
+        try {
+            const response = await this.retry(() => this.client.Rewards(request, this.metadata));
+            return IndexerGrpcAccountTransformer.tradingRewardsResponseToTradingRewards(response);
+        }
+        catch (e) {
+            if (e instanceof InjectiveAccountRpc.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'Rewards',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'Rewards',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchSubaccountsList(address) {
+        const request = InjectiveAccountRpc.SubaccountsListRequest.create();
+        request.accountAddress = address;
+        try {
+            const response = await this.retry(() => this.client.SubaccountsList(request, this.metadata));
+            return response.subaccounts;
+        }
+        catch (e) {
+            if (e instanceof InjectiveAccountRpc.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'SubaccountsList',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'SubaccountsList',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchSubaccountBalance(subaccountId, denom) {
+        const request = InjectiveAccountRpc.SubaccountBalanceEndpointRequest.create();
+        request.subaccountId = subaccountId;
+        request.denom = denom;
+        try {
+            const response = await this.retry(() => this.client.SubaccountBalanceEndpoint(request, this.metadata));
+            return IndexerGrpcAccountTransformer.balanceResponseToBalance(response);
+        }
+        catch (e) {
+            if (e instanceof InjectiveAccountRpc.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'SubaccountBalanceEndpoint',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'SubaccountBalanceEndpoint',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchSubaccountBalancesList(subaccountId) {
+        const request = InjectiveAccountRpc.SubaccountBalancesListRequest.create();
+        request.subaccountId = subaccountId;
+        try {
+            const response = await this.retry(() => this.client.SubaccountBalancesList(request, this.metadata));
+            return IndexerGrpcAccountTransformer.balancesResponseToBalances(response);
+        }
+        catch (e) {
+            if (e instanceof InjectiveAccountRpc.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'SubaccountBalancesList',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'SubaccountBalancesList',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchSubaccountHistory({ subaccountId, denom, transferTypes = [], pagination, }) {
+        const request = InjectiveAccountRpc.SubaccountHistoryRequest.create();
+        request.subaccountId = subaccountId;
+        if (denom) {
+            request.denom = denom;
+        }
+        if (transferTypes.length > 0) {
+            request.transferTypes = transferTypes;
+        }
+        if (pagination) {
+            if (pagination.skip !== undefined) {
+                request.skip = pagination.skip.toString();
+            }
+            if (pagination.limit !== undefined) {
+                request.limit = pagination.limit;
+            }
+            if (pagination.endTime !== undefined) {
+                request.endTime = pagination.endTime.toString();
+            }
+        }
+        try {
+            const response = await this.retry(() => this.client.SubaccountHistory(request, this.metadata));
+            return IndexerGrpcAccountTransformer.transferHistoryResponseToTransferHistory(response);
+        }
+        catch (e) {
+            if (e instanceof InjectiveAccountRpc.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'SubaccountHistory',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'SubaccountHistory',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchSubaccountOrderSummary({ subaccountId, marketId, orderDirection, }) {
+        const request = InjectiveAccountRpc.SubaccountOrderSummaryRequest.create();
+        request.subaccountId = subaccountId;
+        if (marketId) {
+            request.marketId = marketId;
+        }
+        if (orderDirection) {
+            request.orderDirection = orderDirection;
+        }
+        try {
+            const response = await this.retry(() => this.client.SubaccountOrderSummary(request, this.metadata));
+            return response;
+        }
+        catch (e) {
+            if (e instanceof InjectiveAccountRpc.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'SubaccountOrderSummary',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'SubaccountOrderSummary',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchOrderStates(params) {
+        const { spotOrderHashes = [], derivativeOrderHashes = [] } = params || {};
+        const request = InjectiveAccountRpc.OrderStatesRequest.create();
+        request.spotOrderHashes = spotOrderHashes;
+        request.derivativeOrderHashes = derivativeOrderHashes;
+        try {
+            const response = await this.retry(() => this.client.OrderStates(request, this.metadata));
+            return response;
+        }
+        catch (e) {
+            if (e instanceof InjectiveAccountRpc.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'OrderStates',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'OrderStates',
+                contextModule: this.module,
+            });
+        }
+    }
+}

package/dist/esm/client/indexer/grpc/IndexerGrpcArchiverApi.d.ts

@@ -0,0 +1,49 @@
+import { InjectiveArchiverRpc } from '@injectivelabs/indexer-proto-ts';
+import BaseGrpcConsumer from '../../base/BaseIndexerGrpcConsumer.js';
+/**
+ * @category Indexer Grpc API
+ */
+export declare class IndexerGrpcArchiverApi extends BaseGrpcConsumer {
+    protected module: string;
+    protected client: InjectiveArchiverRpc.InjectiveArchiverRPCClientImpl;
+    constructor(endpoint: string);
+    fetchHistoricalBalance({ account, resolution, }: {
+        account: string;
+        resolution: string;
+    }): Promise<import("../types/archiver.js").HistoricalBalance>;
+    fetchHistoricalRpnl({ account, resolution, }: {
+        account: string;
+        resolution: string;
+    }): Promise<import("../types/archiver.js").HistoricalRPNL>;
+    fetchHistoricalVolumes({ account, resolution, }: {
+        account: string;
+        resolution: string;
+    }): Promise<import("../types/archiver.js").HistoricalVolumes>;
+    fetchPnlLeaderboard({ startDate, endDate, limit, account, }: {
+        startDate: string;
+        endDate: string;
+        limit?: number;
+        account?: string;
+    }): Promise<import("../types/archiver.js").PnlLeaderboard>;
+    fetchVolLeaderboard({ startDate, endDate, limit, account, }: {
+        startDate: string;
+        endDate: string;
+        limit?: number;
+        account?: string;
+    }): Promise<import("../types/archiver.js").VolLeaderboard>;
+    fetchPnlLeaderboardFixedResolution({ resolution, limit, account, }: {
+        resolution: string;
+        limit?: number;
+        account?: string;
+    }): Promise<import("../types/archiver.js").PnlLeaderboard>;
+    fetchVolLeaderboardFixedResolution({ resolution, limit, account, }: {
+        resolution: string;
+        limit?: number;
+        account?: string;
+    }): Promise<import("../types/archiver.js").VolLeaderboard>;
+    fetchDenomHolders({ denom, token, limit, }: {
+        denom: string;
+        token?: string;
+        limit?: number;
+    }): Promise<import("../types/archiver.js").DenomHolders>;
+}

package/dist/esm/client/indexer/grpc/IndexerGrpcArchiverApi.js

@@ -0,0 +1,227 @@
+import { UnspecifiedErrorCode, grpcErrorCodeToErrorCode, GrpcUnaryRequestException, } from '@injectivelabs/exceptions';
+import { InjectiveArchiverRpc } from '@injectivelabs/indexer-proto-ts';
+import BaseGrpcConsumer from '../../base/BaseIndexerGrpcConsumer.js';
+import { IndexerModule } from '../types/index.js';
+import { IndexerGrpcArchiverTransformer } from '../transformers/index.js';
+/**
+ * @category Indexer Grpc API
+ */
+export class IndexerGrpcArchiverApi extends BaseGrpcConsumer {
+    module = IndexerModule.Archiver;
+    client;
+    constructor(endpoint) {
+        super(endpoint);
+        this.client = new InjectiveArchiverRpc.InjectiveArchiverRPCClientImpl(this.getGrpcWebImpl(endpoint));
+    }
+    async fetchHistoricalBalance({ account, resolution, }) {
+        const request = InjectiveArchiverRpc.BalanceRequest.create();
+        request.account = account;
+        request.resolution = resolution;
+        try {
+            const response = await this.retry(() => this.client.Balance(request, this.metadata));
+            return IndexerGrpcArchiverTransformer.grpcHistoricalBalanceResponseToHistoricalBalances(response);
+        }
+        catch (e) {
+            if (e instanceof InjectiveArchiverRpc.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'Historical Balance',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'Historical Balance',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchHistoricalRpnl({ account, resolution, }) {
+        const request = InjectiveArchiverRpc.RpnlRequest.create();
+        request.account = account;
+        request.resolution = resolution;
+        try {
+            const response = await this.retry(() => this.client.Rpnl(request, this.metadata));
+            return IndexerGrpcArchiverTransformer.grpcHistoricalRPNLResponseToHistoricalRPNL(response);
+        }
+        catch (e) {
+            if (e instanceof InjectiveArchiverRpc.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'Historical Rpnl',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'Historical Rpnl',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchHistoricalVolumes({ account, resolution, }) {
+        const request = InjectiveArchiverRpc.VolumesRequest.create();
+        request.account = account;
+        request.resolution = resolution;
+        try {
+            const response = await this.retry(() => this.client.Volumes(request, this.metadata));
+            return IndexerGrpcArchiverTransformer.grpcHistoricalVolumesResponseToHistoricalVolumes(response);
+        }
+        catch (e) {
+            if (e instanceof InjectiveArchiverRpc.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'Historical Volumes',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'Historical Volumes',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchPnlLeaderboard({ startDate, endDate, limit, account, }) {
+        const request = InjectiveArchiverRpc.PnlLeaderboardRequest.create();
+        request.startDate = startDate;
+        request.endDate = endDate;
+        if (limit) {
+            request.limit = limit;
+        }
+        if (account) {
+            request.account = account;
+        }
+        try {
+            const response = await this.retry(() => this.client.PnlLeaderboard(request, this.metadata));
+            return IndexerGrpcArchiverTransformer.grpcPnlLeaderboardResponseToPnlLeaderboard(response);
+        }
+        catch (e) {
+            if (e instanceof InjectiveArchiverRpc.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'Pnl Leaderboard',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'Pnl Leaderboard',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchVolLeaderboard({ startDate, endDate, limit, account, }) {
+        const request = InjectiveArchiverRpc.VolLeaderboardRequest.create();
+        request.startDate = startDate;
+        request.endDate = endDate;
+        if (limit) {
+            request.limit = limit;
+        }
+        if (account) {
+            request.account = account;
+        }
+        try {
+            const response = await this.retry(() => this.client.VolLeaderboard(request, this.metadata));
+            return IndexerGrpcArchiverTransformer.grpcVolLeaderboardResponseToVolLeaderboard(response);
+        }
+        catch (e) {
+            if (e instanceof InjectiveArchiverRpc.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'Vol Leaderboard',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'Vol Leaderboard',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchPnlLeaderboardFixedResolution({ resolution, limit, account, }) {
+        const request = InjectiveArchiverRpc.PnlLeaderboardFixedResolutionRequest.create();
+        request.resolution = resolution;
+        if (limit) {
+            request.limit = limit;
+        }
+        if (account) {
+            request.account = account;
+        }
+        try {
+            const response = await this.retry(() => this.client.PnlLeaderboardFixedResolution(request, this.metadata));
+            return IndexerGrpcArchiverTransformer.grpcPnlLeaderboardFixedResolutionResponseToPnlLeaderboard(response);
+        }
+        catch (e) {
+            if (e instanceof InjectiveArchiverRpc.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'Pnl Leaderboard Fixed Resolution',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'Pnl Leaderboard Fixed Resolution',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchVolLeaderboardFixedResolution({ resolution, limit, account, }) {
+        const request = InjectiveArchiverRpc.VolLeaderboardFixedResolutionRequest.create();
+        request.resolution = resolution;
+        if (limit) {
+            request.limit = limit;
+        }
+        if (account) {
+            request.account = account;
+        }
+        try {
+            const response = await this.retry(() => this.client.VolLeaderboardFixedResolution(request, this.metadata));
+            return IndexerGrpcArchiverTransformer.grpcVolLeaderboardFixedResolutionResponseToVolLeaderboard(response);
+        }
+        catch (e) {
+            if (e instanceof InjectiveArchiverRpc.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'Vol Leaderboard Fixed Resolution',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'Vol Leaderboard Fixed Resolution',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchDenomHolders({ denom, token, limit, }) {
+        const request = InjectiveArchiverRpc.DenomHoldersRequest.create();
+        request.denom = denom;
+        if (token) {
+            request.token = token;
+        }
+        if (limit) {
+            request.limit = limit;
+        }
+        try {
+            const response = await this.retry(() => this.client.DenomHolders(request, this.metadata));
+            return IndexerGrpcArchiverTransformer.grpcDenomHoldersResponseToDenomHolders(response);
+        }
+        catch (e) {
+            if (e instanceof InjectiveArchiverRpc.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'DenomHolders',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'DenomHolders',
+                contextModule: this.module,
+            });
+        }
+    }
+}

package/dist/esm/client/indexer/grpc/IndexerGrpcAuctionApi.d.ts

@@ -0,0 +1,16 @@
+import { InjectiveAuctionRpc } from '@injectivelabs/indexer-proto-ts';
+import BaseGrpcConsumer from '../../base/BaseIndexerGrpcConsumer.js';
+/**
+ * @category Indexer Grpc API
+ */
+export declare class IndexerGrpcAuctionApi extends BaseGrpcConsumer {
+    protected module: string;
+    protected client: InjectiveAuctionRpc.InjectiveAuctionRPCClientImpl;
+    constructor(endpoint: string);
+    fetchAuction(round?: number): Promise<{
+        auction: import("../types/auction.js").Auction;
+        bids: import("../types/auction.js").IndexerBid[];
+    }>;
+    fetchAuctions(): Promise<import("../types/auction.js").Auction[]>;
+    fetchInjBurnt(): Promise<number>;
+}

package/dist/esm/client/indexer/grpc/IndexerGrpcAuctionApi.js

@@ -0,0 +1,86 @@
+import { UnspecifiedErrorCode, grpcErrorCodeToErrorCode, GrpcUnaryRequestException, } from '@injectivelabs/exceptions';
+import { InjectiveAuctionRpc } from '@injectivelabs/indexer-proto-ts';
+import BaseGrpcConsumer from '../../base/BaseIndexerGrpcConsumer.js';
+import { IndexerModule } from '../types/index.js';
+import { IndexerGrpcAuctionTransformer } from '../transformers/index.js';
+/**
+ * @category Indexer Grpc API
+ */
+export class IndexerGrpcAuctionApi extends BaseGrpcConsumer {
+    module = IndexerModule.Account;
+    client;
+    constructor(endpoint) {
+        super(endpoint);
+        this.client = new InjectiveAuctionRpc.InjectiveAuctionRPCClientImpl(this.getGrpcWebImpl(endpoint));
+    }
+    async fetchAuction(round) {
+        const request = InjectiveAuctionRpc.AuctionEndpointRequest.create();
+        /**
+         * If round is provided, set it on the request,
+         * otherwise fetch latest round
+         **/
+        if (round) {
+            request.round = round.toString();
+        }
+        try {
+            const response = await this.retry(() => this.client.AuctionEndpoint(request, this.metadata));
+            return IndexerGrpcAuctionTransformer.auctionResponseToAuction(response);
+        }
+        catch (e) {
+            if (e instanceof InjectiveAuctionRpc.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'AuctionEndpoint',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'AuctionEndpoint',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchAuctions() {
+        const request = InjectiveAuctionRpc.AuctionsRequest.create();
+        try {
+            const response = await this.retry(() => this.client.Auctions(request, this.metadata));
+            return IndexerGrpcAuctionTransformer.auctionsResponseToAuctions(response);
+        }
+        catch (e) {
+            if (e instanceof InjectiveAuctionRpc.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'Auctions',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'Auctions',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchInjBurnt() {
+        const request = {};
+        try {
+            const response = await this.retry(() => this.client.InjBurntEndpoint(request, this.metadata));
+            return IndexerGrpcAuctionTransformer.injBurntResponseToInjBurnt(response);
+        }
+        catch (e) {
+            if (e instanceof InjectiveAuctionRpc.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'InjBurntEndpoint',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'InjBurntEndpoint',
+                contextModule: this.module,
+            });
+        }
+    }
+}

package/dist/esm/client/indexer/grpc/IndexerGrpcCampaignApi.d.ts

@@ -0,0 +1,71 @@
+import { InjectiveCampaignRpc } from '@injectivelabs/indexer-proto-ts';
+import BaseGrpcConsumer from '../../base/BaseIndexerGrpcConsumer.js';
+/**
+ * @category Indexer Grpc API
+ */
+export declare class IndexerGrpcCampaignApi extends BaseGrpcConsumer {
+    protected module: string;
+    protected client: InjectiveCampaignRpc.InjectiveCampaignRPCClientImpl;
+    constructor(endpoint: string);
+    fetchCampaign({ skip, limit, marketId, campaignId, accountAddress, contractAddress, }: {
+        skip?: string;
+        limit?: number;
+        marketId?: string;
+        campaignId: string;
+        accountAddress?: string;
+        contractAddress?: string;
+    }): Promise<{
+        campaign: import("../types/campaign.js").Campaign | undefined;
+        users: import("../types/campaign.js").CampaignUser[];
+        paging: import("../../../index.js").ExchangePagination;
+    }>;
+    fetchCampaigns({ type, active, limit, cursor, status, }: {
+        type?: string;
+        active?: boolean;
+        limit?: number;
+        cursor?: string;
+        status?: string;
+    }): Promise<{
+        campaigns: import("../types/campaign.js").CampaignV2[];
+        cursor: string;
+    }>;
+    fetchRound({ roundId, toRoundId, accountAddress, contractAddress, }: {
+        roundId?: string;
+        toRoundId?: number;
+        accountAddress?: string;
+        contractAddress?: string;
+    }): Promise<{
+        campaigns: import("../types/campaign.js").Campaign[];
+        accumulatedRewards: InjectiveCampaignRpc.Coin[];
+        rewardCount: number;
+    }>;
+    fetchGuilds({ skip, limit, sortBy, campaignContract, }: {
+        skip?: number;
+        limit?: number;
+        sortBy: string;
+        campaignContract: string;
+    }): Promise<{
+        guilds: import("../types/campaign.js").Guild[];
+        paging: import("../../../index.js").ExchangePagination;
+        updatedAt: number;
+        summary: import("../types/campaign.js").GuildCampaignSummary | undefined;
+    }>;
+    fetchGuildMember({ address, campaignContract, }: {
+        address: string;
+        campaignContract: string;
+    }): Promise<{
+        info: import("../types/campaign.js").GuildMember | undefined;
+    }>;
+    fetchGuildMembers({ skip, limit, sortBy, guildId, campaignContract, includeGuildInfo, }: {
+        skip?: number;
+        limit?: number;
+        sortBy?: string;
+        guildId: string;
+        campaignContract: string;
+        includeGuildInfo: boolean;
+    }): Promise<{
+        members: import("../types/campaign.js").GuildMember[];
+        paging: import("../../../index.js").ExchangePagination;
+        guildInfo: import("../types/campaign.js").Guild | undefined;
+    }>;
+}