@injectivelabs/sdk-ts 1.16.37 → 1.16.38-alpha.0

package/dist/esm/client/indexer/types/trading.d.ts

@@ -1,15 +0,0 @@
-import type { InjectiveTradingRpc } from '@injectivelabs/indexer-proto-ts';
-export type ListTradingStrategiesResponse = InjectiveTradingRpc.ListTradingStrategiesResponse;
-export type TradingStrategy = InjectiveTradingRpc.TradingStrategy;
-export declare const MarketType: {
-    readonly Spot: "spot";
-    readonly Derivative: "derivative";
-};
-export type MarketType = (typeof MarketType)[keyof typeof MarketType];
-export type GridStrategyType = 'geometric' | 'arithmetic' | 'perpetual';
-export declare const GridStrategyType: {
-    readonly Geometric: "geometric";
-    readonly Arithmetic: "arithmetic";
-    readonly Perpetual: "perpetual";
-};
-export type GridStrategyStreamResponse = InjectiveTradingRpc.StreamStrategyResponse;

package/dist/esm/client/indexer/types/trading.js

@@ -1,11 +0,0 @@
-export const MarketType = {
-    Spot: 'spot',
-    Derivative: 'derivative',
-};
-// Trailing Arithmetic
-export const GridStrategyType = {
-    Geometric: 'geometric',
-    Arithmetic: 'arithmetic',
-    Perpetual: 'perpetual',
-    // Trailing Arithmetic
-};

package/dist/esm/client/olp/grpc/OLPGrpcApi.d.ts

@@ -1,50 +0,0 @@
-import { InjectiveDmmRpc } from '@injectivelabs/olp-proto-ts';
-import BaseGrpcConsumer from '../../base/BaseGrpcConsumer.js';
-export declare class OLPGrpcApi extends BaseGrpcConsumer {
-    protected module: string;
-    protected client: InjectiveDmmRpc.InjectiveDmmV2RPCClientImpl;
-    constructor(endpoint: string);
-    fetchEpochs(status?: string): Promise<import("./index.js").EpochV2[]>;
-    fetchMarketRewards(epochId: string): Promise<import("./index.js").MarketReward[]>;
-    fetchEligibleAddresses({ epochId, page, }: {
-        epochId: string;
-        page?: InjectiveDmmRpc.Pagination;
-    }): Promise<import("./index.js").EligibleAddresses>;
-    fetchEpochScores({ epochId, page, }: {
-        epochId: string;
-        page?: InjectiveDmmRpc.Pagination;
-    }): Promise<import("./index.js").EpochScores>;
-    fetchEpochScoresHistory({ epochId, accountAddress, page, }: {
-        epochId: string;
-        accountAddress: string;
-        page?: InjectiveDmmRpc.Pagination;
-    }): Promise<import("./index.js").EpochScoresHistory>;
-    fetchTotalScores({ epochId, marketId, page, }: {
-        epochId: string;
-        marketId: string;
-        page?: InjectiveDmmRpc.Pagination;
-    }): Promise<import("./index.js").TotalScores>;
-    fetchTotalScoresHistory({ epochId, marketId, accountAddress, page, }: {
-        epochId: string;
-        marketId: string;
-        accountAddress: string;
-        page?: InjectiveDmmRpc.Pagination;
-    }): Promise<import("./index.js").TotalScoresHistory>;
-    fetchRewardsDistribution({ epochId, height, page, }: {
-        epochId: string;
-        height?: string;
-        page?: InjectiveDmmRpc.Pagination;
-    }): Promise<import("./index.js").RewardsDistribution>;
-    fetchAccountVolumes({ epochId, accountAddress, }: {
-        epochId: string;
-        accountAddress: string;
-    }): Promise<import("./index.js").AccountVolume[]>;
-    fetchRewardsEligibility({ epochId, accountAddress, }: {
-        epochId?: string;
-        accountAddress?: string;
-    }): Promise<import("./index.js").RewardsEligibility>;
-    fetchMarketRewardsRange({ epochId, marketId, }: {
-        epochId: string;
-        marketId?: string;
-    }): Promise<import("./index.js").MinMaxRewards>;
-}

package/dist/esm/client/olp/grpc/OLPGrpcApi.js

@@ -1,289 +0,0 @@
-import { InjectiveDmmRpc } from '@injectivelabs/olp-proto-ts';
-import { IndexerErrorModule, UnspecifiedErrorCode, grpcErrorCodeToErrorCode, GrpcUnaryRequestException, } from '@injectivelabs/exceptions';
-import { DmmGrpcTransformer } from './transformers/index.js';
-import BaseGrpcConsumer from '../../base/BaseGrpcConsumer.js';
-export class OLPGrpcApi extends BaseGrpcConsumer {
-    module = IndexerErrorModule.OLP;
-    client;
-    constructor(endpoint) {
-        super(endpoint);
-        this.client = new InjectiveDmmRpc.InjectiveDmmV2RPCClientImpl(this.getGrpcWebImpl(endpoint));
-    }
-    async fetchEpochs(status) {
-        const request = InjectiveDmmRpc.GetEpochsRequest.create();
-        if (status) {
-            request.status = status;
-        }
-        try {
-            const response = await this.retry(() => this.client.GetEpochs(request));
-            return DmmGrpcTransformer.epochsResponseToEpochs(response);
-        }
-        catch (e) {
-            if (e instanceof InjectiveDmmRpc.GrpcWebError) {
-                throw new GrpcUnaryRequestException(new Error(e.toString()), {
-                    code: grpcErrorCodeToErrorCode(e.code),
-                    context: 'GetEpochs',
-                    contextModule: this.module,
-                });
-            }
-            throw new GrpcUnaryRequestException(e, {
-                code: UnspecifiedErrorCode,
-                context: 'GetEpochs',
-                contextModule: this.module,
-            });
-        }
-    }
-    async fetchMarketRewards(epochId) {
-        const request = InjectiveDmmRpc.GetMarketRewardsRequest.create();
-        request.epochId = epochId.toString();
-        try {
-            const response = await this.retry(() => this.client.GetMarketRewards(request));
-            return DmmGrpcTransformer.marketRewardsResponseToMarketRewards(response);
-        }
-        catch (e) {
-            if (e instanceof InjectiveDmmRpc.GrpcWebError) {
-                throw new GrpcUnaryRequestException(new Error(e.toString()), {
-                    code: grpcErrorCodeToErrorCode(e.code),
-                    context: 'GetMarketRewards',
-                    contextModule: this.module,
-                });
-            }
-            throw new GrpcUnaryRequestException(e, {
-                code: UnspecifiedErrorCode,
-                context: 'GetMarketRewards',
-                contextModule: this.module,
-            });
-        }
-    }
-    async fetchEligibleAddresses({ epochId, page, }) {
-        const request = InjectiveDmmRpc.GetEligibleAddressesRequest.create();
-        InjectiveDmmRpc.GetRewardsDistributionRequest;
-        request.epochId = epochId;
-        if (page) {
-            request.page = page;
-        }
-        try {
-            const response = await this.retry(() => this.client.GetEligibleAddresses(request));
-            return DmmGrpcTransformer.eligibleAddressesResponseToEligibleAddresses(response);
-        }
-        catch (e) {
-            if (e instanceof InjectiveDmmRpc.GrpcWebError) {
-                throw new GrpcUnaryRequestException(new Error(e.toString()), {
-                    code: grpcErrorCodeToErrorCode(e.code),
-                    context: 'GetEligibleAddresses',
-                    contextModule: this.module,
-                });
-            }
-            throw new GrpcUnaryRequestException(e, {
-                code: UnspecifiedErrorCode,
-                context: 'GetEligibleAddresses',
-                contextModule: this.module,
-            });
-        }
-    }
-    async fetchEpochScores({ epochId, page, }) {
-        const request = InjectiveDmmRpc.GetEpochScoresRequest.create();
-        request.epochId = epochId;
-        if (page) {
-            request.page = page;
-        }
-        try {
-            const response = await this.retry(() => this.client.GetEpochScores(request));
-            return DmmGrpcTransformer.epochScoresResponseToEpochScores(response);
-        }
-        catch (e) {
-            if (e instanceof InjectiveDmmRpc.GrpcWebError) {
-                throw new GrpcUnaryRequestException(new Error(e.toString()), {
-                    code: grpcErrorCodeToErrorCode(e.code),
-                    context: 'GetEpochScores',
-                    contextModule: this.module,
-                });
-            }
-            throw new GrpcUnaryRequestException(e, {
-                code: UnspecifiedErrorCode,
-                context: 'GetEpochScores',
-                contextModule: this.module,
-            });
-        }
-    }
-    async fetchEpochScoresHistory({ epochId, accountAddress, page, }) {
-        const request = InjectiveDmmRpc.GetEpochScoresHistoryRequest.create();
-        request.epochId = epochId;
-        request.accountAddress = accountAddress;
-        if (page) {
-            request.page = page;
-        }
-        try {
-            const response = await this.retry(() => this.client.GetEpochScoresHistory(request));
-            return DmmGrpcTransformer.epochScoresHistoryResponseToEpochScoresHistory(response);
-        }
-        catch (e) {
-            if (e instanceof InjectiveDmmRpc.GrpcWebError) {
-                throw new GrpcUnaryRequestException(new Error(e.toString()), {
-                    code: grpcErrorCodeToErrorCode(e.code),
-                    context: 'GetEpochScoresHistory',
-                    contextModule: this.module,
-                });
-            }
-            throw new GrpcUnaryRequestException(e, {
-                code: UnspecifiedErrorCode,
-                context: 'GetEpochScoresHistory',
-                contextModule: this.module,
-            });
-        }
-    }
-    async fetchTotalScores({ epochId, marketId, page, }) {
-        const request = InjectiveDmmRpc.GetTotalScoresRequest.create();
-        request.epochId = epochId;
-        request.marketId = marketId;
-        if (page) {
-            request.page = page;
-        }
-        try {
-            const response = await this.retry(() => this.client.GetTotalScores(request));
-            return DmmGrpcTransformer.totalScoresResponseToTotalScores(response);
-        }
-        catch (e) {
-            if (e instanceof InjectiveDmmRpc.GrpcWebError) {
-                throw new GrpcUnaryRequestException(new Error(e.toString()), {
-                    code: grpcErrorCodeToErrorCode(e.code),
-                    context: 'GetTotalScores',
-                    contextModule: this.module,
-                });
-            }
-            throw new GrpcUnaryRequestException(e, {
-                code: UnspecifiedErrorCode,
-                context: 'GetTotalScores',
-                contextModule: this.module,
-            });
-        }
-    }
-    async fetchTotalScoresHistory({ epochId, marketId, accountAddress, page, }) {
-        const request = InjectiveDmmRpc.GetTotalScoresHistoryRequest.create();
-        request.epochId = epochId;
-        request.marketId = marketId;
-        request.accountAddress = accountAddress;
-        if (page) {
-            request.page = page;
-        }
-        try {
-            const response = await this.retry(() => this.client.GetTotalScoresHistory(request));
-            return DmmGrpcTransformer.totalScoresHistoryResponseToTotalScoresHistory(response);
-        }
-        catch (e) {
-            if (e instanceof InjectiveDmmRpc.GrpcWebError) {
-                throw new GrpcUnaryRequestException(new Error(e.toString()), {
-                    code: grpcErrorCodeToErrorCode(e.code),
-                    context: 'GetTotalScoresHistory',
-                    contextModule: this.module,
-                });
-            }
-            throw new GrpcUnaryRequestException(e, {
-                code: UnspecifiedErrorCode,
-                context: 'GetTotalScoresHistory',
-                contextModule: this.module,
-            });
-        }
-    }
-    async fetchRewardsDistribution({ epochId, height, page, }) {
-        const request = InjectiveDmmRpc.GetRewardsDistributionRequest.create();
-        request.epochId = epochId;
-        if (height) {
-            request.height = height;
-        }
-        if (page) {
-            request.page = page;
-        }
-        try {
-            const response = await this.retry(() => this.client.GetRewardsDistribution(request));
-            return DmmGrpcTransformer.rewardsDistributionResponseToRewardsDistribution(response);
-        }
-        catch (e) {
-            if (e instanceof InjectiveDmmRpc.GrpcWebError) {
-                throw new GrpcUnaryRequestException(new Error(e.toString()), {
-                    code: grpcErrorCodeToErrorCode(e.code),
-                    context: 'GetRewardsDistribution',
-                    contextModule: this.module,
-                });
-            }
-            throw new GrpcUnaryRequestException(e, {
-                code: UnspecifiedErrorCode,
-                context: 'GetRewardsDistribution',
-                contextModule: this.module,
-            });
-        }
-    }
-    async fetchAccountVolumes({ epochId, accountAddress, }) {
-        const request = InjectiveDmmRpc.GetAccountVolumesRequest.create();
-        request.epochId = epochId;
-        request.accountAddress = accountAddress;
-        try {
-            const response = await this.retry(() => this.client.GetAccountVolumes(request));
-            return DmmGrpcTransformer.accountVolumesResponseToAccountVolumes(response);
-        }
-        catch (e) {
-            if (e instanceof InjectiveDmmRpc.GrpcWebError) {
-                throw new GrpcUnaryRequestException(new Error(e.toString()), {
-                    code: grpcErrorCodeToErrorCode(e.code),
-                    context: 'GetAccountVolumes',
-                    contextModule: this.module,
-                });
-            }
-            throw new GrpcUnaryRequestException(e, {
-                code: UnspecifiedErrorCode,
-                context: 'GetAccountVolumes',
-                contextModule: this.module,
-            });
-        }
-    }
-    async fetchRewardsEligibility({ epochId, accountAddress, }) {
-        const request = InjectiveDmmRpc.GetRewardsEligibilityRequest.create();
-        if (epochId) {
-            request.epochId = epochId;
-        }
-        if (accountAddress) {
-            request.accountAddress = accountAddress;
-        }
-        try {
-            const response = await this.retry(() => this.client.GetRewardsEligibility(request));
-            return DmmGrpcTransformer.rewardsEligibilityResponseToRewardsEligibility(response);
-        }
-        catch (e) {
-            if (e instanceof InjectiveDmmRpc.GrpcWebError) {
-                throw new GrpcUnaryRequestException(new Error(e.toString()), {
-                    code: grpcErrorCodeToErrorCode(e.code),
-                    context: 'GetRewardsEligibility',
-                    contextModule: this.module,
-                });
-            }
-            throw new GrpcUnaryRequestException(e, {
-                code: UnspecifiedErrorCode,
-                context: 'GetRewardsEligibility',
-                contextModule: this.module,
-            });
-        }
-    }
-    async fetchMarketRewardsRange({ epochId, marketId, }) {
-        const request = InjectiveDmmRpc.GetMarketRewardsRangeRequest.create();
-        request.epochId = epochId;
-        request.marketId = marketId;
-        try {
-            const response = await this.retry(() => this.client.GetMarketRewardRanges(request));
-            return DmmGrpcTransformer.marketRewardsRangeResponseToMarketRewardsRange(response);
-        }
-        catch (e) {
-            if (e instanceof InjectiveDmmRpc.GrpcWebError) {
-                throw new GrpcUnaryRequestException(new Error(e.toString()), {
-                    code: grpcErrorCodeToErrorCode(e.code),
-                    context: 'GetMarketRewardRanges',
-                    contextModule: this.module,
-                });
-            }
-            throw new GrpcUnaryRequestException(e, {
-                code: UnspecifiedErrorCode,
-                context: 'GetMarketRewardRanges',
-                contextModule: this.module,
-            });
-        }
-    }
-}

package/dist/esm/client/olp/grpc/index.d.ts

@@ -1,3 +0,0 @@
-import { OLPGrpcApi } from './OLPGrpcApi.js';
-export { OLPGrpcApi, OLPGrpcApi as DmmGrpcApi };
-export type * from './types/index.js';

package/dist/esm/client/olp/grpc/index.js

@@ -1,2 +0,0 @@
-import { OLPGrpcApi } from './OLPGrpcApi.js';
-export { OLPGrpcApi, OLPGrpcApi as DmmGrpcApi };

package/dist/esm/client/olp/grpc/transformers/index.d.ts

@@ -1,22 +0,0 @@
-import type { InjectiveDmmRpc } from '@injectivelabs/olp-proto-ts';
-import type { GrpcEpochV2, EpochV2, MarketReward, EligibleAddress, EligibleAddresses, EpochScoresHistory, GrpcMarketReward, GrpcEligibleAddress, GrpcTotalScore, EpochScores, TotalScore, AccountVolume, TotalScores, GrpcEpochScore, EpochScore, TotalScoresHistory, GrpcRewardDistribution, RewardsDistribution, RewardDistribution, RewardsEligibility, GrpcAccountVolume, MinMaxRewards } from '../types/index.js';
-export declare class DmmGrpcTransformer {
-    static epochsResponseToEpochs(response: InjectiveDmmRpc.GetEpochsResponse): EpochV2[];
-    static grpcEpochToEpoch(epoch: GrpcEpochV2): EpochV2;
-    static marketRewardsResponseToMarketRewards(response: InjectiveDmmRpc.GetMarketRewardsResponse): MarketReward[];
-    static grpcMarketRewardToMarketReward(marketReward: GrpcMarketReward): MarketReward;
-    static eligibleAddressesResponseToEligibleAddresses(response: InjectiveDmmRpc.GetEligibleAddressesResponse): EligibleAddresses;
-    static grpcEligibleAddresssesToEligibileAddresses(eligibleAddress: GrpcEligibleAddress): EligibleAddress;
-    static epochScoresResponseToEpochScores(response: InjectiveDmmRpc.GetEpochScoresResponse): EpochScores;
-    static grpcEpochScoresToEpochScores(score: GrpcEpochScore): EpochScore;
-    static epochScoresHistoryResponseToEpochScoresHistory(response: InjectiveDmmRpc.GetEpochScoresHistoryResponse): EpochScoresHistory;
-    static totalScoresResponseToTotalScores(response: InjectiveDmmRpc.GetTotalScoresResponse): TotalScores;
-    static grpcTotalScoresToTotalScores(score: GrpcTotalScore): TotalScore;
-    static totalScoresHistoryResponseToTotalScoresHistory(response: InjectiveDmmRpc.GetTotalScoresHistoryResponse): TotalScoresHistory;
-    static rewardsDistributionResponseToRewardsDistribution(response: InjectiveDmmRpc.GetRewardsDistributionResponse): RewardsDistribution;
-    static grpcRewardsDistributionToRewardsDistribution(reward: GrpcRewardDistribution): RewardDistribution;
-    static accountVolumesResponseToAccountVolumes(response: InjectiveDmmRpc.GetAccountVolumesResponse): AccountVolume[];
-    static grpcAccountVolumesToAccountVolumes(reward: GrpcAccountVolume): AccountVolume;
-    static rewardsEligibilityResponseToRewardsEligibility(response: InjectiveDmmRpc.GetRewardsEligibilityResponse): RewardsEligibility;
-    static marketRewardsRangeResponseToMarketRewardsRange(response: InjectiveDmmRpc.GetMarketRewardsRangeResponse): MinMaxRewards;
-}

package/dist/esm/client/olp/grpc/transformers/index.js

@@ -1,218 +0,0 @@
-export class DmmGrpcTransformer {
-    static epochsResponseToEpochs(response) {
-        const epochs = response.epochs;
-        return epochs.map(DmmGrpcTransformer.grpcEpochToEpoch);
-    }
-    static grpcEpochToEpoch(epoch) {
-        return {
-            epochId: epoch.epochId,
-            status: epoch.status,
-            startHeight: epoch.startHeight,
-            endHeight: epoch.endHeight,
-            snapshotCount: epoch.snapshotCount,
-            resultCount: epoch.resultCount,
-            config: epoch.config,
-            createdAt: epoch.createdAt,
-            updatedAt: epoch.updatedAt,
-        };
-    }
-    static marketRewardsResponseToMarketRewards(response) {
-        const rewards = response.rewards;
-        return rewards.map(DmmGrpcTransformer.grpcMarketRewardToMarketReward);
-    }
-    static grpcMarketRewardToMarketReward(marketReward) {
-        return {
-            epochId: marketReward.epochId,
-            marketId: marketReward.marketId,
-            height: marketReward.height,
-            reward: marketReward.reward,
-            rewardPercentage: marketReward.rewardPercentage,
-            liquidity: marketReward.liquidity,
-            startDate: marketReward.startDate,
-            endDate: marketReward.endDate,
-            totalScore: marketReward.totalScore,
-            createdAt: marketReward.createdAt,
-            updatedAt: marketReward.updatedAt,
-            miniEpochsReward: marketReward.miniEpochsReward,
-        };
-    }
-    static eligibleAddressesResponseToEligibleAddresses(response) {
-        const addresses = response.addresses;
-        return {
-            next: response.next,
-            addresses: addresses.map(DmmGrpcTransformer.grpcEligibleAddresssesToEligibileAddresses),
-        };
-    }
-    static grpcEligibleAddresssesToEligibileAddresses(eligibleAddress) {
-        return {
-            epochId: eligibleAddress.epochId,
-            accountAddress: eligibleAddress.accountAddress,
-            height: eligibleAddress.height,
-            source: eligibleAddress.source,
-            createdAt: eligibleAddress.createdAt,
-            updatedAt: eligibleAddress.updatedAt,
-        };
-    }
-    static epochScoresResponseToEpochScores(response) {
-        const scores = response.scores;
-        return {
-            next: response.next,
-            scores: scores.map(DmmGrpcTransformer.grpcEpochScoresToEpochScores),
-        };
-    }
-    static grpcEpochScoresToEpochScores(score) {
-        return {
-            epochId: score.epochId,
-            accountAddress: score.accountAddress,
-            height: score.height,
-            blockTime: score.blockTime,
-            startHeight: score.startHeight,
-            liquidityScore: score.liquidityScore,
-            liquidityScorePonderated: score.liquidityScorePonderated,
-            uptimeScore: score.uptimeScore,
-            uptimeScorePonderated: score.uptimeScorePonderated,
-            uptimePercentage: score.uptimePercentage,
-            volumeScore: score.volumeScore,
-            volumeScorePonderated: score.volumeScorePonderated,
-            totalScore: score.totalScore,
-            volume: score.volume,
-            makerVolume: score.makerVolume,
-            takerVolume: score.takerVolume,
-            reward: score.reward,
-            rewardPercentage: score.rewardPercentage,
-            qualifies: score.qualifies,
-            volumePercentage: score.volumePercentage,
-            createdAt: score.createdAt,
-            updatedAt: score.updatedAt,
-        };
-    }
-    static epochScoresHistoryResponseToEpochScoresHistory(response) {
-        const scores = response.scores;
-        return {
-            next: response.next,
-            scores: scores.map(DmmGrpcTransformer.grpcEpochScoresToEpochScores),
-        };
-    }
-    static totalScoresResponseToTotalScores(response) {
-        const scores = response.scores;
-        return {
-            next: response.next,
-            scores: scores.map(DmmGrpcTransformer.grpcTotalScoresToTotalScores),
-        };
-    }
-    static grpcTotalScoresToTotalScores(score) {
-        return {
-            epochId: score.epochId,
-            marketId: score.marketId,
-            accountAddress: score.accountAddress,
-            height: score.height,
-            startHeight: score.startHeight,
-            blockTime: score.blockTime,
-            bid: score.bid,
-            ask: score.ask,
-            depth: score.depth,
-            snapshotCount: score.snapshotCount,
-            liquidityScore: score.liquidityScore,
-            liquidityScorePonderated: score.liquidityScorePonderated,
-            uptimeScore: score.uptimeScore,
-            uptimeScorePonderated: score.uptimeScorePonderated,
-            uptimePercentage: score.uptimePercentage,
-            startVolume: score.startVolume,
-            currentVolume: score.currentVolume,
-            volume: score.volume,
-            volumeScore: score.volumeScore,
-            volumeScorePonderated: score.volumeScorePonderated,
-            takerStartVolume: score.takerStartVolume,
-            takerCurrentVolume: score.takerCurrentVolume,
-            takerVolume: score.takerVolume,
-            makerStartVolume: score.makerStartVolume,
-            makerCurrentVolume: score.makerCurrentVolume,
-            makerVolume: score.makerVolume,
-            totalScore: score.totalScore,
-            reward: score.reward,
-            rewardPercentage: score.rewardPercentage,
-            createdAt: score.createdAt,
-            updatedAt: score.updatedAt,
-        };
-    }
-    static totalScoresHistoryResponseToTotalScoresHistory(response) {
-        const scores = response.scores;
-        return {
-            next: response.next,
-            scores: scores.map(DmmGrpcTransformer.grpcTotalScoresToTotalScores),
-        };
-    }
-    static rewardsDistributionResponseToRewardsDistribution(response) {
-        const rewards = response.rewards;
-        return {
-            next: response.next,
-            rewards: rewards.map(DmmGrpcTransformer.grpcRewardsDistributionToRewardsDistribution),
-        };
-    }
-    static grpcRewardsDistributionToRewardsDistribution(reward) {
-        return {
-            epochId: reward.epochId,
-            accountAddress: reward.accountAddress,
-            height: reward.height,
-            startHeight: reward.startHeight,
-            blockTime: reward.blockTime,
-            depth: reward.depth,
-            reward: reward.reward,
-            createdAt: reward.createdAt,
-            updatedAt: reward.updatedAt,
-        };
-    }
-    static accountVolumesResponseToAccountVolumes(response) {
-        const volumes = response.volumes;
-        return volumes.map(DmmGrpcTransformer.grpcAccountVolumesToAccountVolumes);
-    }
-    static grpcAccountVolumesToAccountVolumes(reward) {
-        return {
-            epochId: reward.epochId,
-            accountAddress: reward.accountAddress,
-            height: reward.height,
-            blockTime: reward.blockTime,
-            date: reward.date,
-            dateTimestamp: reward.dateTimestamp,
-            volume: reward.volume,
-            takerVolume: reward.takerVolume,
-            makerVolume: reward.makerVolume,
-            volumePercentage: reward.volumePercentage,
-            makerVolumePercentage: reward.makerVolumePercentage,
-            takerVolumePercentage: reward.takerVolumePercentage,
-            dailyVolume: reward.dailyVolume,
-            dailyMakerVolume: reward.dailyMakerVolume,
-            dailyTakerVolume: reward.dailyTakerVolume,
-            dailyVolumePercentage: reward.dailyVolumePercentage,
-            dailyMakerVolumePercentage: reward.dailyMakerVolumePercentage,
-            dailyTakerVolumePercentage: reward.dailyTakerVolumePercentage,
-            dailyQualified: reward.dailyQualified,
-            createdAt: reward.createdAt,
-            updatedAt: reward.updatedAt,
-        };
-    }
-    static rewardsEligibilityResponseToRewardsEligibility(response) {
-        const volumes = response.volumes;
-        return {
-            volumes: volumes.map(DmmGrpcTransformer.grpcAccountVolumesToAccountVolumes),
-            currentMakerVolumePercentage: response.currentMakerVolumePercentage,
-            averageDailyMakerVolumePercentage: response.averageDailyMakerVolumePercentage,
-            eligibleForNextEpoch: response.eligibleForNextEpoch,
-            eligibleForCurrentEpoch: response.eligibleForCurrentEpoch,
-            estimatedReward: response.estimatedReward,
-            updatedAt: response.updatedAt,
-        };
-    }
-    static marketRewardsRangeResponseToMarketRewardsRange(response) {
-        const formattedMinCurrentEpochRewards = {};
-        const formattedMaxCurrentEpochRewards = {};
-        response.ranges.forEach((item) => {
-            formattedMinCurrentEpochRewards[item.marketId] = item.min;
-            formattedMaxCurrentEpochRewards[item.marketId] = item.max;
-        });
-        return {
-            minRewards: formattedMinCurrentEpochRewards,
-            maxRewards: formattedMaxCurrentEpochRewards,
-        };
-    }
-}