@chainstream-io/sdk 0.0.1

package/src/openapi/apis/TradeApi.ts

@@ -0,0 +1,427 @@
+// TODO: better import syntax?
+import {BaseAPIRequestFactory, RequiredError, COLLECTION_FORMATS} from './baseapi';
+import {Configuration} from '../configuration';
+import {RequestContext, HttpMethod, ResponseContext, HttpFile, HttpInfo} from '../http/http';
+import {ObjectSerializer} from '../models/ObjectSerializer';
+import {ApiException} from './exception';
+import {canConsumeForm, isCodeInRange} from '../util';
+import {SecurityAuthentication} from '../auth/auth';
+
+
+import { GainersAndLosersPage } from '../models/GainersAndLosersPage';
+import { TopTradersPage } from '../models/TopTradersPage';
+import { TradePage } from '../models/TradePage';
+
+/**
+ * no description
+ */
+export class TradeApiRequestFactory extends BaseAPIRequestFactory {
+
+    /**
+     * CONTROLLER.TRADE.GET.GAINERS_LOSERS.DESCRIPTION
+     * CONTROLLER.TRADE.GET.GAINERS_LOSERS.SUMMARY
+     * @param chain GLOBAL.CHAIN.DESCRIPTION
+     * @param type DTO.TRADE.GAINERS_LOSERS.QUERY.TYPE
+     * @param sortBy DTO.TRADE.GAINERS_LOSERS.QUERY.SORT_BY
+     * @param sortType DTO.TRADE.GAINERS_LOSERS.QUERY.SORT_TYPE
+     * @param cursor DTO.PAGE.CURSOR.DESCRIPTION
+     * @param limit DTO.TRADE.QUERY.LIMIT
+     * @param direction DTO.PAGE.DIRECTION
+     */
+    public async getGainersLosers(chain: 'sol' | 'base' | 'bsc' | 'polygon' | 'arbitrum' | 'optimism' | 'avalanche' | 'ethereum' | 'zksync' | 'sui', type: string, sortBy: string, sortType: string, cursor?: string, limit?: number, direction?: 'next' | 'prev', _options?: Configuration): Promise<RequestContext> {
+        let _config = _options || this.configuration;
+
+        // verify required parameter 'chain' is not null or undefined
+        if (chain === null || chain === undefined) {
+            throw new RequiredError("TradeApi", "getGainersLosers", "chain");
+        }
+
+
+        // verify required parameter 'type' is not null or undefined
+        if (type === null || type === undefined) {
+            throw new RequiredError("TradeApi", "getGainersLosers", "type");
+        }
+
+
+        // verify required parameter 'sortBy' is not null or undefined
+        if (sortBy === null || sortBy === undefined) {
+            throw new RequiredError("TradeApi", "getGainersLosers", "sortBy");
+        }
+
+
+        // verify required parameter 'sortType' is not null or undefined
+        if (sortType === null || sortType === undefined) {
+            throw new RequiredError("TradeApi", "getGainersLosers", "sortType");
+        }
+
+
+
+
+
+        // Path Params
+        const localVarPath = '/v1/trade/{chain}/gainers-losers'
+            .replace('{' + 'chain' + '}', encodeURIComponent(String(chain)));
+
+        // Make Request Context
+        const requestContext = _config.baseServer.makeRequestContext(localVarPath, HttpMethod.GET);
+        requestContext.setHeaderParam("Accept", "application/json, */*;q=0.8")
+        const randomId = Math.floor(Math.random() * Math.pow(2, 32))
+        requestContext.setHeaderParam("x-req-id", randomId.toString())
+
+
+        // Query Params
+        if (cursor !== undefined) {
+            requestContext.setQueryParam("cursor", ObjectSerializer.serialize(cursor, "string", ""));
+        }
+
+        // Query Params
+        if (limit !== undefined) {
+            requestContext.setQueryParam("limit", ObjectSerializer.serialize(limit, "number", ""));
+        }
+
+        // Query Params
+        if (direction !== undefined) {
+            requestContext.setQueryParam("direction", ObjectSerializer.serialize(direction, "'next' | 'prev'", ""));
+        }
+
+        // Query Params
+        if (type !== undefined) {
+            requestContext.setQueryParam("type", ObjectSerializer.serialize(type, "string", ""));
+        }
+
+        // Query Params
+        if (sortBy !== undefined) {
+            requestContext.setQueryParam("sortBy", ObjectSerializer.serialize(sortBy, "string", ""));
+        }
+
+        // Query Params
+        if (sortType !== undefined) {
+            requestContext.setQueryParam("sortType", ObjectSerializer.serialize(sortType, "string", ""));
+        }
+
+
+        let authMethod: SecurityAuthentication | undefined;
+        // Apply auth methods
+        authMethod = _config.authMethods["bearer"]
+        if (authMethod?.applySecurityAuthentication) {
+            await authMethod?.applySecurityAuthentication(requestContext);
+        }
+
+        const defaultAuth: SecurityAuthentication | undefined = _options?.authMethods?.default || this.configuration?.authMethods?.default
+        if (defaultAuth?.applySecurityAuthentication) {
+            await defaultAuth?.applySecurityAuthentication(requestContext);
+        }
+
+        return requestContext;
+    }
+
+    /**
+     * CONTROLLER.TRADE.GET.TOP_TRADERS.DESCRIPTION
+     * CONTROLLER.TRADE.GET.TOP_TRADERS.SUMMARY
+     * @param chain GLOBAL.CHAIN.DESCRIPTION
+     * @param tokenAddress DTO.TRADE.QUERY.TOKEN_ADDRESS
+     * @param timeFrame DTO.TRADE.QUERY.TIME_FRAME
+     * @param sortType DTO.TRADE.QUERY.SORT_TYPE
+     * @param sortBy DTO.TRADE.QUERY.SORT_BY
+     * @param cursor DTO.PAGE.CURSOR.DESCRIPTION
+     * @param limit DTO.TRADE.QUERY.LIMIT
+     * @param direction DTO.PAGE.DIRECTION
+     */
+    public async getTopTraders(chain: 'sol' | 'base' | 'bsc' | 'polygon' | 'arbitrum' | 'optimism' | 'avalanche' | 'ethereum' | 'zksync' | 'sui', tokenAddress: string, timeFrame: string, sortType: string, sortBy: string, cursor?: string, limit?: number, direction?: 'next' | 'prev', _options?: Configuration): Promise<RequestContext> {
+        let _config = _options || this.configuration;
+
+        // verify required parameter 'chain' is not null or undefined
+        if (chain === null || chain === undefined) {
+            throw new RequiredError("TradeApi", "getTopTraders", "chain");
+        }
+
+
+        // verify required parameter 'tokenAddress' is not null or undefined
+        if (tokenAddress === null || tokenAddress === undefined) {
+            throw new RequiredError("TradeApi", "getTopTraders", "tokenAddress");
+        }
+
+
+        // verify required parameter 'timeFrame' is not null or undefined
+        if (timeFrame === null || timeFrame === undefined) {
+            throw new RequiredError("TradeApi", "getTopTraders", "timeFrame");
+        }
+
+
+        // verify required parameter 'sortType' is not null or undefined
+        if (sortType === null || sortType === undefined) {
+            throw new RequiredError("TradeApi", "getTopTraders", "sortType");
+        }
+
+
+        // verify required parameter 'sortBy' is not null or undefined
+        if (sortBy === null || sortBy === undefined) {
+            throw new RequiredError("TradeApi", "getTopTraders", "sortBy");
+        }
+
+
+
+
+
+        // Path Params
+        const localVarPath = '/v1/trade/{chain}/top-traders'
+            .replace('{' + 'chain' + '}', encodeURIComponent(String(chain)));
+
+        // Make Request Context
+        const requestContext = _config.baseServer.makeRequestContext(localVarPath, HttpMethod.GET);
+        requestContext.setHeaderParam("Accept", "application/json, */*;q=0.8")
+        const randomId = Math.floor(Math.random() * Math.pow(2, 32))
+        requestContext.setHeaderParam("x-req-id", randomId.toString())
+
+
+        // Query Params
+        if (cursor !== undefined) {
+            requestContext.setQueryParam("cursor", ObjectSerializer.serialize(cursor, "string", ""));
+        }
+
+        // Query Params
+        if (limit !== undefined) {
+            requestContext.setQueryParam("limit", ObjectSerializer.serialize(limit, "number", ""));
+        }
+
+        // Query Params
+        if (direction !== undefined) {
+            requestContext.setQueryParam("direction", ObjectSerializer.serialize(direction, "'next' | 'prev'", ""));
+        }
+
+        // Query Params
+        if (tokenAddress !== undefined) {
+            requestContext.setQueryParam("tokenAddress", ObjectSerializer.serialize(tokenAddress, "string", ""));
+        }
+
+        // Query Params
+        if (timeFrame !== undefined) {
+            requestContext.setQueryParam("timeFrame", ObjectSerializer.serialize(timeFrame, "string", ""));
+        }
+
+        // Query Params
+        if (sortType !== undefined) {
+            requestContext.setQueryParam("sortType", ObjectSerializer.serialize(sortType, "string", ""));
+        }
+
+        // Query Params
+        if (sortBy !== undefined) {
+            requestContext.setQueryParam("sortBy", ObjectSerializer.serialize(sortBy, "string", ""));
+        }
+
+
+        let authMethod: SecurityAuthentication | undefined;
+        // Apply auth methods
+        authMethod = _config.authMethods["bearer"]
+        if (authMethod?.applySecurityAuthentication) {
+            await authMethod?.applySecurityAuthentication(requestContext);
+        }
+
+        const defaultAuth: SecurityAuthentication | undefined = _options?.authMethods?.default || this.configuration?.authMethods?.default
+        if (defaultAuth?.applySecurityAuthentication) {
+            await defaultAuth?.applySecurityAuthentication(requestContext);
+        }
+
+        return requestContext;
+    }
+
+    /**
+     * CONTROLLER.TRADE.GET.TOKEN.DESCRIPTION
+     * CONTROLLER.TRADE.GET.TOKEN.SUMMARY
+     * @param chain GLOBAL.CHAIN.DESCRIPTION
+     * @param cursor DTO.PAGE.CURSOR.DESCRIPTION
+     * @param limit DTO.PAGE.LIMIT
+     * @param direction DTO.PAGE.DIRECTION
+     * @param tokenAddress DTO.TRADE.QUERY.TOKEN_ADDRESS
+     * @param walletAddress DTO.TRADE.QUERY.WALLET_ADDRESS
+     * @param poolAddress DTO.TRADE.QUERY.POOL_ADDRESS
+     * @param beforeTimestamp DTO.TRADE.QUERY.BEFORE_TIMESTAMP
+     * @param afterTimestamp DTO.TRADE.QUERY.AFTER_TIMESTAMP
+     * @param beforeBlockHeight DTO.TRADE.QUERY.BEFORE_BLOCK_HEIGHT
+     * @param afterBlockHeight DTO.TRADE.QUERY.AFTER_BLOCK_HEIGHT
+     */
+    public async getTrades(chain: 'sol' | 'base' | 'bsc' | 'polygon' | 'arbitrum' | 'optimism' | 'avalanche' | 'ethereum' | 'zksync' | 'sui', cursor?: string, limit?: number, direction?: 'next' | 'prev', tokenAddress?: string, walletAddress?: string, poolAddress?: string, beforeTimestamp?: number, afterTimestamp?: number, beforeBlockHeight?: number, afterBlockHeight?: number, _options?: Configuration): Promise<RequestContext> {
+        let _config = _options || this.configuration;
+
+        // verify required parameter 'chain' is not null or undefined
+        if (chain === null || chain === undefined) {
+            throw new RequiredError("TradeApi", "getTrades", "chain");
+        }
+
+
+
+
+
+
+
+
+
+
+
+
+        // Path Params
+        const localVarPath = '/v1/trade/{chain}'
+            .replace('{' + 'chain' + '}', encodeURIComponent(String(chain)));
+
+        // Make Request Context
+        const requestContext = _config.baseServer.makeRequestContext(localVarPath, HttpMethod.GET);
+        requestContext.setHeaderParam("Accept", "application/json, */*;q=0.8")
+        const randomId = Math.floor(Math.random() * Math.pow(2, 32))
+        requestContext.setHeaderParam("x-req-id", randomId.toString())
+
+
+        // Query Params
+        if (cursor !== undefined) {
+            requestContext.setQueryParam("cursor", ObjectSerializer.serialize(cursor, "string", ""));
+        }
+
+        // Query Params
+        if (limit !== undefined) {
+            requestContext.setQueryParam("limit", ObjectSerializer.serialize(limit, "number", ""));
+        }
+
+        // Query Params
+        if (direction !== undefined) {
+            requestContext.setQueryParam("direction", ObjectSerializer.serialize(direction, "'next' | 'prev'", ""));
+        }
+
+        // Query Params
+        if (tokenAddress !== undefined) {
+            requestContext.setQueryParam("tokenAddress", ObjectSerializer.serialize(tokenAddress, "string", ""));
+        }
+
+        // Query Params
+        if (walletAddress !== undefined) {
+            requestContext.setQueryParam("walletAddress", ObjectSerializer.serialize(walletAddress, "string", ""));
+        }
+
+        // Query Params
+        if (poolAddress !== undefined) {
+            requestContext.setQueryParam("poolAddress", ObjectSerializer.serialize(poolAddress, "string", ""));
+        }
+
+        // Query Params
+        if (beforeTimestamp !== undefined) {
+            requestContext.setQueryParam("beforeTimestamp", ObjectSerializer.serialize(beforeTimestamp, "number", ""));
+        }
+
+        // Query Params
+        if (afterTimestamp !== undefined) {
+            requestContext.setQueryParam("afterTimestamp", ObjectSerializer.serialize(afterTimestamp, "number", ""));
+        }
+
+        // Query Params
+        if (beforeBlockHeight !== undefined) {
+            requestContext.setQueryParam("beforeBlockHeight", ObjectSerializer.serialize(beforeBlockHeight, "number", ""));
+        }
+
+        // Query Params
+        if (afterBlockHeight !== undefined) {
+            requestContext.setQueryParam("afterBlockHeight", ObjectSerializer.serialize(afterBlockHeight, "number", ""));
+        }
+
+
+        let authMethod: SecurityAuthentication | undefined;
+        // Apply auth methods
+        authMethod = _config.authMethods["bearer"]
+        if (authMethod?.applySecurityAuthentication) {
+            await authMethod?.applySecurityAuthentication(requestContext);
+        }
+
+        const defaultAuth: SecurityAuthentication | undefined = _options?.authMethods?.default || this.configuration?.authMethods?.default
+        if (defaultAuth?.applySecurityAuthentication) {
+            await defaultAuth?.applySecurityAuthentication(requestContext);
+        }
+
+        return requestContext;
+    }
+
+}
+
+export class TradeApiResponseProcessor {
+
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to getGainersLosers
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+     public async getGainersLosersWithHttpInfo(response: ResponseContext): Promise<HttpInfo<GainersAndLosersPage >> {
+        const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+        if (isCodeInRange("200", response.httpStatusCode)) {
+            const body: GainersAndLosersPage = ObjectSerializer.deserialize(
+                ObjectSerializer.parse(await response.body.text(), contentType),
+                "GainersAndLosersPage", ""
+            ) as GainersAndLosersPage;
+            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
+        }
+
+        // Work around for missing responses in specification, e.g. for petstore.yaml
+        if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
+            const body: GainersAndLosersPage = ObjectSerializer.deserialize(
+                ObjectSerializer.parse(await response.body.text(), contentType),
+                "GainersAndLosersPage", ""
+            ) as GainersAndLosersPage;
+            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
+        }
+        throw new ApiException<string | Blob | undefined>(response.httpStatusCode, "Unknown API Status Code!", await response.getBodyAsAny(), response.headers);
+    }
+
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to getTopTraders
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+     public async getTopTradersWithHttpInfo(response: ResponseContext): Promise<HttpInfo<TopTradersPage >> {
+        const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+        if (isCodeInRange("200", response.httpStatusCode)) {
+            const body: TopTradersPage = ObjectSerializer.deserialize(
+                ObjectSerializer.parse(await response.body.text(), contentType),
+                "TopTradersPage", ""
+            ) as TopTradersPage;
+            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
+        }
+
+        // Work around for missing responses in specification, e.g. for petstore.yaml
+        if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
+            const body: TopTradersPage = ObjectSerializer.deserialize(
+                ObjectSerializer.parse(await response.body.text(), contentType),
+                "TopTradersPage", ""
+            ) as TopTradersPage;
+            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
+        }
+        throw new ApiException<string | Blob | undefined>(response.httpStatusCode, "Unknown API Status Code!", await response.getBodyAsAny(), response.headers);
+    }
+
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to getTrades
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+     public async getTradesWithHttpInfo(response: ResponseContext): Promise<HttpInfo<TradePage >> {
+        const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+        if (isCodeInRange("200", response.httpStatusCode)) {
+            const body: TradePage = ObjectSerializer.deserialize(
+                ObjectSerializer.parse(await response.body.text(), contentType),
+                "TradePage", ""
+            ) as TradePage;
+            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
+        }
+
+        // Work around for missing responses in specification, e.g. for petstore.yaml
+        if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
+            const body: TradePage = ObjectSerializer.deserialize(
+                ObjectSerializer.parse(await response.body.text(), contentType),
+                "TradePage", ""
+            ) as TradePage;
+            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
+        }
+        throw new ApiException<string | Blob | undefined>(response.httpStatusCode, "Unknown API Status Code!", await response.getBodyAsAny(), response.headers);
+    }
+
+}

package/src/openapi/apis/TransactionApi.ts

@@ -0,0 +1,110 @@
+// TODO: better import syntax?
+import {BaseAPIRequestFactory, RequiredError, COLLECTION_FORMATS} from './baseapi';
+import {Configuration} from '../configuration';
+import {RequestContext, HttpMethod, ResponseContext, HttpFile, HttpInfo} from '../http/http';
+import {ObjectSerializer} from '../models/ObjectSerializer';
+import {ApiException} from './exception';
+import {canConsumeForm, isCodeInRange} from '../util';
+import {SecurityAuthentication} from '../auth/auth';
+
+
+import { SendTxInput } from '../models/SendTxInput';
+import { SendTxResponse } from '../models/SendTxResponse';
+
+/**
+ * no description
+ */
+export class TransactionApiRequestFactory extends BaseAPIRequestFactory {
+
+    /**
+     * CONTROLLER.TRANSACTION.SEND.DESCRIPTION
+     * CONTROLLER.TRANSACTION.SEND.SUMMARY
+     * @param chain GLOBAL.CHAIN.DESCRIPTION
+     * @param sendTxInput CONTROLLER.TRANSACTION.SEND.BODY
+     */
+    public async send(chain: string, sendTxInput: SendTxInput, _options?: Configuration): Promise<RequestContext> {
+        let _config = _options || this.configuration;
+
+        // verify required parameter 'chain' is not null or undefined
+        if (chain === null || chain === undefined) {
+            throw new RequiredError("TransactionApi", "send", "chain");
+        }
+
+
+        // verify required parameter 'sendTxInput' is not null or undefined
+        if (sendTxInput === null || sendTxInput === undefined) {
+            throw new RequiredError("TransactionApi", "send", "sendTxInput");
+        }
+
+
+        // Path Params
+        const localVarPath = '/v1/transaction/{chain}/send'
+            .replace('{' + 'chain' + '}', encodeURIComponent(String(chain)));
+
+        // Make Request Context
+        const requestContext = _config.baseServer.makeRequestContext(localVarPath, HttpMethod.POST);
+        requestContext.setHeaderParam("Accept", "application/json, */*;q=0.8")
+        const randomId = Math.floor(Math.random() * Math.pow(2, 32))
+        requestContext.setHeaderParam("x-req-id", randomId.toString())
+
+
+
+        // Body Params
+        const contentType = ObjectSerializer.getPreferredMediaType([
+            "application/json"
+        ]);
+        requestContext.setHeaderParam("Content-Type", contentType);
+        const serializedBody = ObjectSerializer.stringify(
+            ObjectSerializer.serialize(sendTxInput, "SendTxInput", ""),
+            contentType
+        );
+        requestContext.setBody(serializedBody);
+
+        let authMethod: SecurityAuthentication | undefined;
+        // Apply auth methods
+        authMethod = _config.authMethods["bearer"]
+        if (authMethod?.applySecurityAuthentication) {
+            await authMethod?.applySecurityAuthentication(requestContext);
+        }
+
+        const defaultAuth: SecurityAuthentication | undefined = _options?.authMethods?.default || this.configuration?.authMethods?.default
+        if (defaultAuth?.applySecurityAuthentication) {
+            await defaultAuth?.applySecurityAuthentication(requestContext);
+        }
+
+        return requestContext;
+    }
+
+}
+
+export class TransactionApiResponseProcessor {
+
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to send
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+     public async sendWithHttpInfo(response: ResponseContext): Promise<HttpInfo<SendTxResponse >> {
+        const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+        if (isCodeInRange("200", response.httpStatusCode)) {
+            const body: SendTxResponse = ObjectSerializer.deserialize(
+                ObjectSerializer.parse(await response.body.text(), contentType),
+                "SendTxResponse", ""
+            ) as SendTxResponse;
+            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
+        }
+
+        // Work around for missing responses in specification, e.g. for petstore.yaml
+        if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
+            const body: SendTxResponse = ObjectSerializer.deserialize(
+                ObjectSerializer.parse(await response.body.text(), contentType),
+                "SendTxResponse", ""
+            ) as SendTxResponse;
+            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
+        }
+        throw new ApiException<string | Blob | undefined>(response.httpStatusCode, "Unknown API Status Code!", await response.getBodyAsAny(), response.headers);
+    }
+
+}