@chainstream-io/sdk 0.0.6 → 0.0.8

package/src/openapi/models/all.ts

@@ -4,20 +4,21 @@ export * from '../models/Candle'
 export * from '../models/ClaimRedPacketInput'
 export * from '../models/CreateRedPacketInput'
 export * from '../models/CreateRedPacketReply'
+export * from '../models/CreateTokenReply'
+export * from '../models/DexCreateTokenInput'
 export * from '../models/DexDTO'
-export * from '../models/DexMintInput'
 export * from '../models/DexPage'
 export * from '../models/DexPoolDTO'
 export * from '../models/FilterCondition'
 export * from '../models/GainersAndLosersDTO'
 export * from '../models/GainersAndLosersPage'
 export * from '../models/Link'
-export * from '../models/MintInput'
-export * from '../models/MintReply'
-export * from '../models/MoonshotMintReply'
-export * from '../models/MoonshotSubmitMint200Response'
-export * from '../models/PumpMintInput'
-export * from '../models/PumpMintReply'
+export * from '../models/MoonshotCreateTokenInput'
+export * from '../models/MoonshotCreateTokenReply'
+export * from '../models/MoonshotSubmitCreateToken200Response'
+export * from '../models/MoonshotSubmitCreateTokenInput'
+export * from '../models/PumpCreateTokenInput'
+export * from '../models/PumpCreateTokenReply'
 export * from '../models/RedPacketClaimDTO'
 export * from '../models/RedPacketClaimsPage'
 export * from '../models/RedPacketDTO'
@@ -28,7 +29,6 @@ export * from '../models/RedPacketsPage'
 export * from '../models/Resolution'
 export * from '../models/SendTxInput'
 export * from '../models/SendTxResponse'
-export * from '../models/SubmitInput'
 export * from '../models/SwapInput'
 export * from '../models/SwapReply'
 export * from '../models/SwapRouteInput'

package/src/openapi/types/ObjectParamAPI.ts

@@ -7,20 +7,21 @@ import { Candle } from '../models/Candle';
 import { ClaimRedPacketInput } from '../models/ClaimRedPacketInput';
 import { CreateRedPacketInput } from '../models/CreateRedPacketInput';
 import { CreateRedPacketReply } from '../models/CreateRedPacketReply';
+import { CreateTokenReply } from '../models/CreateTokenReply';
+import { DexCreateTokenInput } from '../models/DexCreateTokenInput';
 import { DexDTO } from '../models/DexDTO';
-import { DexMintInput } from '../models/DexMintInput';
 import { DexPage } from '../models/DexPage';
 import { DexPoolDTO } from '../models/DexPoolDTO';
 import { FilterCondition } from '../models/FilterCondition';
 import { GainersAndLosersDTO } from '../models/GainersAndLosersDTO';
 import { GainersAndLosersPage } from '../models/GainersAndLosersPage';
 import { Link } from '../models/Link';
-import { MintInput } from '../models/MintInput';
-import { MintReply } from '../models/MintReply';
-import { MoonshotMintReply } from '../models/MoonshotMintReply';
-import { MoonshotSubmitMint200Response } from '../models/MoonshotSubmitMint200Response';
-import { PumpMintInput } from '../models/PumpMintInput';
-import { PumpMintReply } from '../models/PumpMintReply';
+import { MoonshotCreateTokenInput } from '../models/MoonshotCreateTokenInput';
+import { MoonshotCreateTokenReply } from '../models/MoonshotCreateTokenReply';
+import { MoonshotSubmitCreateToken200Response } from '../models/MoonshotSubmitCreateToken200Response';
+import { MoonshotSubmitCreateTokenInput } from '../models/MoonshotSubmitCreateTokenInput';
+import { PumpCreateTokenInput } from '../models/PumpCreateTokenInput';
+import { PumpCreateTokenReply } from '../models/PumpCreateTokenReply';
 import { RedPacketClaimDTO } from '../models/RedPacketClaimDTO';
 import { RedPacketClaimsPage } from '../models/RedPacketClaimsPage';
 import { RedPacketDTO } from '../models/RedPacketDTO';
@@ -31,7 +32,6 @@ import { RedPacketsPage } from '../models/RedPacketsPage';
 import { Resolution } from '../models/Resolution';
 import { SendTxInput } from '../models/SendTxInput';
 import { SendTxResponse } from '../models/SendTxResponse';
-import { SubmitInput } from '../models/SubmitInput';
 import { SwapInput } from '../models/SwapInput';
 import { SwapReply } from '../models/SwapReply';
 import { SwapRouteInput } from '../models/SwapRouteInput';
@@ -125,22 +125,22 @@ export class ObjectBlockchainApi {
 import { ObservableDefiSolanaMoonshotApi } from "./ObservableAPI";
 import { DefiSolanaMoonshotApiRequestFactory, DefiSolanaMoonshotApiResponseProcessor} from "../apis/DefiSolanaMoonshotApi";
 
-export interface DefiSolanaMoonshotApiMoonshotMintRequest {
+export interface DefiSolanaMoonshotApiMoonshotCreateTokenRequest {
     /**
      * Token creation parameters
-     * @type MintInput
-     * @memberof DefiSolanaMoonshotApimoonshotMint
+     * @type MoonshotCreateTokenInput
+     * @memberof DefiSolanaMoonshotApimoonshotCreateToken
      */
-    mintInput: MintInput
+    moonshotCreateTokenInput: MoonshotCreateTokenInput
 }
 
-export interface DefiSolanaMoonshotApiMoonshotSubmitMintRequest {
+export interface DefiSolanaMoonshotApiMoonshotSubmitCreateTokenRequest {
     /**
      * Signed transaction and token details
-     * @type SubmitInput
-     * @memberof DefiSolanaMoonshotApimoonshotSubmitMint
+     * @type MoonshotSubmitCreateTokenInput
+     * @memberof DefiSolanaMoonshotApimoonshotSubmitCreateToken
      */
-    submitInput: SubmitInput
+    moonshotSubmitCreateTokenInput: MoonshotSubmitCreateTokenInput
 }
 
 export class ObjectDefiSolanaMoonshotApi {
@@ -151,39 +151,39 @@ export class ObjectDefiSolanaMoonshotApi {
     }
 
     /**
-     * CONTROLLER.MOONSHOT.MINT.DESCRIPTION
-     * CONTROLLER.MOONSHOT.MINT.SUMMARY
+     * CONTROLLER.MOONSHOT.CREATE_TOKEN.DESCRIPTION
+     * CONTROLLER.MOONSHOT.CREATE_TOKEN.SUMMARY
      * @param param the request object
      */
-    public moonshotMintWithHttpInfo(param: DefiSolanaMoonshotApiMoonshotMintRequest, options?: Configuration): Promise<HttpInfo<MoonshotMintReply>> {
-        return this.api.moonshotMintWithHttpInfo(param.mintInput,  options).toPromise();
+    public moonshotCreateTokenWithHttpInfo(param: DefiSolanaMoonshotApiMoonshotCreateTokenRequest, options?: Configuration): Promise<HttpInfo<MoonshotCreateTokenReply>> {
+        return this.api.moonshotCreateTokenWithHttpInfo(param.moonshotCreateTokenInput,  options).toPromise();
     }
 
     /**
-     * CONTROLLER.MOONSHOT.MINT.DESCRIPTION
-     * CONTROLLER.MOONSHOT.MINT.SUMMARY
+     * CONTROLLER.MOONSHOT.CREATE_TOKEN.DESCRIPTION
+     * CONTROLLER.MOONSHOT.CREATE_TOKEN.SUMMARY
      * @param param the request object
      */
-    public moonshotMint(param: DefiSolanaMoonshotApiMoonshotMintRequest, options?: Configuration): Promise<MoonshotMintReply> {
-        return this.api.moonshotMint(param.mintInput,  options).toPromise();
+    public moonshotCreateToken(param: DefiSolanaMoonshotApiMoonshotCreateTokenRequest, options?: Configuration): Promise<MoonshotCreateTokenReply> {
+        return this.api.moonshotCreateToken(param.moonshotCreateTokenInput,  options).toPromise();
     }
 
     /**
-     * CONTROLLER.MOONSHOT.SUBMIT_MINT.DESCRIPTION
-     * CONTROLLER.MOONSHOT.SUBMIT_MINT.SUMMARY
+     * CONTROLLER.MOONSHOT.SUBMIT_CREATE_TOKEN.DESCRIPTION
+     * CONTROLLER.MOONSHOT.SUBMIT_CREATE_TOKEN.SUMMARY
      * @param param the request object
      */
-    public moonshotSubmitMintWithHttpInfo(param: DefiSolanaMoonshotApiMoonshotSubmitMintRequest, options?: Configuration): Promise<HttpInfo<MoonshotSubmitMint200Response>> {
-        return this.api.moonshotSubmitMintWithHttpInfo(param.submitInput,  options).toPromise();
+    public moonshotSubmitCreateTokenWithHttpInfo(param: DefiSolanaMoonshotApiMoonshotSubmitCreateTokenRequest, options?: Configuration): Promise<HttpInfo<MoonshotSubmitCreateToken200Response>> {
+        return this.api.moonshotSubmitCreateTokenWithHttpInfo(param.moonshotSubmitCreateTokenInput,  options).toPromise();
     }
 
     /**
-     * CONTROLLER.MOONSHOT.SUBMIT_MINT.DESCRIPTION
-     * CONTROLLER.MOONSHOT.SUBMIT_MINT.SUMMARY
+     * CONTROLLER.MOONSHOT.SUBMIT_CREATE_TOKEN.DESCRIPTION
+     * CONTROLLER.MOONSHOT.SUBMIT_CREATE_TOKEN.SUMMARY
      * @param param the request object
      */
-    public moonshotSubmitMint(param: DefiSolanaMoonshotApiMoonshotSubmitMintRequest, options?: Configuration): Promise<MoonshotSubmitMint200Response> {
-        return this.api.moonshotSubmitMint(param.submitInput,  options).toPromise();
+    public moonshotSubmitCreateToken(param: DefiSolanaMoonshotApiMoonshotSubmitCreateTokenRequest, options?: Configuration): Promise<MoonshotSubmitCreateToken200Response> {
+        return this.api.moonshotSubmitCreateToken(param.moonshotSubmitCreateTokenInput,  options).toPromise();
     }
 
 }
@@ -191,13 +191,13 @@ export class ObjectDefiSolanaMoonshotApi {
 import { ObservableDefiSolanaPumpfunApi } from "./ObservableAPI";
 import { DefiSolanaPumpfunApiRequestFactory, DefiSolanaPumpfunApiResponseProcessor} from "../apis/DefiSolanaPumpfunApi";
 
-export interface DefiSolanaPumpfunApiPumpfunMintRequest {
+export interface DefiSolanaPumpfunApiPumpfunCreateTokenRequest {
     /**
      * Required parameters for minting token
-     * @type PumpMintInput
-     * @memberof DefiSolanaPumpfunApipumpfunMint
+     * @type PumpCreateTokenInput
+     * @memberof DefiSolanaPumpfunApipumpfunCreateToken
      */
-    pumpMintInput: PumpMintInput
+    pumpCreateTokenInput: PumpCreateTokenInput
 }
 
 export class ObjectDefiSolanaPumpfunApi {
@@ -208,21 +208,21 @@ export class ObjectDefiSolanaPumpfunApi {
     }
 
     /**
-     * CONTROLLER.PUMPFUN.MINT.DESCRIPTION
-     * CONTROLLER.PUMPFUN.MINT.SUMMARY
+     * CONTROLLER.PUMPFUN.CREATE_TOKEN.DESCRIPTION
+     * CONTROLLER.PUMPFUN.CREATE_TOKEN.SUMMARY
      * @param param the request object
      */
-    public pumpfunMintWithHttpInfo(param: DefiSolanaPumpfunApiPumpfunMintRequest, options?: Configuration): Promise<HttpInfo<PumpMintReply>> {
-        return this.api.pumpfunMintWithHttpInfo(param.pumpMintInput,  options).toPromise();
+    public pumpfunCreateTokenWithHttpInfo(param: DefiSolanaPumpfunApiPumpfunCreateTokenRequest, options?: Configuration): Promise<HttpInfo<PumpCreateTokenReply>> {
+        return this.api.pumpfunCreateTokenWithHttpInfo(param.pumpCreateTokenInput,  options).toPromise();
     }
 
     /**
-     * CONTROLLER.PUMPFUN.MINT.DESCRIPTION
-     * CONTROLLER.PUMPFUN.MINT.SUMMARY
+     * CONTROLLER.PUMPFUN.CREATE_TOKEN.DESCRIPTION
+     * CONTROLLER.PUMPFUN.CREATE_TOKEN.SUMMARY
      * @param param the request object
      */
-    public pumpfunMint(param: DefiSolanaPumpfunApiPumpfunMintRequest, options?: Configuration): Promise<PumpMintReply> {
-        return this.api.pumpfunMint(param.pumpMintInput,  options).toPromise();
+    public pumpfunCreateToken(param: DefiSolanaPumpfunApiPumpfunCreateTokenRequest, options?: Configuration): Promise<PumpCreateTokenReply> {
+        return this.api.pumpfunCreateToken(param.pumpCreateTokenInput,  options).toPromise();
     }
 
 }
@@ -230,6 +230,22 @@ export class ObjectDefiSolanaPumpfunApi {
 import { ObservableDexApi } from "./ObservableAPI";
 import { DexApiRequestFactory, DexApiResponseProcessor} from "../apis/DexApi";
 
+export interface DexApiCreateTokenRequest {
+    /**
+     * GLOBAL.CHAIN.DESCRIPTION
+     * Defaults to: undefined
+     * @type &#39;sol&#39; | &#39;base&#39; | &#39;bsc&#39; | &#39;polygon&#39; | &#39;arbitrum&#39; | &#39;optimism&#39; | &#39;avalanche&#39; | &#39;ethereum&#39; | &#39;zksync&#39; | &#39;sui&#39;
+     * @memberof DexApicreateToken
+     */
+    chain: 'sol' | 'base' | 'bsc' | 'polygon' | 'arbitrum' | 'optimism' | 'avalanche' | 'ethereum' | 'zksync' | 'sui'
+    /**
+     * Token creation parameters
+     * @type DexCreateTokenInput
+     * @memberof DexApicreateToken
+     */
+    dexCreateTokenInput: DexCreateTokenInput
+}
+
 export interface DexApiListRequest {
     /**
      * 
@@ -256,22 +272,6 @@ export interface DexApiListRequest {
     dexProgram?: string
 }
 
-export interface DexApiMintRequest {
-    /**
-     * GLOBAL.CHAIN.DESCRIPTION
-     * Defaults to: undefined
-     * @type &#39;sol&#39; | &#39;base&#39; | &#39;bsc&#39; | &#39;polygon&#39; | &#39;arbitrum&#39; | &#39;optimism&#39; | &#39;avalanche&#39; | &#39;ethereum&#39; | &#39;zksync&#39; | &#39;sui&#39;
-     * @memberof DexApimint
-     */
-    chain: 'sol' | 'base' | 'bsc' | 'polygon' | 'arbitrum' | 'optimism' | 'avalanche' | 'ethereum' | 'zksync' | 'sui'
-    /**
-     * Token creation parameters
-     * @type DexMintInput
-     * @memberof DexApimint
-     */
-    dexMintInput: DexMintInput
-}
-
 export interface DexApiRouteRequest {
     /**
      * GLOBAL.CHAIN.DESCRIPTION
@@ -312,39 +312,39 @@ export class ObjectDexApi {
     }
 
     /**
-     * CONTROLLER.DEX.LIST.DESCRIPTION
-     * CONTROLLER.DEX.LIST.SUMMARY
+     * CONTROLLER.DEX.CREATE.DESCRIPTION
+     * CONTROLLER.DEX.CREATE.SUMMARY
      * @param param the request object
      */
-    public listWithHttpInfo(param: DexApiListRequest = {}, options?: Configuration): Promise<HttpInfo<DexPage>> {
-        return this.api.listWithHttpInfo(param.chains, param.limit, param.dexProgram,  options).toPromise();
+    public createTokenWithHttpInfo(param: DexApiCreateTokenRequest, options?: Configuration): Promise<HttpInfo<CreateTokenReply>> {
+        return this.api.createTokenWithHttpInfo(param.chain, param.dexCreateTokenInput,  options).toPromise();
     }
 
     /**
-     * CONTROLLER.DEX.LIST.DESCRIPTION
-     * CONTROLLER.DEX.LIST.SUMMARY
+     * CONTROLLER.DEX.CREATE.DESCRIPTION
+     * CONTROLLER.DEX.CREATE.SUMMARY
      * @param param the request object
      */
-    public list(param: DexApiListRequest = {}, options?: Configuration): Promise<DexPage> {
-        return this.api.list(param.chains, param.limit, param.dexProgram,  options).toPromise();
+    public createToken(param: DexApiCreateTokenRequest, options?: Configuration): Promise<CreateTokenReply> {
+        return this.api.createToken(param.chain, param.dexCreateTokenInput,  options).toPromise();
     }
 
     /**
-     * CONTROLLER.DEX.MINT.DESCRIPTION
-     * CONTROLLER.DEX.MINT.SUMMARY
+     * CONTROLLER.DEX.LIST.DESCRIPTION
+     * CONTROLLER.DEX.LIST.SUMMARY
      * @param param the request object
      */
-    public mintWithHttpInfo(param: DexApiMintRequest, options?: Configuration): Promise<HttpInfo<MintReply>> {
-        return this.api.mintWithHttpInfo(param.chain, param.dexMintInput,  options).toPromise();
+    public listWithHttpInfo(param: DexApiListRequest = {}, options?: Configuration): Promise<HttpInfo<DexPage>> {
+        return this.api.listWithHttpInfo(param.chains, param.limit, param.dexProgram,  options).toPromise();
     }
 
     /**
-     * CONTROLLER.DEX.MINT.DESCRIPTION
-     * CONTROLLER.DEX.MINT.SUMMARY
+     * CONTROLLER.DEX.LIST.DESCRIPTION
+     * CONTROLLER.DEX.LIST.SUMMARY
      * @param param the request object
      */
-    public mint(param: DexApiMintRequest, options?: Configuration): Promise<MintReply> {
-        return this.api.mint(param.chain, param.dexMintInput,  options).toPromise();
+    public list(param: DexApiListRequest = {}, options?: Configuration): Promise<DexPage> {
+        return this.api.list(param.chains, param.limit, param.dexProgram,  options).toPromise();
     }
 
     /**

package/src/openapi/types/ObservableAPI.ts

@@ -8,20 +8,21 @@ import { Candle } from '../models/Candle';
 import { ClaimRedPacketInput } from '../models/ClaimRedPacketInput';
 import { CreateRedPacketInput } from '../models/CreateRedPacketInput';
 import { CreateRedPacketReply } from '../models/CreateRedPacketReply';
+import { CreateTokenReply } from '../models/CreateTokenReply';
+import { DexCreateTokenInput } from '../models/DexCreateTokenInput';
 import { DexDTO } from '../models/DexDTO';
-import { DexMintInput } from '../models/DexMintInput';
 import { DexPage } from '../models/DexPage';
 import { DexPoolDTO } from '../models/DexPoolDTO';
 import { FilterCondition } from '../models/FilterCondition';
 import { GainersAndLosersDTO } from '../models/GainersAndLosersDTO';
 import { GainersAndLosersPage } from '../models/GainersAndLosersPage';
 import { Link } from '../models/Link';
-import { MintInput } from '../models/MintInput';
-import { MintReply } from '../models/MintReply';
-import { MoonshotMintReply } from '../models/MoonshotMintReply';
-import { MoonshotSubmitMint200Response } from '../models/MoonshotSubmitMint200Response';
-import { PumpMintInput } from '../models/PumpMintInput';
-import { PumpMintReply } from '../models/PumpMintReply';
+import { MoonshotCreateTokenInput } from '../models/MoonshotCreateTokenInput';
+import { MoonshotCreateTokenReply } from '../models/MoonshotCreateTokenReply';
+import { MoonshotSubmitCreateToken200Response } from '../models/MoonshotSubmitCreateToken200Response';
+import { MoonshotSubmitCreateTokenInput } from '../models/MoonshotSubmitCreateTokenInput';
+import { PumpCreateTokenInput } from '../models/PumpCreateTokenInput';
+import { PumpCreateTokenReply } from '../models/PumpCreateTokenReply';
 import { RedPacketClaimDTO } from '../models/RedPacketClaimDTO';
 import { RedPacketClaimsPage } from '../models/RedPacketClaimsPage';
 import { RedPacketDTO } from '../models/RedPacketDTO';
@@ -32,7 +33,6 @@ import { RedPacketsPage } from '../models/RedPacketsPage';
 import { Resolution } from '../models/Resolution';
 import { SendTxInput } from '../models/SendTxInput';
 import { SendTxResponse } from '../models/SendTxResponse';
-import { SubmitInput } from '../models/SubmitInput';
 import { SwapInput } from '../models/SwapInput';
 import { SwapReply } from '../models/SwapReply';
 import { SwapRouteInput } from '../models/SwapRouteInput';
@@ -161,12 +161,12 @@ export class ObservableDefiSolanaMoonshotApi {
     }
 
     /**
-     * CONTROLLER.MOONSHOT.MINT.DESCRIPTION
-     * CONTROLLER.MOONSHOT.MINT.SUMMARY
-     * @param mintInput Token creation parameters
+     * CONTROLLER.MOONSHOT.CREATE_TOKEN.DESCRIPTION
+     * CONTROLLER.MOONSHOT.CREATE_TOKEN.SUMMARY
+     * @param moonshotCreateTokenInput Token creation parameters
      */
-    public moonshotMintWithHttpInfo(mintInput: MintInput, _options?: Configuration): Observable<HttpInfo<MoonshotMintReply>> {
-        const requestContextPromise = this.requestFactory.moonshotMint(mintInput, _options);
+    public moonshotCreateTokenWithHttpInfo(moonshotCreateTokenInput: MoonshotCreateTokenInput, _options?: Configuration): Observable<HttpInfo<MoonshotCreateTokenReply>> {
+        const requestContextPromise = this.requestFactory.moonshotCreateToken(moonshotCreateTokenInput, _options);
 
         // build promise chain
         let middlewarePreObservable = from<RequestContext>(requestContextPromise);
@@ -180,26 +180,26 @@ export class ObservableDefiSolanaMoonshotApi {
                 for (const middleware of this.configuration.middleware) {
                     middlewarePostObservable = middlewarePostObservable.pipe(mergeMap((rsp: ResponseContext) => middleware.post(rsp)));
                 }
-                return middlewarePostObservable.pipe(map((rsp: ResponseContext) => this.responseProcessor.moonshotMintWithHttpInfo(rsp)));
+                return middlewarePostObservable.pipe(map((rsp: ResponseContext) => this.responseProcessor.moonshotCreateTokenWithHttpInfo(rsp)));
             }));
     }
 
     /**
-     * CONTROLLER.MOONSHOT.MINT.DESCRIPTION
-     * CONTROLLER.MOONSHOT.MINT.SUMMARY
-     * @param mintInput Token creation parameters
+     * CONTROLLER.MOONSHOT.CREATE_TOKEN.DESCRIPTION
+     * CONTROLLER.MOONSHOT.CREATE_TOKEN.SUMMARY
+     * @param moonshotCreateTokenInput Token creation parameters
      */
-    public moonshotMint(mintInput: MintInput, _options?: Configuration): Observable<MoonshotMintReply> {
-        return this.moonshotMintWithHttpInfo(mintInput, _options).pipe(map((apiResponse: HttpInfo<MoonshotMintReply>) => apiResponse.data));
+    public moonshotCreateToken(moonshotCreateTokenInput: MoonshotCreateTokenInput, _options?: Configuration): Observable<MoonshotCreateTokenReply> {
+        return this.moonshotCreateTokenWithHttpInfo(moonshotCreateTokenInput, _options).pipe(map((apiResponse: HttpInfo<MoonshotCreateTokenReply>) => apiResponse.data));
     }
 
     /**
-     * CONTROLLER.MOONSHOT.SUBMIT_MINT.DESCRIPTION
-     * CONTROLLER.MOONSHOT.SUBMIT_MINT.SUMMARY
-     * @param submitInput Signed transaction and token details
+     * CONTROLLER.MOONSHOT.SUBMIT_CREATE_TOKEN.DESCRIPTION
+     * CONTROLLER.MOONSHOT.SUBMIT_CREATE_TOKEN.SUMMARY
+     * @param moonshotSubmitCreateTokenInput Signed transaction and token details
      */
-    public moonshotSubmitMintWithHttpInfo(submitInput: SubmitInput, _options?: Configuration): Observable<HttpInfo<MoonshotSubmitMint200Response>> {
-        const requestContextPromise = this.requestFactory.moonshotSubmitMint(submitInput, _options);
+    public moonshotSubmitCreateTokenWithHttpInfo(moonshotSubmitCreateTokenInput: MoonshotSubmitCreateTokenInput, _options?: Configuration): Observable<HttpInfo<MoonshotSubmitCreateToken200Response>> {
+        const requestContextPromise = this.requestFactory.moonshotSubmitCreateToken(moonshotSubmitCreateTokenInput, _options);
 
         // build promise chain
         let middlewarePreObservable = from<RequestContext>(requestContextPromise);
@@ -213,17 +213,17 @@ export class ObservableDefiSolanaMoonshotApi {
                 for (const middleware of this.configuration.middleware) {
                     middlewarePostObservable = middlewarePostObservable.pipe(mergeMap((rsp: ResponseContext) => middleware.post(rsp)));
                 }
-                return middlewarePostObservable.pipe(map((rsp: ResponseContext) => this.responseProcessor.moonshotSubmitMintWithHttpInfo(rsp)));
+                return middlewarePostObservable.pipe(map((rsp: ResponseContext) => this.responseProcessor.moonshotSubmitCreateTokenWithHttpInfo(rsp)));
             }));
     }
 
     /**
-     * CONTROLLER.MOONSHOT.SUBMIT_MINT.DESCRIPTION
-     * CONTROLLER.MOONSHOT.SUBMIT_MINT.SUMMARY
-     * @param submitInput Signed transaction and token details
+     * CONTROLLER.MOONSHOT.SUBMIT_CREATE_TOKEN.DESCRIPTION
+     * CONTROLLER.MOONSHOT.SUBMIT_CREATE_TOKEN.SUMMARY
+     * @param moonshotSubmitCreateTokenInput Signed transaction and token details
      */
-    public moonshotSubmitMint(submitInput: SubmitInput, _options?: Configuration): Observable<MoonshotSubmitMint200Response> {
-        return this.moonshotSubmitMintWithHttpInfo(submitInput, _options).pipe(map((apiResponse: HttpInfo<MoonshotSubmitMint200Response>) => apiResponse.data));
+    public moonshotSubmitCreateToken(moonshotSubmitCreateTokenInput: MoonshotSubmitCreateTokenInput, _options?: Configuration): Observable<MoonshotSubmitCreateToken200Response> {
+        return this.moonshotSubmitCreateTokenWithHttpInfo(moonshotSubmitCreateTokenInput, _options).pipe(map((apiResponse: HttpInfo<MoonshotSubmitCreateToken200Response>) => apiResponse.data));
     }
 
 }
@@ -245,12 +245,12 @@ export class ObservableDefiSolanaPumpfunApi {
     }
 
     /**
-     * CONTROLLER.PUMPFUN.MINT.DESCRIPTION
-     * CONTROLLER.PUMPFUN.MINT.SUMMARY
-     * @param pumpMintInput Required parameters for minting token
+     * CONTROLLER.PUMPFUN.CREATE_TOKEN.DESCRIPTION
+     * CONTROLLER.PUMPFUN.CREATE_TOKEN.SUMMARY
+     * @param pumpCreateTokenInput Required parameters for minting token
      */
-    public pumpfunMintWithHttpInfo(pumpMintInput: PumpMintInput, _options?: Configuration): Observable<HttpInfo<PumpMintReply>> {
-        const requestContextPromise = this.requestFactory.pumpfunMint(pumpMintInput, _options);
+    public pumpfunCreateTokenWithHttpInfo(pumpCreateTokenInput: PumpCreateTokenInput, _options?: Configuration): Observable<HttpInfo<PumpCreateTokenReply>> {
+        const requestContextPromise = this.requestFactory.pumpfunCreateToken(pumpCreateTokenInput, _options);
 
         // build promise chain
         let middlewarePreObservable = from<RequestContext>(requestContextPromise);
@@ -264,17 +264,17 @@ export class ObservableDefiSolanaPumpfunApi {
                 for (const middleware of this.configuration.middleware) {
                     middlewarePostObservable = middlewarePostObservable.pipe(mergeMap((rsp: ResponseContext) => middleware.post(rsp)));
                 }
-                return middlewarePostObservable.pipe(map((rsp: ResponseContext) => this.responseProcessor.pumpfunMintWithHttpInfo(rsp)));
+                return middlewarePostObservable.pipe(map((rsp: ResponseContext) => this.responseProcessor.pumpfunCreateTokenWithHttpInfo(rsp)));
             }));
     }
 
     /**
-     * CONTROLLER.PUMPFUN.MINT.DESCRIPTION
-     * CONTROLLER.PUMPFUN.MINT.SUMMARY
-     * @param pumpMintInput Required parameters for minting token
+     * CONTROLLER.PUMPFUN.CREATE_TOKEN.DESCRIPTION
+     * CONTROLLER.PUMPFUN.CREATE_TOKEN.SUMMARY
+     * @param pumpCreateTokenInput Required parameters for minting token
      */
-    public pumpfunMint(pumpMintInput: PumpMintInput, _options?: Configuration): Observable<PumpMintReply> {
-        return this.pumpfunMintWithHttpInfo(pumpMintInput, _options).pipe(map((apiResponse: HttpInfo<PumpMintReply>) => apiResponse.data));
+    public pumpfunCreateToken(pumpCreateTokenInput: PumpCreateTokenInput, _options?: Configuration): Observable<PumpCreateTokenReply> {
+        return this.pumpfunCreateTokenWithHttpInfo(pumpCreateTokenInput, _options).pipe(map((apiResponse: HttpInfo<PumpCreateTokenReply>) => apiResponse.data));
     }
 
 }
@@ -296,14 +296,13 @@ export class ObservableDexApi {
     }
 
     /**
-     * CONTROLLER.DEX.LIST.DESCRIPTION
-     * CONTROLLER.DEX.LIST.SUMMARY
-     * @param [chains]
-     * @param [limit] DTO.DEX.QUERY.LIMIT
-     * @param [dexProgram] DTO.DEX.QUERY.DEX_PROGRAM
+     * CONTROLLER.DEX.CREATE.DESCRIPTION
+     * CONTROLLER.DEX.CREATE.SUMMARY
+     * @param chain GLOBAL.CHAIN.DESCRIPTION
+     * @param dexCreateTokenInput Token creation parameters
      */
-    public listWithHttpInfo(chains?: Array<string>, limit?: number, dexProgram?: string, _options?: Configuration): Observable<HttpInfo<DexPage>> {
-        const requestContextPromise = this.requestFactory.list(chains, limit, dexProgram, _options);
+    public createTokenWithHttpInfo(chain: 'sol' | 'base' | 'bsc' | 'polygon' | 'arbitrum' | 'optimism' | 'avalanche' | 'ethereum' | 'zksync' | 'sui', dexCreateTokenInput: DexCreateTokenInput, _options?: Configuration): Observable<HttpInfo<CreateTokenReply>> {
+        const requestContextPromise = this.requestFactory.createToken(chain, dexCreateTokenInput, _options);
 
         // build promise chain
         let middlewarePreObservable = from<RequestContext>(requestContextPromise);
@@ -317,10 +316,20 @@ export class ObservableDexApi {
                 for (const middleware of this.configuration.middleware) {
                     middlewarePostObservable = middlewarePostObservable.pipe(mergeMap((rsp: ResponseContext) => middleware.post(rsp)));
                 }
-                return middlewarePostObservable.pipe(map((rsp: ResponseContext) => this.responseProcessor.listWithHttpInfo(rsp)));
+                return middlewarePostObservable.pipe(map((rsp: ResponseContext) => this.responseProcessor.createTokenWithHttpInfo(rsp)));
             }));
     }
 
+    /**
+     * CONTROLLER.DEX.CREATE.DESCRIPTION
+     * CONTROLLER.DEX.CREATE.SUMMARY
+     * @param chain GLOBAL.CHAIN.DESCRIPTION
+     * @param dexCreateTokenInput Token creation parameters
+     */
+    public createToken(chain: 'sol' | 'base' | 'bsc' | 'polygon' | 'arbitrum' | 'optimism' | 'avalanche' | 'ethereum' | 'zksync' | 'sui', dexCreateTokenInput: DexCreateTokenInput, _options?: Configuration): Observable<CreateTokenReply> {
+        return this.createTokenWithHttpInfo(chain, dexCreateTokenInput, _options).pipe(map((apiResponse: HttpInfo<CreateTokenReply>) => apiResponse.data));
+    }
+
     /**
      * CONTROLLER.DEX.LIST.DESCRIPTION
      * CONTROLLER.DEX.LIST.SUMMARY
@@ -328,18 +337,8 @@ export class ObservableDexApi {
      * @param [limit] DTO.DEX.QUERY.LIMIT
      * @param [dexProgram] DTO.DEX.QUERY.DEX_PROGRAM
      */
-    public list(chains?: Array<string>, limit?: number, dexProgram?: string, _options?: Configuration): Observable<DexPage> {
-        return this.listWithHttpInfo(chains, limit, dexProgram, _options).pipe(map((apiResponse: HttpInfo<DexPage>) => apiResponse.data));
-    }
-
-    /**
-     * CONTROLLER.DEX.MINT.DESCRIPTION
-     * CONTROLLER.DEX.MINT.SUMMARY
-     * @param chain GLOBAL.CHAIN.DESCRIPTION
-     * @param dexMintInput Token creation parameters
-     */
-    public mintWithHttpInfo(chain: 'sol' | 'base' | 'bsc' | 'polygon' | 'arbitrum' | 'optimism' | 'avalanche' | 'ethereum' | 'zksync' | 'sui', dexMintInput: DexMintInput, _options?: Configuration): Observable<HttpInfo<MintReply>> {
-        const requestContextPromise = this.requestFactory.mint(chain, dexMintInput, _options);
+    public listWithHttpInfo(chains?: Array<string>, limit?: number, dexProgram?: string, _options?: Configuration): Observable<HttpInfo<DexPage>> {
+        const requestContextPromise = this.requestFactory.list(chains, limit, dexProgram, _options);
 
         // build promise chain
         let middlewarePreObservable = from<RequestContext>(requestContextPromise);
@@ -353,18 +352,19 @@ export class ObservableDexApi {
                 for (const middleware of this.configuration.middleware) {
                     middlewarePostObservable = middlewarePostObservable.pipe(mergeMap((rsp: ResponseContext) => middleware.post(rsp)));
                 }
-                return middlewarePostObservable.pipe(map((rsp: ResponseContext) => this.responseProcessor.mintWithHttpInfo(rsp)));
+                return middlewarePostObservable.pipe(map((rsp: ResponseContext) => this.responseProcessor.listWithHttpInfo(rsp)));
             }));
     }
 
     /**
-     * CONTROLLER.DEX.MINT.DESCRIPTION
-     * CONTROLLER.DEX.MINT.SUMMARY
-     * @param chain GLOBAL.CHAIN.DESCRIPTION
-     * @param dexMintInput Token creation parameters
+     * CONTROLLER.DEX.LIST.DESCRIPTION
+     * CONTROLLER.DEX.LIST.SUMMARY
+     * @param [chains]
+     * @param [limit] DTO.DEX.QUERY.LIMIT
+     * @param [dexProgram] DTO.DEX.QUERY.DEX_PROGRAM
      */
-    public mint(chain: 'sol' | 'base' | 'bsc' | 'polygon' | 'arbitrum' | 'optimism' | 'avalanche' | 'ethereum' | 'zksync' | 'sui', dexMintInput: DexMintInput, _options?: Configuration): Observable<MintReply> {
-        return this.mintWithHttpInfo(chain, dexMintInput, _options).pipe(map((apiResponse: HttpInfo<MintReply>) => apiResponse.data));
+    public list(chains?: Array<string>, limit?: number, dexProgram?: string, _options?: Configuration): Observable<DexPage> {
+        return this.listWithHttpInfo(chains, limit, dexProgram, _options).pipe(map((apiResponse: HttpInfo<DexPage>) => apiResponse.data));
     }
 
     /**