zklighter-perps 1.0.28 → 1.0.30

package/apis/BlockApi.ts

@@ -28,15 +28,15 @@ import {
     ResultCodeToJSON,
 } from '../models/index';
 
-export interface GetBlockRequest {
-    by: GetBlockByEnum;
+export interface BlockRequest {
+    by: BlockByEnum;
     value: string;
 }
 
-export interface GetBlocksRequest {
+export interface BlocksRequest {
     limit: number;
     index?: number;
-    sort?: GetBlocksSortEnum;
+    sort?: BlocksSortEnum;
 }
 
 /**
@@ -46,20 +46,20 @@ export class BlockApi extends runtime.BaseAPI {
 
     /**
      * Get block by its height or commitment
-     * GetBlock
+     * block
      */
-    async getBlockRaw(requestParameters: GetBlockRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Blocks>> {
+    async blockRaw(requestParameters: BlockRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Blocks>> {
         if (requestParameters['by'] == null) {
             throw new runtime.RequiredError(
                 'by',
-                'Required parameter "by" was null or undefined when calling getBlock().'
+                'Required parameter "by" was null or undefined when calling block().'
             );
         }
 
         if (requestParameters['value'] == null) {
             throw new runtime.RequiredError(
                 'value',
-                'Required parameter "value" was null or undefined when calling getBlock().'
+                'Required parameter "value" was null or undefined when calling block().'
             );
         }
 
@@ -87,22 +87,22 @@ export class BlockApi extends runtime.BaseAPI {
 
     /**
      * Get block by its height or commitment
-     * GetBlock
+     * block
      */
-    async getBlock(requestParameters: GetBlockRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Blocks> {
-        const response = await this.getBlockRaw(requestParameters, initOverrides);
+    async block(requestParameters: BlockRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Blocks> {
+        const response = await this.blockRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
      * Get blocks
-     * GetBlocks
+     * blocks
      */
-    async getBlocksRaw(requestParameters: GetBlocksRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Blocks>> {
+    async blocksRaw(requestParameters: BlocksRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Blocks>> {
         if (requestParameters['limit'] == null) {
             throw new runtime.RequiredError(
                 'limit',
-                'Required parameter "limit" was null or undefined when calling getBlocks().'
+                'Required parameter "limit" was null or undefined when calling blocks().'
             );
         }
 
@@ -134,17 +134,18 @@ export class BlockApi extends runtime.BaseAPI {
 
     /**
      * Get blocks
-     * GetBlocks
+     * blocks
      */
-    async getBlocks(requestParameters: GetBlocksRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Blocks> {
-        const response = await this.getBlocksRaw(requestParameters, initOverrides);
+    async blocks(requestParameters: BlocksRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Blocks> {
+        const response = await this.blocksRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * GetCurrentHeight
+     * Get current height
+     * currentHeight
      */
-    async getCurrentHeightRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CurrentHeight>> {
+    async currentHeightRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CurrentHeight>> {
         const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -160,10 +161,11 @@ export class BlockApi extends runtime.BaseAPI {
     }
 
     /**
-     * GetCurrentHeight
+     * Get current height
+     * currentHeight
      */
-    async getCurrentHeight(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CurrentHeight> {
-        const response = await this.getCurrentHeightRaw(initOverrides);
+    async currentHeight(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CurrentHeight> {
+        const response = await this.currentHeightRaw(initOverrides);
         return await response.value();
     }
 
@@ -172,16 +174,16 @@ export class BlockApi extends runtime.BaseAPI {
 /**
  * @export
  */
-export const GetBlockByEnum = {
+export const BlockByEnum = {
     Commitment: 'commitment',
     Height: 'height'
 } as const;
-export type GetBlockByEnum = typeof GetBlockByEnum[keyof typeof GetBlockByEnum];
+export type BlockByEnum = typeof BlockByEnum[keyof typeof BlockByEnum];
 /**
  * @export
  */
-export const GetBlocksSortEnum = {
+export const BlocksSortEnum = {
     Asc: 'asc',
     Desc: 'desc'
 } as const;
-export type GetBlocksSortEnum = typeof GetBlocksSortEnum[keyof typeof GetBlocksSortEnum];
+export type BlocksSortEnum = typeof BlocksSortEnum[keyof typeof BlocksSortEnum];

package/apis/CandlestickApi.ts

@@ -28,17 +28,17 @@ import {
     ResultCodeToJSON,
 } from '../models/index';
 
-export interface GetCandlesticksRequest {
+export interface CandlesticksRequest {
     market_id: number;
-    resolution: GetCandlesticksResolutionEnum;
+    resolution: CandlesticksResolutionEnum;
     start_timestamp: number;
     end_timestamp: number;
     count_back: number;
 }
 
-export interface GetFundingsRequest {
+export interface FundingsRequest {
     market_id: number;
-    resolution: GetFundingsResolutionEnum;
+    resolution: FundingsResolutionEnum;
     start_timestamp: number;
     end_timestamp: number;
     count_back: number;
@@ -51,41 +51,41 @@ export class CandlestickApi extends runtime.BaseAPI {
 
     /**
      * Get candlesticks
-     * GetCandlesticks
+     * candlesticks
      */
-    async getCandlesticksRaw(requestParameters: GetCandlesticksRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Candlesticks>> {
+    async candlesticksRaw(requestParameters: CandlesticksRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Candlesticks>> {
         if (requestParameters['market_id'] == null) {
             throw new runtime.RequiredError(
                 'market_id',
-                'Required parameter "market_id" was null or undefined when calling getCandlesticks().'
+                'Required parameter "market_id" was null or undefined when calling candlesticks().'
             );
         }
 
         if (requestParameters['resolution'] == null) {
             throw new runtime.RequiredError(
                 'resolution',
-                'Required parameter "resolution" was null or undefined when calling getCandlesticks().'
+                'Required parameter "resolution" was null or undefined when calling candlesticks().'
             );
         }
 
         if (requestParameters['start_timestamp'] == null) {
             throw new runtime.RequiredError(
                 'start_timestamp',
-                'Required parameter "start_timestamp" was null or undefined when calling getCandlesticks().'
+                'Required parameter "start_timestamp" was null or undefined when calling candlesticks().'
             );
         }
 
         if (requestParameters['end_timestamp'] == null) {
             throw new runtime.RequiredError(
                 'end_timestamp',
-                'Required parameter "end_timestamp" was null or undefined when calling getCandlesticks().'
+                'Required parameter "end_timestamp" was null or undefined when calling candlesticks().'
             );
         }
 
         if (requestParameters['count_back'] == null) {
             throw new runtime.RequiredError(
                 'count_back',
-                'Required parameter "count_back" was null or undefined when calling getCandlesticks().'
+                'Required parameter "count_back" was null or undefined when calling candlesticks().'
             );
         }
 
@@ -125,50 +125,50 @@ export class CandlestickApi extends runtime.BaseAPI {
 
     /**
      * Get candlesticks
-     * GetCandlesticks
+     * candlesticks
      */
-    async getCandlesticks(requestParameters: GetCandlesticksRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Candlesticks> {
-        const response = await this.getCandlesticksRaw(requestParameters, initOverrides);
+    async candlesticks(requestParameters: CandlesticksRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Candlesticks> {
+        const response = await this.candlesticksRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
      * Get fundings
-     * GetFundings
+     * fundings
      */
-    async getFundingsRaw(requestParameters: GetFundingsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Fundings>> {
+    async fundingsRaw(requestParameters: FundingsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Fundings>> {
         if (requestParameters['market_id'] == null) {
             throw new runtime.RequiredError(
                 'market_id',
-                'Required parameter "market_id" was null or undefined when calling getFundings().'
+                'Required parameter "market_id" was null or undefined when calling fundings().'
             );
         }
 
         if (requestParameters['resolution'] == null) {
             throw new runtime.RequiredError(
                 'resolution',
-                'Required parameter "resolution" was null or undefined when calling getFundings().'
+                'Required parameter "resolution" was null or undefined when calling fundings().'
             );
         }
 
         if (requestParameters['start_timestamp'] == null) {
             throw new runtime.RequiredError(
                 'start_timestamp',
-                'Required parameter "start_timestamp" was null or undefined when calling getFundings().'
+                'Required parameter "start_timestamp" was null or undefined when calling fundings().'
             );
         }
 
         if (requestParameters['end_timestamp'] == null) {
             throw new runtime.RequiredError(
                 'end_timestamp',
-                'Required parameter "end_timestamp" was null or undefined when calling getFundings().'
+                'Required parameter "end_timestamp" was null or undefined when calling fundings().'
             );
         }
 
         if (requestParameters['count_back'] == null) {
             throw new runtime.RequiredError(
                 'count_back',
-                'Required parameter "count_back" was null or undefined when calling getFundings().'
+                'Required parameter "count_back" was null or undefined when calling fundings().'
             );
         }
 
@@ -208,10 +208,10 @@ export class CandlestickApi extends runtime.BaseAPI {
 
     /**
      * Get fundings
-     * GetFundings
+     * fundings
      */
-    async getFundings(requestParameters: GetFundingsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Fundings> {
-        const response = await this.getFundingsRaw(requestParameters, initOverrides);
+    async fundings(requestParameters: FundingsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Fundings> {
+        const response = await this.fundingsRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
@@ -220,7 +220,7 @@ export class CandlestickApi extends runtime.BaseAPI {
 /**
  * @export
  */
-export const GetCandlesticksResolutionEnum = {
+export const CandlesticksResolutionEnum = {
     _1m: '1m',
     _5m: '5m',
     _15m: '15m',
@@ -228,11 +228,11 @@ export const GetCandlesticksResolutionEnum = {
     _4h: '4h',
     _1d: '1d'
 } as const;
-export type GetCandlesticksResolutionEnum = typeof GetCandlesticksResolutionEnum[keyof typeof GetCandlesticksResolutionEnum];
+export type CandlesticksResolutionEnum = typeof CandlesticksResolutionEnum[keyof typeof CandlesticksResolutionEnum];
 /**
  * @export
  */
-export const GetFundingsResolutionEnum = {
+export const FundingsResolutionEnum = {
     _1h: '1h'
 } as const;
-export type GetFundingsResolutionEnum = typeof GetFundingsResolutionEnum[keyof typeof GetFundingsResolutionEnum];
+export type FundingsResolutionEnum = typeof FundingsResolutionEnum[keyof typeof FundingsResolutionEnum];

package/apis/InfoApi.ts

@@ -34,7 +34,7 @@ import {
     SearchToJSON,
 } from '../models/index';
 
-export interface GetRollbacksRequest {
+export interface RollbacksRequest {
     from_block_height: number;
     offset: number;
     limit: number;
@@ -51,9 +51,9 @@ export class InfoApi extends runtime.BaseAPI {
 
     /**
      * Get zklighter l1 general info, including contract address and rpc info
-     * GetLayer1BasicInfo
+     * layer1BasicInfo
      */
-    async getLayer1BasicInfoRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Layer1BasicInfo>> {
+    async layer1BasicInfoRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Layer1BasicInfo>> {
         const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -70,18 +70,18 @@ export class InfoApi extends runtime.BaseAPI {
 
     /**
      * Get zklighter l1 general info, including contract address and rpc info
-     * GetLayer1BasicInfo
+     * layer1BasicInfo
      */
-    async getLayer1BasicInfo(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Layer1BasicInfo> {
-        const response = await this.getLayer1BasicInfoRaw(initOverrides);
+    async layer1BasicInfo(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Layer1BasicInfo> {
+        const response = await this.layer1BasicInfoRaw(initOverrides);
         return await response.value();
     }
 
     /**
      * Get zklighter general info, including contract address, and count of transactions and active users
-     * GetLayer2BasicInfo
+     * layer2BasicInfo
      */
-    async getLayer2BasicInfoRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Layer2BasicInfo>> {
+    async layer2BasicInfoRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Layer2BasicInfo>> {
         const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -98,36 +98,36 @@ export class InfoApi extends runtime.BaseAPI {
 
     /**
      * Get zklighter general info, including contract address, and count of transactions and active users
-     * GetLayer2BasicInfo
+     * layer2BasicInfo
      */
-    async getLayer2BasicInfo(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Layer2BasicInfo> {
-        const response = await this.getLayer2BasicInfoRaw(initOverrides);
+    async layer2BasicInfo(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Layer2BasicInfo> {
+        const response = await this.layer2BasicInfoRaw(initOverrides);
         return await response.value();
     }
 
     /**
      * Get rollbacks
-     * GetRollbacks
+     * rollbacks
      */
-    async getRollbacksRaw(requestParameters: GetRollbacksRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Rollbacks>> {
+    async rollbacksRaw(requestParameters: RollbacksRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Rollbacks>> {
         if (requestParameters['from_block_height'] == null) {
             throw new runtime.RequiredError(
                 'from_block_height',
-                'Required parameter "from_block_height" was null or undefined when calling getRollbacks().'
+                'Required parameter "from_block_height" was null or undefined when calling rollbacks().'
             );
         }
 
         if (requestParameters['offset'] == null) {
             throw new runtime.RequiredError(
                 'offset',
-                'Required parameter "offset" was null or undefined when calling getRollbacks().'
+                'Required parameter "offset" was null or undefined when calling rollbacks().'
             );
         }
 
         if (requestParameters['limit'] == null) {
             throw new runtime.RequiredError(
                 'limit',
-                'Required parameter "limit" was null or undefined when calling getRollbacks().'
+                'Required parameter "limit" was null or undefined when calling rollbacks().'
             );
         }
 
@@ -159,16 +159,16 @@ export class InfoApi extends runtime.BaseAPI {
 
     /**
      * Get rollbacks
-     * GetRollbacks
+     * rollbacks
      */
-    async getRollbacks(requestParameters: GetRollbacksRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Rollbacks> {
-        const response = await this.getRollbacksRaw(requestParameters, initOverrides);
+    async rollbacks(requestParameters: RollbacksRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Rollbacks> {
+        const response = await this.rollbacksRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
      * Search with a specific keyword
-     * Search
+     * search
      */
     async searchRaw(requestParameters: SearchRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Search>> {
         if (requestParameters['keyword'] == null) {
@@ -198,7 +198,7 @@ export class InfoApi extends runtime.BaseAPI {
 
     /**
      * Search with a specific keyword
-     * Search
+     * search
      */
     async search(requestParameters: SearchRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Search> {
         const response = await this.searchRaw(requestParameters, initOverrides);

package/apis/LiquidationApi.ts

@@ -36,8 +36,8 @@ export interface MarkNotifReadRequest {
 export class LiquidationApi extends runtime.BaseAPI {
 
     /**
-     * Mark
-     * MarkNotifRead
+     * Mark liquidation notification as read
+     * markNotifRead
      */
     async markNotifReadRaw(requestParameters: MarkNotifReadRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ResultCode>> {
         if (requestParameters['notif_type'] == null) {
@@ -110,8 +110,8 @@ export class LiquidationApi extends runtime.BaseAPI {
     }
 
     /**
-     * Mark
-     * MarkNotifRead
+     * Mark liquidation notification as read
+     * markNotifRead
      */
     async markNotifRead(requestParameters: MarkNotifReadRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ResultCode> {
         const response = await this.markNotifReadRaw(requestParameters, initOverrides);