@chainstream-io/sdk 0.0.1

package/src/index.ts

@@ -0,0 +1,208 @@
+import { StreamApi } from "./api/stream";
+import {
+  DexApi,
+  Configuration,
+  TransactionApi,
+  DefiSolanaMoonshotApi,
+  DefiSolanaPumpfunApi,
+  DexPoolApi,
+  TokenApi,
+  RankingApi,
+  TradeApi,
+  WalletApi,
+  createConfiguration,
+  ServerConfiguration,
+  ResponseContext,
+  RequestContext,
+  Middleware,
+  BearerAuthentication,
+  RedPacketApi,
+  IpfsApi,
+} from "./openapi";
+import { EventSourcePolyfill } from "event-source-polyfill";
+
+export interface TokenProvider {
+  getToken(): Promise<string> | string;
+}
+
+export interface DexRequestContext {
+  baseUrl: string;
+  streamUrl: string;
+  accessToken: string | TokenProvider;
+}
+
+export interface DexAggregatorOptions {
+  debug?: boolean;
+  serverUrl?: string;
+  streamUrl?: string;
+}
+
+export const LIB_VERSION = "0.0.1";
+
+class UserAgentMiddleware implements Middleware {
+  public pre(context: RequestContext): Promise<RequestContext> {
+    context.setHeaderParam("User-Agent", `dex/${LIB_VERSION}/javascript`);
+    return Promise.resolve(context);
+  }
+
+  public post(context: ResponseContext): Promise<ResponseContext> {
+    return Promise.resolve(context);
+  }
+}
+
+export class DexClient {
+  public readonly requestCtx: DexRequestContext;
+  public readonly _configuration: Configuration;
+  public readonly dex: DexApi;
+  public readonly dexpool: DexPoolApi;
+  public readonly token: TokenApi;
+  public readonly wallet: WalletApi;
+  public readonly trade: TradeApi;
+  public readonly ranking: RankingApi;
+  public readonly transaction: TransactionApi;
+  public readonly moonshot: DefiSolanaMoonshotApi;
+  public readonly pumpfun: DefiSolanaPumpfunApi;
+  public readonly stream: StreamApi;
+  public readonly redPacket: RedPacketApi;
+  public readonly ipfs: IpfsApi;
+  public constructor(
+    accessToken: string | TokenProvider,
+    options: DexAggregatorOptions = {}
+  ) {
+    const baseUrl: string = options.serverUrl ?? "https://api-dex.chainstream.io";
+    const streamUrl: string =
+      options.streamUrl ?? "wss://realtime-dex.chainstream.io/connection/websocket";
+
+    const tokenProvider =
+      typeof accessToken === "string"
+        ? {
+            getToken: () => accessToken,
+          }
+        : accessToken;
+
+    this.requestCtx = { baseUrl, streamUrl, accessToken };
+
+    const config = createConfiguration({
+      baseServer: new ServerConfiguration<any>(baseUrl, {}),
+      promiseMiddleware: [new UserAgentMiddleware()],
+      authMethods: {
+        default: new BearerAuthentication(tokenProvider),
+      },
+    });
+
+    this._configuration = config;
+    // this.authentication = new Authentication(config);
+    this.dex = new DexApi(config);
+    this.dexpool = new DexPoolApi(config);
+    this.token = new TokenApi(config);
+    this.trade = new TradeApi(config);
+    this.ranking = new RankingApi(config);
+    this.transaction = new TransactionApi(config);
+    this.moonshot = new DefiSolanaMoonshotApi(config);
+    this.pumpfun = new DefiSolanaPumpfunApi(config);
+    this.stream = new StreamApi(this.requestCtx);
+    this.wallet = new WalletApi(config);
+    this.redPacket = new RedPacketApi(config);
+    this.ipfs = new IpfsApi(config);
+    this.stream.connect();
+  }
+
+  async waitForJob<T>(jobId: string, timeout = 60000): Promise<T> {
+    const accessToken =
+      typeof this.requestCtx.accessToken === "string"
+        ? this.requestCtx.accessToken
+        : await this.requestCtx.accessToken.getToken();
+
+    return new Promise((resolve, reject) => {
+      const sse = new EventSourcePolyfill(
+        `${this.requestCtx.baseUrl}/jobs/${jobId}/streaming`,
+        {
+          headers: {
+            Authorization: `Bearer ${accessToken}`,
+          },
+        }
+      );
+
+      const timeoutId = setTimeout(() => {
+        sse.close();
+        reject(new Error(`Job ${jobId} timed out after ${timeout}ms`));
+      }, timeout);
+
+      sse.onmessage = (event: any) => {
+        try {
+          console.log("event.data: ", event.data);
+          const data = JSON.parse(event.data);
+
+          if (data.status === "error") {
+            sse.close();
+            reject(new Error(`Error: ${data.message}`));
+          } else if (data.status === "completed") {
+            clearTimeout(timeoutId);
+            sse.close();
+            resolve(data as T);
+          }
+        } catch (e) {
+          clearTimeout(timeoutId);
+          sse.close();
+          reject(new Error("Error parsing event data"));
+        }
+      };
+
+      sse.onopen = () => {
+        console.log("SSE connection opened");
+      };
+
+      sse.onerror = (error: any) => {
+        if (error.message?.includes("No activity within")) {
+          console.log("SSE reconnecting due to inactivity...");
+          return;
+        }
+
+        clearTimeout(timeoutId);
+
+        sse.close();
+        reject(new Error(`Error in SSE connection: ${error}`));
+      };
+    });
+  }
+}
+
+export interface PostOptions {
+  idempotencyKey?: string;
+}
+
+/*
+class Authentication {
+  private readonly api: AuthenticationApi;
+
+  public constructor(config: Configuration) {
+    this.api = new AuthenticationApi(config);
+  }
+
+  public appPortalAccess(
+    appId: string,
+    appPortalAccessIn: AppPortalAccessIn,
+    options?: PostOptions
+  ): Promise<AppPortalAccessOut> {
+    return this.api.v1AuthenticationAppPortalAccess({
+      appId,
+      appPortalAccessIn,
+      ...options,
+    });
+  }
+
+  public dashboardAccess(
+    appId: string,
+    options?: PostOptions
+  ): Promise<DashboardAccessOut> {
+    return this.api.v1AuthenticationDashboardAccess({
+      appId,
+      ...options,
+    });
+  }
+
+  public logout(options?: PostOptions): Promise<void> {
+    return this.api.v1AuthenticationLogout({ ...options });
+  }
+}
+*/

package/src/openapi/.gitattributes

@@ -0,0 +1,8 @@
+**/* linguist-generated
+*.md linguist-documentation
+
+.gitattributes text
+.gitattributes export-ignore
+
+.gitignore text
+.gitignore export-ignore

package/src/openapi/.openapi-generator/FILES

@@ -0,0 +1,96 @@
+.gitattributes
+.gitignore
+.openapi-generator-ignore
+README.md
+apis/BlockchainApi.ts
+apis/DefiSolanaMoonshotApi.ts
+apis/DefiSolanaPumpfunApi.ts
+apis/DexApi.ts
+apis/DexPoolApi.ts
+apis/IpfsApi.ts
+apis/JobsApi.ts
+apis/RankingApi.ts
+apis/RedPacketApi.ts
+apis/TokenApi.ts
+apis/TradeApi.ts
+apis/TransactionApi.ts
+apis/WalletApi.ts
+apis/WatchlistApi.ts
+apis/baseapi.ts
+apis/exception.ts
+auth/auth.ts
+configuration.ts
+git_push.sh
+http/http.ts
+http/isomorphic-fetch.ts
+index.ts
+middleware.ts
+models/BlockchainLatestBlockDTO.ts
+models/CalculatePnlInput.ts
+models/Candle.ts
+models/ClaimRedPacketInput.ts
+models/CreateRedPacketInput.ts
+models/CreateRedPacketReply.ts
+models/DexDTO.ts
+models/DexMintInput.ts
+models/DexPage.ts
+models/DexPoolDTO.ts
+models/FilterCondition.ts
+models/GainersAndLosersDTO.ts
+models/GainersAndLosersPage.ts
+models/Link.ts
+models/MintInput.ts
+models/MintReply.ts
+models/MoonshotMintReply.ts
+models/MoonshotSubmitMint200Response.ts
+models/ObjectSerializer.ts
+models/PumpMintInput.ts
+models/PumpMintReply.ts
+models/RankingToken.ts
+models/RankingTokenMarketData.ts
+models/RankingTokenStat.ts
+models/RedPacketClaimDTO.ts
+models/RedPacketClaimsPage.ts
+models/RedPacketDTO.ts
+models/RedPacketReply.ts
+models/RedPacketSendTxInput.ts
+models/RedPacketSendTxResponse.ts
+models/RedPacketsPage.ts
+models/Resolution.ts
+models/SendTxInput.ts
+models/SendTxResponse.ts
+models/SubmitInput.ts
+models/SwapInput.ts
+models/SwapReply.ts
+models/SwapRouteInput.ts
+models/SwapRouteResponse.ts
+models/Token.ts
+models/TokenCreationDTO.ts
+models/TokenCreationPage.ts
+models/TokenHolder.ts
+models/TokenHolderPage.ts
+models/TokenListPage.ts
+models/TokenMarketData.ts
+models/TokenMetadata.ts
+models/TokenPage.ts
+models/TokenPriceDTO.ts
+models/TokenPricePage.ts
+models/TokenStat.ts
+models/TopTradersDTO.ts
+models/TopTradersPage.ts
+models/TradeDetailDTO.ts
+models/TradeEvent.ts
+models/TradePage.ts
+models/TradeType.ts
+models/WalletBalanceDetailDTO.ts
+models/WalletBalancesDTO.ts
+models/WalletPnlDTO.ts
+models/all.ts
+package.json
+rxjsStub.ts
+servers.ts
+tsconfig.json
+types/ObjectParamAPI.ts
+types/ObservableAPI.ts
+types/PromiseAPI.ts
+util.ts

package/src/openapi/.openapi-generator/VERSION

@@ -0,0 +1 @@
+7.10.0

package/src/openapi/.openapi-generator-ignore

@@ -0,0 +1,23 @@
+# OpenAPI Generator Ignore
+# Generated by openapi-generator https://github.com/openapitools/openapi-generator
+
+# Use this file to prevent files from being overwritten by the generator.
+# The patterns follow closely to .gitignore or .dockerignore.
+
+# As an example, the C# client generator defines ApiClient.cs.
+# You can make changes and tell OpenAPI Generator to ignore just this file by uncommenting the following line:
+#ApiClient.cs
+
+# You can match any string of characters against a directory, file or extension with a single asterisk (*):
+#foo/*/qux
+# The above matches foo/bar/qux and foo/baz/qux, but not foo/bar/baz/qux
+
+# You can recursively match patterns against a directory, file or extension with a double asterisk (**):
+#foo/**/qux
+# This matches foo/bar/qux, foo/baz/qux, and foo/bar/baz/qux
+
+# You can also negate patterns with an exclamation (!).
+# For example, you can ignore all files in a docs folder with the file extension .md:
+#docs/*.md
+# Then explicitly reverse the ignore rule for a single file:
+#!docs/README.md

package/src/openapi/README.md

@@ -0,0 +1,80 @@
+## @chainstream-io/dex@1.0
+
+This generator creates TypeScript/JavaScript client that utilizes fetch-api.
+
+### Building
+
+To build and compile the typescript sources to javascript use:
+```
+npm install
+npm run build
+```
+
+### Publishing
+
+First build the package then run ```npm publish```
+
+### Consuming
+
+Navigate to the folder of your consuming project and run one of the following commands.
+
+_published:_
+
+```
+npm install @chainstream-io/dex@1.0 --save
+```
+
+_unPublished (not recommended):_
+
+```
+npm install PATH_TO_GENERATED_PACKAGE --save
+```
+
+### Usage
+
+Below code snippet shows exemplary usage of the configuration and the API based 
+on the typical `PetStore` example used for OpenAPI. 
+
+```
+import * as your_api from 'your_api_package'
+
+// Covers all auth methods included in your OpenAPI yaml definition
+const authConfig: your_api.AuthMethodsConfiguration = {
+    "api_key": "YOUR_API_KEY"
+}
+
+// Implements a simple middleware to modify requests before (`pre`) they are sent
+// and after (`post`) they have been received 
+class Test implements your_api.Middleware {
+    pre(context: your_api.RequestContext): Promise<your_api.RequestContext> {
+        // Modify context here and return
+        return Promise.resolve(context);
+    }
+
+    post(context: your_api.ResponseContext): Promise<your_api.ResponseContext> {
+        return Promise.resolve(context);
+    }
+
+}
+
+// Create configuration parameter object
+const configurationParameters = {
+    httpApi: new your_api.JQueryHttpLibrary(), // Can also be ignored - default is usually fine
+    baseServer: your_api.servers[0], // First server is default
+    authMethods: authConfig, // No auth is default
+    promiseMiddleware: [new Test()],
+}
+
+// Convert to actual configuration
+const config = your_api.createConfiguration(configurationParameters);
+
+// Use configuration with your_api
+const api = new your_api.PetApi(config);
+your_api.Pet p = new your_api.Pet();
+p.name = "My new pet";
+p.photoUrls = [];
+p.tags = [];
+p.status = "available";
+Promise<your_api.Pet> createdPet = api.addPet(p);
+
+```

package/src/openapi/apis/BlockchainApi.ts

@@ -0,0 +1,152 @@
+// 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 { BlockchainLatestBlockDTO } from '../models/BlockchainLatestBlockDTO';
+
+/**
+ * no description
+ */
+export class BlockchainApiRequestFactory extends BaseAPIRequestFactory {
+
+    /**
+     * CONTROLLER.GET_LATEST_BLOCK.DESCRIPTION
+     * CONTROLLER.GET_LATEST_BLOCK.SUMMARY
+     * @param chain GLOBAL.CHAIN.DESCRIPTION
+     */
+    public async getLatestBlock(chain: 'sol' | 'base' | 'bsc' | 'polygon' | 'arbitrum' | 'optimism' | 'avalanche' | 'ethereum' | 'zksync' | 'sui', _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("BlockchainApi", "getLatestBlock", "chain");
+        }
+
+
+        // Path Params
+        const localVarPath = '/v1/blockchain/{chain}/latest_block'
+            .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())
+
+
+
+        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.GET_SUPPORTED_BLOCKCHAINS.DESCRIPTION
+     * CONTROLLER.GET_SUPPORTED_BLOCKCHAINS.SUMMARY
+     */
+    public async getSupportedBlockchains(_options?: Configuration): Promise<RequestContext> {
+        let _config = _options || this.configuration;
+
+        // Path Params
+        const localVarPath = '/v1/blockchain';
+
+        // 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())
+
+
+
+        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 BlockchainApiResponseProcessor {
+
+    /**
+     * 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 getLatestBlock
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+     public async getLatestBlockWithHttpInfo(response: ResponseContext): Promise<HttpInfo<BlockchainLatestBlockDTO >> {
+        const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+        if (isCodeInRange("200", response.httpStatusCode)) {
+            const body: BlockchainLatestBlockDTO = ObjectSerializer.deserialize(
+                ObjectSerializer.parse(await response.body.text(), contentType),
+                "BlockchainLatestBlockDTO", ""
+            ) as BlockchainLatestBlockDTO;
+            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: BlockchainLatestBlockDTO = ObjectSerializer.deserialize(
+                ObjectSerializer.parse(await response.body.text(), contentType),
+                "BlockchainLatestBlockDTO", ""
+            ) as BlockchainLatestBlockDTO;
+            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 getSupportedBlockchains
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+     public async getSupportedBlockchainsWithHttpInfo(response: ResponseContext): Promise<HttpInfo<Array<string> >> {
+        const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+        if (isCodeInRange("200", response.httpStatusCode)) {
+            const body: Array<string> = ObjectSerializer.deserialize(
+                ObjectSerializer.parse(await response.body.text(), contentType),
+                "Array<string>", ""
+            ) as Array<string>;
+            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: Array<string> = ObjectSerializer.deserialize(
+                ObjectSerializer.parse(await response.body.text(), contentType),
+                "Array<string>", ""
+            ) as Array<string>;
+            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);
+    }
+
+}