@injectivelabs/sdk-ts 1.16.38-alpha.7 → 1.16.38

package/dist/cjs/client/abacus/grpc/AbacusGrpcApi.d.ts

@@ -0,0 +1,10 @@
+import { InjectiveAbacusRpc } from '@injectivelabs/abacus-proto-ts';
+import BaseGrpcConsumer from '../../base/BaseGrpcConsumer.js';
+export declare class AbacusGrpcApi extends BaseGrpcConsumer {
+    protected module: string;
+    protected client: InjectiveAbacusRpc.PointsSvcClientImpl;
+    constructor(endpoint: string);
+    fetchAccountLatestPoints(address: string): Promise<InjectiveAbacusRpc.PointsLatestForAccountResponse>;
+    fetchAccountDailyPoints(address: string, daysLimit?: number): Promise<InjectiveAbacusRpc.HistoricalPointsStatsRow[]>;
+    fetchAccountWeeklyPoints(address: string, weeksLimit?: number): Promise<InjectiveAbacusRpc.HistoricalPointsStatsRow[]>;
+}

package/dist/cjs/client/abacus/grpc/AbacusGrpcApi.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbacusGrpcApi = void 0;
+const abacus_proto_ts_1 = require("@injectivelabs/abacus-proto-ts");
+const exceptions_1 = require("@injectivelabs/exceptions");
+const BaseGrpcConsumer_js_1 = __importDefault(require("../../base/BaseGrpcConsumer.js"));
+const index_js_1 = require("./transformers/index.js");
+class AbacusGrpcApi extends BaseGrpcConsumer_js_1.default {
+    module = exceptions_1.IndexerErrorModule.Abacus;
+    client;
+    constructor(endpoint) {
+        super(endpoint);
+        this.client = new abacus_proto_ts_1.InjectiveAbacusRpc.PointsSvcClientImpl(this.getGrpcWebImpl(endpoint));
+    }
+    async fetchAccountLatestPoints(address) {
+        const request = abacus_proto_ts_1.InjectiveAbacusRpc.PointsLatestForAccountRequest.create();
+        request.accountAddress = address;
+        try {
+            const response = await this.retry(() => this.client.PointsLatestForAccount(request));
+            return index_js_1.AbacusGrpcTransformer.grpcPointsLatestToPointsLatest(response);
+        }
+        catch (e) {
+            if (e instanceof abacus_proto_ts_1.InjectiveAbacusRpc.GrpcWebError) {
+                throw new exceptions_1.GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: (0, exceptions_1.grpcErrorCodeToErrorCode)(e.code),
+                    context: 'PointsStatsLatestForAccount',
+                    contextModule: this.module,
+                });
+            }
+            throw new exceptions_1.GrpcUnaryRequestException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'PointsStatsLatestForAccount',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchAccountDailyPoints(address, daysLimit) {
+        const request = abacus_proto_ts_1.InjectiveAbacusRpc.PointsStatsDailyForAccountRequest.create();
+        request.accountAddress = address;
+        if (daysLimit) {
+            request.daysLimit = daysLimit.toString();
+        }
+        try {
+            const response = await this.retry(() => this.client.PointsStatsDailyForAccount(request));
+            return index_js_1.AbacusGrpcTransformer.grpcPointsStatsDailyToPointsStatsDaily(response);
+        }
+        catch (e) {
+            if (e instanceof abacus_proto_ts_1.InjectiveAbacusRpc.GrpcWebError) {
+                throw new exceptions_1.GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: (0, exceptions_1.grpcErrorCodeToErrorCode)(e.code),
+                    context: 'PointsStatsDailyForAccount',
+                    contextModule: this.module,
+                });
+            }
+            throw new exceptions_1.GrpcUnaryRequestException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'PointsStatsDailyForAccount',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchAccountWeeklyPoints(address, weeksLimit) {
+        const request = abacus_proto_ts_1.InjectiveAbacusRpc.PointsStatsWeeklyForAccountRequest.create();
+        request.accountAddress = address;
+        if (weeksLimit) {
+            request.weeksLimit = weeksLimit.toString();
+        }
+        try {
+            const response = await this.retry(() => this.client.PointsStatsWeeklyForAccount(request));
+            return index_js_1.AbacusGrpcTransformer.grpcPointsStatsWeeklyToPointsStatsWeekly(response);
+        }
+        catch (e) {
+            if (e instanceof abacus_proto_ts_1.InjectiveAbacusRpc.GrpcWebError) {
+                throw new exceptions_1.GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: (0, exceptions_1.grpcErrorCodeToErrorCode)(e.code),
+                    context: 'PointsStatsWeeklyForAccount',
+                    contextModule: this.module,
+                });
+            }
+            throw new exceptions_1.GrpcUnaryRequestException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'PointsStatsWeeklyForAccount',
+                contextModule: this.module,
+            });
+        }
+    }
+}
+exports.AbacusGrpcApi = AbacusGrpcApi;

package/dist/cjs/client/abacus/grpc/index.d.ts

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

package/dist/cjs/client/abacus/grpc/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbacusGrpcApi = void 0;
+const AbacusGrpcApi_js_1 = require("./AbacusGrpcApi.js");
+Object.defineProperty(exports, "AbacusGrpcApi", { enumerable: true, get: function () { return AbacusGrpcApi_js_1.AbacusGrpcApi; } });

package/dist/cjs/client/abacus/grpc/transformers/index.d.ts

@@ -0,0 +1,6 @@
+import type { InjectiveAbacusRpc } from '@injectivelabs/abacus-proto-ts';
+export declare class AbacusGrpcTransformer {
+    static grpcPointsStatsDailyToPointsStatsDaily(response: InjectiveAbacusRpc.HistoricalPointsStatsRowCollection): InjectiveAbacusRpc.HistoricalPointsStatsRow[];
+    static grpcPointsStatsWeeklyToPointsStatsWeekly(response: InjectiveAbacusRpc.HistoricalPointsStatsRowCollection): InjectiveAbacusRpc.HistoricalPointsStatsRow[];
+    static grpcPointsLatestToPointsLatest(response: InjectiveAbacusRpc.PointsLatestForAccountResponse): InjectiveAbacusRpc.PointsLatestForAccountResponse;
+}

package/dist/cjs/client/abacus/grpc/transformers/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbacusGrpcTransformer = void 0;
+class AbacusGrpcTransformer {
+    static grpcPointsStatsDailyToPointsStatsDaily(response) {
+        return response.rows;
+    }
+    static grpcPointsStatsWeeklyToPointsStatsWeekly(response) {
+        return response.rows;
+    }
+    static grpcPointsLatestToPointsLatest(response) {
+        return response;
+    }
+}
+exports.AbacusGrpcTransformer = AbacusGrpcTransformer;

package/dist/cjs/client/abacus/index.d.ts

@@ -0,0 +1 @@
+export * from './grpc/index.js';

package/dist/cjs/client/abacus/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./grpc/index.js"), exports);

package/dist/cjs/client/base/BaseGrpcConsumer.d.ts

@@ -0,0 +1,11 @@
+import { GrpcWebImpl } from './GrpcWebImpl.js';
+import type { grpcPkg } from '../../utils/grpc.js';
+export default class BaseGrpcConsumer extends GrpcWebImpl {
+    protected module: string;
+    protected metadata?: grpcPkg.grpc.Metadata;
+    constructor(endpoint: string);
+    setMetadata(map: Record<string, string>): this;
+    clearMetadata(): void;
+    getGrpcWebImpl(endpoint: string): BaseGrpcConsumer;
+    protected retry<TResponse>(grpcCall: Function, retries?: number, delay?: number): Promise<TResponse>;
+}

package/dist/cjs/client/base/BaseGrpcConsumer.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const GrpcWebImpl_js_1 = require("./GrpcWebImpl.js");
+const grpc_js_1 = require("../../utils/grpc.js");
+class BaseGrpcConsumer extends GrpcWebImpl_js_1.GrpcWebImpl {
+    module = '';
+    metadata;
+    constructor(endpoint) {
+        super(endpoint, {
+            transport: (0, grpc_js_1.getGrpcTransport)(),
+        });
+    }
+    setMetadata(map) {
+        const metadata = new grpc_js_1.grpc.Metadata();
+        Object.keys(map).forEach((key) => metadata.set(key, map[key]));
+        this.metadata = metadata;
+        return this;
+    }
+    clearMetadata() {
+        this.metadata = undefined;
+    }
+    getGrpcWebImpl(endpoint) {
+        return new BaseGrpcConsumer(endpoint);
+    }
+    retry(grpcCall, retries = 3, delay = 1000) {
+        const retryGrpcCall = async (attempt = 1) => {
+            try {
+                return await grpcCall();
+            }
+            catch (e) {
+                if (attempt >= retries) {
+                    throw e;
+                }
+                return new Promise((resolve) => setTimeout(() => resolve(retryGrpcCall(attempt + 1)), delay * attempt));
+            }
+        };
+        return retryGrpcCall();
+    }
+}
+exports.default = BaseGrpcConsumer;

package/dist/cjs/client/base/BaseGrpcWebConsumer.d.ts

@@ -0,0 +1,9 @@
+import { GrpcWebImpl } from './GrpcWebImpl.js';
+/**
+ * @hidden
+ */
+export default class BaseGrpcWebConsumer extends GrpcWebImpl {
+    protected module: string;
+    constructor(endpoint: string);
+    static getGrpcWebImpl: (endpoint: string) => BaseGrpcWebConsumer;
+}

package/dist/cjs/client/base/BaseGrpcWebConsumer.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const GrpcWebImpl_js_1 = require("./GrpcWebImpl.js");
+const grpc_js_1 = require("../../utils/grpc.js");
+/**
+ * @hidden
+ */
+class BaseGrpcWebConsumer extends GrpcWebImpl_js_1.GrpcWebImpl {
+    module = '';
+    constructor(endpoint) {
+        super(endpoint, {
+            transport: (0, grpc_js_1.getGrpcTransport)(),
+            setCookieMetadata: true,
+        });
+    }
+    static getGrpcWebImpl = (endpoint) => new BaseGrpcWebConsumer(endpoint);
+}
+exports.default = BaseGrpcWebConsumer;

package/dist/cjs/client/base/BaseIndexerGrpcConsumer.d.ts

@@ -0,0 +1,11 @@
+import { GrpcWebImpl } from './IndexerGrpcWebImpl.js';
+import type { grpcPkg } from '../../utils/grpc.js';
+export default class BaseIndexerGrpcConsumer extends GrpcWebImpl {
+    protected module: string;
+    protected metadata?: grpcPkg.grpc.Metadata;
+    constructor(endpoint: string);
+    getGrpcWebImpl(endpoint: string): BaseIndexerGrpcConsumer;
+    setMetadata(map: Record<string, string>): this;
+    clearMetadata(): void;
+    protected retry<TResponse>(grpcCall: Function, retries?: number, delay?: number): Promise<TResponse>;
+}

package/dist/cjs/client/base/BaseIndexerGrpcConsumer.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const IndexerGrpcWebImpl_js_1 = require("./IndexerGrpcWebImpl.js");
+const grpc_js_1 = require("../../utils/grpc.js");
+class BaseIndexerGrpcConsumer extends IndexerGrpcWebImpl_js_1.GrpcWebImpl {
+    module = '';
+    metadata;
+    constructor(endpoint) {
+        super(endpoint, {
+            transport: (0, grpc_js_1.getGrpcTransport)(),
+        });
+    }
+    getGrpcWebImpl(endpoint) {
+        return new BaseIndexerGrpcConsumer(endpoint);
+    }
+    setMetadata(map) {
+        const metadata = new grpc_js_1.grpc.Metadata();
+        Object.keys(map).forEach((key) => metadata.set(key, map[key]));
+        this.metadata = metadata;
+        return this;
+    }
+    clearMetadata() {
+        this.metadata = undefined;
+    }
+    retry(grpcCall, retries = 3, delay = 1000) {
+        const retryGrpcCall = async (attempt = 1) => {
+            try {
+                return await grpcCall();
+            }
+            catch (e) {
+                if (attempt >= retries) {
+                    throw e;
+                }
+                return new Promise((resolve) => setTimeout(() => resolve(retryGrpcCall(attempt + 1)), delay * attempt));
+            }
+        };
+        return retryGrpcCall();
+    }
+}
+exports.default = BaseIndexerGrpcConsumer;

package/dist/cjs/client/base/BaseIndexerGrpcWebConsumer.d.ts

@@ -0,0 +1,9 @@
+import { GrpcWebImpl } from './IndexerGrpcWebImpl.js';
+/**
+ * @hidden
+ */
+export default class BaseIndexerGrpcWebConsumer extends GrpcWebImpl {
+    protected module: string;
+    constructor(endpoint: string, metadata?: Record<string, string>);
+}
+export declare const getGrpcIndexerWebImpl: (endpoint: string, metadata?: Record<string, string>) => BaseIndexerGrpcWebConsumer;

package/dist/cjs/client/base/BaseIndexerGrpcWebConsumer.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGrpcIndexerWebImpl = void 0;
+const IndexerGrpcWebImpl_js_1 = require("./IndexerGrpcWebImpl.js");
+const grpc_js_1 = require("../../utils/grpc.js");
+/**
+ * @hidden
+ */
+class BaseIndexerGrpcWebConsumer extends IndexerGrpcWebImpl_js_1.GrpcWebImpl {
+    module = '';
+    constructor(endpoint, metadata = {}) {
+        const grpcMetadata = new grpc_js_1.grpc.Metadata();
+        Object.keys(metadata).forEach((key) => grpcMetadata.set(key, metadata[key]));
+        super(endpoint, { transport: (0, grpc_js_1.getGrpcTransport)(), metadata: grpcMetadata });
+    }
+}
+exports.default = BaseIndexerGrpcWebConsumer;
+const getGrpcIndexerWebImpl = (endpoint, metadata) => new BaseIndexerGrpcWebConsumer(endpoint, metadata);
+exports.getGrpcIndexerWebImpl = getGrpcIndexerWebImpl;

package/dist/cjs/client/base/BaseRestConsumer.d.ts

@@ -0,0 +1,6 @@
+import { HttpRestClient } from '@injectivelabs/utils';
+/**
+ * @hidden
+ */
+export default class BaseRestConsumer extends HttpRestClient {
+}

package/dist/cjs/client/base/BaseRestConsumer.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@injectivelabs/utils");
+/**
+ * @hidden
+ */
+class BaseRestConsumer extends utils_1.HttpRestClient {
+}
+exports.default = BaseRestConsumer;

package/dist/cjs/client/base/GrpcWebImpl.d.ts

@@ -0,0 +1,27 @@
+import type { grpcPkg } from './../../utils/grpc.js';
+interface UnaryMethodDefinitionR extends grpcPkg.grpc.UnaryMethodDefinition<any, any> {
+    requestStream: any;
+    responseStream: any;
+}
+type UnaryMethodDefinition = UnaryMethodDefinitionR;
+export interface Rpc {
+    unary<T extends UnaryMethodDefinition>(methodDesc: T, request: any, metadata: grpcPkg.grpc.Metadata | undefined): Promise<any>;
+}
+export declare class GrpcWebError extends Error {
+    code: grpcPkg.grpc.Code;
+    metadata: grpcPkg.grpc.Metadata;
+    constructor(message: string, code: grpcPkg.grpc.Code, metadata: grpcPkg.grpc.Metadata);
+}
+export declare class GrpcWebImpl {
+    private host;
+    private options;
+    constructor(host: string, options: {
+        transport?: grpcPkg.grpc.TransportFactory;
+        debug?: boolean;
+        setCookieMetadata?: boolean;
+        metadata?: grpcPkg.grpc.Metadata;
+        upStreamRetryCodes?: number[];
+    });
+    unary<T extends UnaryMethodDefinition>(methodDesc: T, _request: any, metadata: grpcPkg.grpc.Metadata | undefined): Promise<any>;
+}
+export {};

package/dist/cjs/client/base/GrpcWebImpl.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GrpcWebImpl = exports.GrpcWebError = void 0;
+const browser_headers_1 = require("browser-headers");
+const grpc_js_1 = require("./../../utils/grpc.js");
+class GrpcWebError extends Error {
+    code;
+    metadata;
+    constructor(message, code, metadata) {
+        super(message);
+        this.code = code;
+        this.metadata = metadata;
+    }
+}
+exports.GrpcWebError = GrpcWebError;
+class GrpcWebImpl {
+    host;
+    options;
+    constructor(host, options) {
+        this.host = host;
+        this.options = options;
+    }
+    unary(methodDesc, _request, metadata) {
+        const request = { ..._request, ...methodDesc.requestType };
+        const actualMetadata = new browser_headers_1.BrowserHeaders({
+            ...(metadata?.headersMap || {}),
+            ...(this.options?.metadata?.headersMap || {}),
+        });
+        return new Promise((resolve, reject) => {
+            grpc_js_1.grpc.unary(methodDesc, {
+                request,
+                host: this.host,
+                metadata: actualMetadata,
+                transport: this.options.transport,
+                debug: this.options.debug,
+                onEnd: (response) => {
+                    if (response.status === grpc_js_1.grpc.Code.OK) {
+                        return resolve(response.message.toObject());
+                    }
+                    return reject(new GrpcWebError(response.statusMessage, response.status, response.trailers));
+                },
+            });
+        });
+    }
+}
+exports.GrpcWebImpl = GrpcWebImpl;

package/dist/cjs/client/base/IndexerGrpcWebImpl.d.ts

@@ -0,0 +1,30 @@
+import { Observable } from 'rxjs';
+import type { grpcPkg } from '../../utils/grpc.js';
+interface UnaryMethodDefinitionR extends grpcPkg.grpc.UnaryMethodDefinition<any, any> {
+    requestStream: any;
+    responseStream: any;
+}
+type UnaryMethodDefinition = UnaryMethodDefinitionR;
+export interface Rpc {
+    unary<T extends UnaryMethodDefinition>(methodDesc: T, request: any, metadata: grpcPkg.grpc.Metadata | undefined): Promise<any>;
+    invoke<T extends UnaryMethodDefinition>(methodDesc: T, request: any, metadata: grpcPkg.grpc.Metadata | undefined): Observable<any>;
+}
+export declare class GrpcWebError extends Error {
+    code: grpcPkg.grpc.Code;
+    metadata: grpcPkg.grpc.Metadata;
+    constructor(message: string, code: grpcPkg.grpc.Code, metadata: grpcPkg.grpc.Metadata);
+}
+export declare class GrpcWebImpl {
+    private host;
+    private options;
+    constructor(host: string, options: {
+        transport?: grpcPkg.grpc.TransportFactory;
+        streamingTransport?: grpcPkg.grpc.TransportFactory;
+        debug?: boolean;
+        metadata?: grpcPkg.grpc.Metadata;
+        upStreamRetryCodes?: number[];
+    });
+    unary<T extends UnaryMethodDefinition>(methodDesc: T, _request: any, metadata: grpcPkg.grpc.Metadata | undefined): Promise<any>;
+    invoke<T extends UnaryMethodDefinition>(methodDesc: T, _request: any, metadata: grpcPkg.grpc.Metadata | undefined): Observable<any>;
+}
+export {};

package/dist/cjs/client/base/IndexerGrpcWebImpl.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GrpcWebImpl = exports.GrpcWebError = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const browser_headers_1 = require("browser-headers");
+const grpc_js_1 = require("../../utils/grpc.js");
+class GrpcWebError extends Error {
+    code;
+    metadata;
+    constructor(message, code, metadata) {
+        super(message);
+        this.code = code;
+        this.metadata = metadata;
+    }
+}
+exports.GrpcWebError = GrpcWebError;
+class GrpcWebImpl {
+    host;
+    options;
+    constructor(host, options) {
+        this.host = host;
+        this.options = options;
+    }
+    unary(methodDesc, _request, metadata) {
+        const request = { ..._request, ...methodDesc.requestType };
+        const metadataWithCookieMetadata = new browser_headers_1.BrowserHeaders({
+            ...(metadata?.headersMap || {}),
+            ...(this.options?.metadata?.headersMap || {}),
+        });
+        return new Promise((resolve, reject) => {
+            grpc_js_1.grpc.unary(methodDesc, {
+                request,
+                host: this.host,
+                metadata: metadataWithCookieMetadata,
+                transport: this.options.transport,
+                debug: this.options.debug,
+                onEnd: (response) => {
+                    if (response.status === grpc_js_1.grpc.Code.OK) {
+                        return resolve(response.message.toObject());
+                    }
+                    return reject(new GrpcWebError(response.statusMessage, response.status, response.trailers));
+                },
+            });
+        });
+    }
+    invoke(methodDesc, _request, metadata) {
+        const upStreamCodes = this.options.upStreamRetryCodes || [];
+        const DEFAULT_TIMEOUT_TIME = 3_000;
+        const request = { ..._request, ...methodDesc.requestType };
+        const actualMetadata = new browser_headers_1.BrowserHeaders({
+            ...(metadata?.headersMap || {}),
+            ...(this.options?.metadata?.headersMap || {}),
+        });
+        return new rxjs_1.Observable((observer) => {
+            const upStream = () => {
+                const client = grpc_js_1.grpc.invoke(methodDesc, {
+                    host: this.host,
+                    request,
+                    transport: this.options.streamingTransport || this.options.transport,
+                    metadata: actualMetadata,
+                    debug: this.options.debug,
+                    onMessage: (next) => observer.next(next),
+                    onEnd: (code, message, trailers) => {
+                        if (code === 0) {
+                            observer.complete();
+                        }
+                        else if (upStreamCodes.includes(code)) {
+                            setTimeout(upStream, DEFAULT_TIMEOUT_TIME);
+                        }
+                        else {
+                            const err = new Error(message);
+                            err.code = code;
+                            err.metadata = trailers;
+                            observer.error(err);
+                        }
+                    },
+                });
+                observer.add(() => client.close());
+            };
+            upStream();
+        }).pipe((0, operators_1.share)());
+    }
+}
+exports.GrpcWebImpl = GrpcWebImpl;

package/dist/cjs/client/chain/ChainGrpcClient.d.ts

@@ -0,0 +1,43 @@
+import { ChainGrpcGovApi } from './grpc/ChainGrpcGovApi.js';
+import { ChainGrpcIbcApi } from './grpc/ChainGrpcIbcApi.js';
+import { ChainGrpcEvmApi } from './grpc/ChainGrpcEvmApi.js';
+import { ChainGrpcAuthApi } from './grpc/ChainGrpcAuthApi.js';
+import { ChainGrpcBankApi } from './grpc/ChainGrpcBankApi.js';
+import { ChainGrpcMintApi } from './grpc/ChainGrpcMintApi.js';
+import { ChainGrpcWasmApi } from './grpc/ChainGrpcWasmApi.js';
+import { ChainGrpcPeggyApi } from './grpc/ChainGrpcPeggyApi.js';
+import { ChainGrpcWasmXApi } from './grpc/ChainGrpcWasmXApi.js';
+import { ChainGrpcErc20Api } from './grpc/ChainGrpcErc20Api.js';
+import { ChainGrpcOracleApi } from './grpc/ChainGrpcOracleApi.js';
+import { ChainGrpcAuctionApi } from './grpc/ChainGrpcAuctionApi.js';
+import { ChainGrpcStakingApi } from './grpc/ChainGrpcStakingApi.js';
+import { ChainGrpcExchangeApi } from './grpc/ChainGrpcExchangeApi.js';
+import { ChainGrpcPermissionsApi } from './grpc/ChainGrpcPermissionsApi.js';
+import { ChainGrpcDistributionApi } from './grpc/ChainGrpcDistributionApi.js';
+import { ChainGrpcTokenFactoryApi } from './grpc/ChainGrpcTokenFactoryApi.js';
+import { ChainGrpcInsuranceFundApi } from './grpc/ChainGrpcInsuranceFundApi.js';
+/**
+ * @category Chain Grpc API
+ * @hidden
+ */
+export declare class ChainGrpcClient {
+    gov: ChainGrpcGovApi;
+    ibc: ChainGrpcIbcApi;
+    evm: ChainGrpcEvmApi;
+    auth: ChainGrpcAuthApi;
+    bank: ChainGrpcBankApi;
+    mint: ChainGrpcMintApi;
+    wasm: ChainGrpcWasmApi;
+    peggy: ChainGrpcPeggyApi;
+    wasmX: ChainGrpcWasmXApi;
+    erc20: ChainGrpcErc20Api;
+    oracle: ChainGrpcOracleApi;
+    auction: ChainGrpcAuctionApi;
+    staking: ChainGrpcStakingApi;
+    exchange: ChainGrpcExchangeApi;
+    permissions: ChainGrpcPermissionsApi;
+    distribution: ChainGrpcDistributionApi;
+    tokenfactory: ChainGrpcTokenFactoryApi;
+    insuranceFund: ChainGrpcInsuranceFundApi;
+    constructor(endpoint: string);
+}

package/dist/cjs/client/chain/ChainGrpcClient.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChainGrpcClient = void 0;
+const ChainGrpcGovApi_js_1 = require("./grpc/ChainGrpcGovApi.js");
+const ChainGrpcIbcApi_js_1 = require("./grpc/ChainGrpcIbcApi.js");
+const ChainGrpcEvmApi_js_1 = require("./grpc/ChainGrpcEvmApi.js");
+const ChainGrpcAuthApi_js_1 = require("./grpc/ChainGrpcAuthApi.js");
+const ChainGrpcBankApi_js_1 = require("./grpc/ChainGrpcBankApi.js");
+const ChainGrpcMintApi_js_1 = require("./grpc/ChainGrpcMintApi.js");
+const ChainGrpcWasmApi_js_1 = require("./grpc/ChainGrpcWasmApi.js");
+const ChainGrpcPeggyApi_js_1 = require("./grpc/ChainGrpcPeggyApi.js");
+const ChainGrpcWasmXApi_js_1 = require("./grpc/ChainGrpcWasmXApi.js");
+const ChainGrpcErc20Api_js_1 = require("./grpc/ChainGrpcErc20Api.js");
+const ChainGrpcOracleApi_js_1 = require("./grpc/ChainGrpcOracleApi.js");
+const ChainGrpcAuctionApi_js_1 = require("./grpc/ChainGrpcAuctionApi.js");
+const ChainGrpcStakingApi_js_1 = require("./grpc/ChainGrpcStakingApi.js");
+const ChainGrpcExchangeApi_js_1 = require("./grpc/ChainGrpcExchangeApi.js");
+const ChainGrpcPermissionsApi_js_1 = require("./grpc/ChainGrpcPermissionsApi.js");
+const ChainGrpcDistributionApi_js_1 = require("./grpc/ChainGrpcDistributionApi.js");
+const ChainGrpcTokenFactoryApi_js_1 = require("./grpc/ChainGrpcTokenFactoryApi.js");
+const ChainGrpcInsuranceFundApi_js_1 = require("./grpc/ChainGrpcInsuranceFundApi.js");
+/**
+ * @category Chain Grpc API
+ * @hidden
+ */
+class ChainGrpcClient {
+    gov;
+    ibc;
+    evm;
+    auth;
+    bank;
+    mint;
+    wasm;
+    peggy;
+    wasmX;
+    erc20;
+    oracle;
+    auction;
+    staking;
+    exchange;
+    permissions;
+    distribution;
+    tokenfactory;
+    insuranceFund;
+    constructor(endpoint) {
+        this.evm = new ChainGrpcEvmApi_js_1.ChainGrpcEvmApi(endpoint);
+        this.gov = new ChainGrpcGovApi_js_1.ChainGrpcGovApi(endpoint);
+        this.ibc = new ChainGrpcIbcApi_js_1.ChainGrpcIbcApi(endpoint);
+        this.auth = new ChainGrpcAuthApi_js_1.ChainGrpcAuthApi(endpoint);
+        this.bank = new ChainGrpcBankApi_js_1.ChainGrpcBankApi(endpoint);
+        this.mint = new ChainGrpcMintApi_js_1.ChainGrpcMintApi(endpoint);
+        this.wasm = new ChainGrpcWasmApi_js_1.ChainGrpcWasmApi(endpoint);
+        this.erc20 = new ChainGrpcErc20Api_js_1.ChainGrpcErc20Api(endpoint);
+        this.peggy = new ChainGrpcPeggyApi_js_1.ChainGrpcPeggyApi(endpoint);
+        this.wasmX = new ChainGrpcWasmXApi_js_1.ChainGrpcWasmXApi(endpoint);
+        this.oracle = new ChainGrpcOracleApi_js_1.ChainGrpcOracleApi(endpoint);
+        this.auction = new ChainGrpcAuctionApi_js_1.ChainGrpcAuctionApi(endpoint);
+        this.staking = new ChainGrpcStakingApi_js_1.ChainGrpcStakingApi(endpoint);
+        this.exchange = new ChainGrpcExchangeApi_js_1.ChainGrpcExchangeApi(endpoint);
+        this.permissions = new ChainGrpcPermissionsApi_js_1.ChainGrpcPermissionsApi(endpoint);
+        this.distribution = new ChainGrpcDistributionApi_js_1.ChainGrpcDistributionApi(endpoint);
+        this.tokenfactory = new ChainGrpcTokenFactoryApi_js_1.ChainGrpcTokenFactoryApi(endpoint);
+        this.insuranceFund = new ChainGrpcInsuranceFundApi_js_1.ChainGrpcInsuranceFundApi(endpoint);
+    }
+}
+exports.ChainGrpcClient = ChainGrpcClient;

package/dist/cjs/client/chain/ChainRestClient.d.ts

@@ -0,0 +1,9 @@
+import { ChainRestAuthApi } from './rest/ChainRestAuthApi.js';
+/**
+ * @category Chain Rest API
+ * @hidden
+ */
+export declare class ChainRestClient {
+    auth: ChainRestAuthApi;
+    constructor(endpoint: string);
+}