@chainstream-io/sdk 0.1.5 → 0.1.6

package/README.md

@@ -0,0 +1,46 @@
+## @chainstream-io/sdk@0.1.6
+
+This generator creates TypeScript/JavaScript client that utilizes [Fetch API](https://fetch.spec.whatwg.org/). The generated Node module can be used in the following environments:
+
+Environment
+* Node.js
+* Webpack
+* Browserify
+
+Language level
+* ES5 - you must have a Promises/A+ library installed
+* ES6
+
+Module system
+* CommonJS
+* ES6 module system
+
+It can be used in both TypeScript and JavaScript. In TypeScript, the definition will be automatically resolved via `package.json`. ([Reference](https://www.typescriptlang.org/docs/handbook/declaration-files/consumption.html))
+
+### 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/sdk@0.1.6 --save
+```
+
+_unPublished (not recommended):_
+
+```
+npm install PATH_TO_GENERATED_PACKAGE --save
+```

package/dist/esm/index.d.ts

@@ -1,4 +1,4 @@
-import { StreamApi } from "./api/stream";
+import { StreamApi } from "./stream";
 import { DexApi, Configuration, TransactionApi, DefiSolanaMoonshotApi, DefiSolanaPumpfunApi, DexPoolApi, TokenApi, RankingApi, TradeApi, WalletApi, RedPacketApi, IpfsApi, WatchlistApi, BlockchainApi, JobsApi } from "./openapi";
 export interface TokenProvider {
     getToken(): Promise<string> | string;

package/dist/esm/index.js

@@ -1,26 +1,39 @@
-import { StreamApi } from "./api/stream";
-import { DexApi, Configuration, TransactionApi, DefiSolanaMoonshotApi, DefiSolanaPumpfunApi, DexPoolApi, TokenApi, RankingApi, TradeApi, WalletApi, RedPacketApi, IpfsApi, WatchlistApi, BlockchainApi, JobsApi } from "./openapi";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { StreamApi } from "./stream";
+import { DexApi, Configuration, TransactionApi, DefiSolanaMoonshotApi, DefiSolanaPumpfunApi, DexPoolApi, TokenApi, RankingApi, TradeApi, WalletApi, RedPacketApi, IpfsApi, WatchlistApi, BlockchainApi, JobsApi, } from "./openapi";
 import { EventSourcePolyfill } from "event-source-polyfill";
 export const LIB_VERSION = "0.1.5";
 class UserAgentMiddleware {
-    async pre(context) {
-        if (!context.init.headers) {
-            context.init.headers = {};
-        }
-        if (context.init.headers instanceof Headers) {
-            context.init.headers.set("User-Agent", `dex/${LIB_VERSION}/javascript`);
-        }
-        else {
-            context.init.headers["User-Agent"] = `dex/${LIB_VERSION}/javascript`;
-        }
+    pre(context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!context.init.headers) {
+                context.init.headers = {};
+            }
+            if (context.init.headers instanceof Headers) {
+                context.init.headers.set("User-Agent", `dex/${LIB_VERSION}/javascript`);
+            }
+            else {
+                context.init.headers["User-Agent"] = `dex/${LIB_VERSION}/javascript`;
+            }
+        });
     }
-    async post(context) {
+    post(context) {
+        return __awaiter(this, void 0, void 0, function* () { });
     }
 }
 export class DexClient {
     constructor(accessToken, options = {}) {
-        const baseUrl = options.serverUrl ?? "https://api-dex.chainstream.io";
-        const streamUrl = options.streamUrl ?? "wss://realtime-dex.chainstream.io/connection/websocket";
+        var _a, _b;
+        const baseUrl = (_a = options.serverUrl) !== null && _a !== void 0 ? _a : "https://api-dex.chainstream.io";
+        const streamUrl = (_b = options.streamUrl) !== null && _b !== void 0 ? _b : "wss://realtime-dex.chainstream.io/connection/websocket";
         const tokenProvider = typeof accessToken === "string"
             ? {
                 getToken: () => accessToken,
@@ -30,14 +43,14 @@ export class DexClient {
         const config = new Configuration({
             basePath: baseUrl,
             middleware: [new UserAgentMiddleware()],
-            accessToken: async () => {
+            accessToken: () => __awaiter(this, void 0, void 0, function* () {
                 return typeof accessToken === "string"
                     ? accessToken
-                    : await accessToken.getToken();
-            },
+                    : yield accessToken.getToken();
+            }),
             headers: {
-                'User-Agent': `dex/${LIB_VERSION}/javascript`
-            }
+                "User-Agent": `dex/${LIB_VERSION}/javascript`,
+            },
         });
         this._configuration = config;
         this.dex = new DexApi(config);
@@ -57,52 +70,55 @@ export class DexClient {
         this.jobs = new JobsApi(config);
         this.stream.connect();
     }
-    async waitForJob(jobId, timeout = 60000) {
-        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) => {
-                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}`));
+    waitForJob(jobId_1) {
+        return __awaiter(this, arguments, void 0, function* (jobId, timeout = 60000) {
+            const accessToken = typeof this.requestCtx.accessToken === "string"
+                ? this.requestCtx.accessToken
+                : yield 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) => {
+                    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);
+                        }
                     }
-                    else if (data.status === "completed") {
+                    catch (e) {
                         clearTimeout(timeoutId);
                         sse.close();
-                        resolve(data);
+                        reject(new Error("Error parsing event data"));
+                    }
+                };
+                sse.onopen = () => {
+                    console.log("SSE connection opened");
+                };
+                sse.onerror = (error) => {
+                    var _a;
+                    if ((_a = error.message) === null || _a === void 0 ? void 0 : _a.includes("No activity within")) {
+                        console.log("SSE reconnecting due to inactivity...");
+                        return;
                     }
-                }
-                catch (e) {
                     clearTimeout(timeoutId);
                     sse.close();
-                    reject(new Error("Error parsing event data"));
-                }
-            };
-            sse.onopen = () => {
-                console.log("SSE connection opened");
-            };
-            sse.onerror = (error) => {
-                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}`));
-            };
+                    reject(new Error(`Error in SSE connection: ${error}`));
+                };
+            });
         });
     }
 }

package/dist/esm/openapi/apis/BlockchainApi.js

@@ -11,6 +11,15 @@
  * https://openapi-generator.tech
  * Do not edit the class manually.
  */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 import * as runtime from '../runtime';
 import { BlockchainDTOFromJSON, BlockchainLatestBlockDTOFromJSON, } from '../models/index';
 /**
@@ -21,67 +30,75 @@ export class BlockchainApi extends runtime.BaseAPI {
      * CONTROLLER.GET_LATEST_BLOCK.DESCRIPTION
      * CONTROLLER.GET_LATEST_BLOCK.SUMMARY
      */
-    async getLatestBlockRaw(requestParameters, initOverrides) {
-        if (requestParameters['chain'] == null) {
-            throw new runtime.RequiredError('chain', 'Required parameter "chain" was null or undefined when calling getLatestBlock().');
-        }
-        const queryParameters = {};
-        const headerParameters = {};
-        if (this.configuration && this.configuration.accessToken) {
-            const token = this.configuration.accessToken;
-            const tokenString = await token("bearer", []);
-            if (tokenString) {
-                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+    getLatestBlockRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['chain'] == null) {
+                throw new runtime.RequiredError('chain', 'Required parameter "chain" was null or undefined when calling getLatestBlock().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearer", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
             }
-        }
-        let urlPath = `/v1/blockchain/{chain}/latest_block`;
-        urlPath = urlPath.replace(`{${"chain"}}`, encodeURIComponent(String(requestParameters['chain'])));
-        const response = await this.request({
-            path: urlPath,
-            method: 'GET',
-            headers: headerParameters,
-            query: queryParameters,
-        }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => BlockchainLatestBlockDTOFromJSON(jsonValue));
+            let urlPath = `/v1/blockchain/{chain}/latest_block`;
+            urlPath = urlPath.replace(`{${"chain"}}`, encodeURIComponent(String(requestParameters['chain'])));
+            const response = yield this.request({
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => BlockchainLatestBlockDTOFromJSON(jsonValue));
+        });
     }
     /**
      * CONTROLLER.GET_LATEST_BLOCK.DESCRIPTION
      * CONTROLLER.GET_LATEST_BLOCK.SUMMARY
      */
-    async getLatestBlock(requestParameters, initOverrides) {
-        const response = await this.getLatestBlockRaw(requestParameters, initOverrides);
-        return await response.value();
+    getLatestBlock(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getLatestBlockRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
     }
     /**
      * CONTROLLER.GET_SUPPORTED_BLOCKCHAINS.DESCRIPTION
      * CONTROLLER.GET_SUPPORTED_BLOCKCHAINS.SUMMARY
      */
-    async getSupportedBlockchainsRaw(initOverrides) {
-        const queryParameters = {};
-        const headerParameters = {};
-        if (this.configuration && this.configuration.accessToken) {
-            const token = this.configuration.accessToken;
-            const tokenString = await token("bearer", []);
-            if (tokenString) {
-                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+    getSupportedBlockchainsRaw(initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queryParameters = {};
+            const headerParameters = {};
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearer", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
             }
-        }
-        let urlPath = `/v1/blockchain`;
-        const response = await this.request({
-            path: urlPath,
-            method: 'GET',
-            headers: headerParameters,
-            query: queryParameters,
-        }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(BlockchainDTOFromJSON));
+            let urlPath = `/v1/blockchain`;
+            const response = yield this.request({
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(BlockchainDTOFromJSON));
+        });
     }
     /**
      * CONTROLLER.GET_SUPPORTED_BLOCKCHAINS.DESCRIPTION
      * CONTROLLER.GET_SUPPORTED_BLOCKCHAINS.SUMMARY
      */
-    async getSupportedBlockchains(initOverrides) {
-        const response = await this.getSupportedBlockchainsRaw(initOverrides);
-        return await response.value();
+    getSupportedBlockchains(initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getSupportedBlockchainsRaw(initOverrides);
+            return yield response.value();
+        });
     }
 }
 /**

package/dist/esm/openapi/apis/DefiSolanaMoonshotApi.js

@@ -11,6 +11,15 @@
  * https://openapi-generator.tech
  * Do not edit the class manually.
  */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 import * as runtime from '../runtime';
 import { MoonshotCreateTokenInputToJSON, MoonshotCreateTokenReplyFromJSON, MoonshotSubmitCreateToken200ResponseFromJSON, MoonshotSubmitCreateTokenInputToJSON, } from '../models/index';
 /**
@@ -21,72 +30,80 @@ export class DefiSolanaMoonshotApi extends runtime.BaseAPI {
      * CONTROLLER.MOONSHOT.CREATE_TOKEN.DESCRIPTION
      * CONTROLLER.MOONSHOT.CREATE_TOKEN.SUMMARY
      */
-    async moonshotCreateTokenRaw(requestParameters, initOverrides) {
-        if (requestParameters['moonshotCreateTokenInput'] == null) {
-            throw new runtime.RequiredError('moonshotCreateTokenInput', 'Required parameter "moonshotCreateTokenInput" was null or undefined when calling moonshotCreateToken().');
-        }
-        const queryParameters = {};
-        const headerParameters = {};
-        headerParameters['Content-Type'] = 'application/json';
-        if (this.configuration && this.configuration.accessToken) {
-            const token = this.configuration.accessToken;
-            const tokenString = await token("bearer", []);
-            if (tokenString) {
-                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+    moonshotCreateTokenRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['moonshotCreateTokenInput'] == null) {
+                throw new runtime.RequiredError('moonshotCreateTokenInput', 'Required parameter "moonshotCreateTokenInput" was null or undefined when calling moonshotCreateToken().');
             }
-        }
-        let urlPath = `/v1/solana/moonshot/create`;
-        const response = await this.request({
-            path: urlPath,
-            method: 'POST',
-            headers: headerParameters,
-            query: queryParameters,
-            body: MoonshotCreateTokenInputToJSON(requestParameters['moonshotCreateTokenInput']),
-        }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => MoonshotCreateTokenReplyFromJSON(jsonValue));
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearer", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            let urlPath = `/v1/solana/moonshot/create`;
+            const response = yield this.request({
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: MoonshotCreateTokenInputToJSON(requestParameters['moonshotCreateTokenInput']),
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => MoonshotCreateTokenReplyFromJSON(jsonValue));
+        });
     }
     /**
      * CONTROLLER.MOONSHOT.CREATE_TOKEN.DESCRIPTION
      * CONTROLLER.MOONSHOT.CREATE_TOKEN.SUMMARY
      */
-    async moonshotCreateToken(requestParameters, initOverrides) {
-        const response = await this.moonshotCreateTokenRaw(requestParameters, initOverrides);
-        return await response.value();
+    moonshotCreateToken(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.moonshotCreateTokenRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
     }
     /**
      * CONTROLLER.MOONSHOT.SUBMIT_CREATE_TOKEN.DESCRIPTION
      * CONTROLLER.MOONSHOT.SUBMIT_CREATE_TOKEN.SUMMARY
      */
-    async moonshotSubmitCreateTokenRaw(requestParameters, initOverrides) {
-        if (requestParameters['moonshotSubmitCreateTokenInput'] == null) {
-            throw new runtime.RequiredError('moonshotSubmitCreateTokenInput', 'Required parameter "moonshotSubmitCreateTokenInput" was null or undefined when calling moonshotSubmitCreateToken().');
-        }
-        const queryParameters = {};
-        const headerParameters = {};
-        headerParameters['Content-Type'] = 'application/json';
-        if (this.configuration && this.configuration.accessToken) {
-            const token = this.configuration.accessToken;
-            const tokenString = await token("bearer", []);
-            if (tokenString) {
-                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+    moonshotSubmitCreateTokenRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['moonshotSubmitCreateTokenInput'] == null) {
+                throw new runtime.RequiredError('moonshotSubmitCreateTokenInput', 'Required parameter "moonshotSubmitCreateTokenInput" was null or undefined when calling moonshotSubmitCreateToken().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearer", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
             }
-        }
-        let urlPath = `/v1/solana/moonshot/submitCreateToken`;
-        const response = await this.request({
-            path: urlPath,
-            method: 'POST',
-            headers: headerParameters,
-            query: queryParameters,
-            body: MoonshotSubmitCreateTokenInputToJSON(requestParameters['moonshotSubmitCreateTokenInput']),
-        }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => MoonshotSubmitCreateToken200ResponseFromJSON(jsonValue));
+            let urlPath = `/v1/solana/moonshot/submitCreateToken`;
+            const response = yield this.request({
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: MoonshotSubmitCreateTokenInputToJSON(requestParameters['moonshotSubmitCreateTokenInput']),
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => MoonshotSubmitCreateToken200ResponseFromJSON(jsonValue));
+        });
     }
     /**
      * CONTROLLER.MOONSHOT.SUBMIT_CREATE_TOKEN.DESCRIPTION
      * CONTROLLER.MOONSHOT.SUBMIT_CREATE_TOKEN.SUMMARY
      */
-    async moonshotSubmitCreateToken(requestParameters, initOverrides) {
-        const response = await this.moonshotSubmitCreateTokenRaw(requestParameters, initOverrides);
-        return await response.value();
+    moonshotSubmitCreateToken(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.moonshotSubmitCreateTokenRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
     }
 }

package/dist/esm/openapi/apis/DefiSolanaPumpfunApi.js

@@ -11,6 +11,15 @@
  * https://openapi-generator.tech
  * Do not edit the class manually.
  */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 import * as runtime from '../runtime';
 import { PumpCreateTokenInputToJSON, PumpCreateTokenReplyFromJSON, } from '../models/index';
 /**
@@ -21,36 +30,40 @@ export class DefiSolanaPumpfunApi extends runtime.BaseAPI {
      * CONTROLLER.PUMPFUN.CREATE_TOKEN.DESCRIPTION
      * CONTROLLER.PUMPFUN.CREATE_TOKEN.SUMMARY
      */
-    async pumpfunCreateTokenRaw(requestParameters, initOverrides) {
-        if (requestParameters['pumpCreateTokenInput'] == null) {
-            throw new runtime.RequiredError('pumpCreateTokenInput', 'Required parameter "pumpCreateTokenInput" was null or undefined when calling pumpfunCreateToken().');
-        }
-        const queryParameters = {};
-        const headerParameters = {};
-        headerParameters['Content-Type'] = 'application/json';
-        if (this.configuration && this.configuration.accessToken) {
-            const token = this.configuration.accessToken;
-            const tokenString = await token("bearer", []);
-            if (tokenString) {
-                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+    pumpfunCreateTokenRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['pumpCreateTokenInput'] == null) {
+                throw new runtime.RequiredError('pumpCreateTokenInput', 'Required parameter "pumpCreateTokenInput" was null or undefined when calling pumpfunCreateToken().');
             }
-        }
-        let urlPath = `/v1/solana/pumpfun/create`;
-        const response = await this.request({
-            path: urlPath,
-            method: 'POST',
-            headers: headerParameters,
-            query: queryParameters,
-            body: PumpCreateTokenInputToJSON(requestParameters['pumpCreateTokenInput']),
-        }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => PumpCreateTokenReplyFromJSON(jsonValue));
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearer", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            let urlPath = `/v1/solana/pumpfun/create`;
+            const response = yield this.request({
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: PumpCreateTokenInputToJSON(requestParameters['pumpCreateTokenInput']),
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => PumpCreateTokenReplyFromJSON(jsonValue));
+        });
     }
     /**
      * CONTROLLER.PUMPFUN.CREATE_TOKEN.DESCRIPTION
      * CONTROLLER.PUMPFUN.CREATE_TOKEN.SUMMARY
      */
-    async pumpfunCreateToken(requestParameters, initOverrides) {
-        const response = await this.pumpfunCreateTokenRaw(requestParameters, initOverrides);
-        return await response.value();
+    pumpfunCreateToken(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.pumpfunCreateTokenRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
     }
 }