zklighter-perps 1.0.28 → 1.0.30

package/apis/TransactionApi.ts

@@ -40,50 +40,36 @@ import {
     TxsToJSON,
 } from '../models/index';
 
-export interface GetAccountPendingTxsRequest {
-    by: GetAccountPendingTxsByEnum;
+export interface AccountPendingTxsRequest {
+    by: AccountPendingTxsByEnum;
     value: string;
     types?: number;
 }
 
-export interface GetAccountTxsRequest {
+export interface AccountTxsRequest {
     limit: number;
-    by: GetAccountTxsByEnum;
+    by: AccountTxsByEnum;
     value: string;
     index?: number;
     types?: number;
 }
 
-export interface GetBlockTxsRequest {
-    by: GetBlockTxsByEnum;
+export interface BlockTxsRequest {
+    by: BlockTxsByEnum;
     value: string;
 }
 
-export interface GetL2SignatureBodyRequest {
+export interface L2SignatureRequest {
     tx_type: number;
     tx_info: string;
 }
 
-export interface GetNextNonceRequest {
+export interface NextNonceRequest {
     account_index: number;
     api_key_index: number;
 }
 
-export interface GetPendingTxsRequest {
-    limit: number;
-    index?: number;
-}
-
-export interface GetTxRequest {
-    by: GetTxByEnum;
-    value: string;
-}
-
-export interface GetTxFromL1TxHashRequest {
-    hash: string;
-}
-
-export interface GetTxsRequest {
+export interface PendingTxsRequest {
     limit: number;
     index?: number;
 }
@@ -98,6 +84,20 @@ export interface SendTxBatchRequest {
     tx_infos: string;
 }
 
+export interface TxRequest {
+    by: TxByEnum;
+    value: string;
+}
+
+export interface TxFromL1TxHashRequest {
+    hash: string;
+}
+
+export interface TxsRequest {
+    limit: number;
+    index?: number;
+}
+
 /**
  * 
  */
@@ -105,20 +105,20 @@ export class TransactionApi extends runtime.BaseAPI {
 
     /**
      * Get pending transactions of a specific account
-     * GetAccountPendingTxs
+     * accountPendingTxs
      */
-    async getAccountPendingTxsRaw(requestParameters: GetAccountPendingTxsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Txs>> {
+    async accountPendingTxsRaw(requestParameters: AccountPendingTxsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Txs>> {
         if (requestParameters['by'] == null) {
             throw new runtime.RequiredError(
                 'by',
-                'Required parameter "by" was null or undefined when calling getAccountPendingTxs().'
+                'Required parameter "by" was null or undefined when calling accountPendingTxs().'
             );
         }
 
         if (requestParameters['value'] == null) {
             throw new runtime.RequiredError(
                 'value',
-                'Required parameter "value" was null or undefined when calling getAccountPendingTxs().'
+                'Required parameter "value" was null or undefined when calling accountPendingTxs().'
             );
         }
 
@@ -150,36 +150,36 @@ export class TransactionApi extends runtime.BaseAPI {
 
     /**
      * Get pending transactions of a specific account
-     * GetAccountPendingTxs
+     * accountPendingTxs
      */
-    async getAccountPendingTxs(requestParameters: GetAccountPendingTxsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Txs> {
-        const response = await this.getAccountPendingTxsRaw(requestParameters, initOverrides);
+    async accountPendingTxs(requestParameters: AccountPendingTxsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Txs> {
+        const response = await this.accountPendingTxsRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
      * Get transactions of a specific account
-     * GetAccountTxs
+     * accountTxs
      */
-    async getAccountTxsRaw(requestParameters: GetAccountTxsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Txs>> {
+    async accountTxsRaw(requestParameters: AccountTxsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Txs>> {
         if (requestParameters['limit'] == null) {
             throw new runtime.RequiredError(
                 'limit',
-                'Required parameter "limit" was null or undefined when calling getAccountTxs().'
+                'Required parameter "limit" was null or undefined when calling accountTxs().'
             );
         }
 
         if (requestParameters['by'] == null) {
             throw new runtime.RequiredError(
                 'by',
-                'Required parameter "by" was null or undefined when calling getAccountTxs().'
+                'Required parameter "by" was null or undefined when calling accountTxs().'
             );
         }
 
         if (requestParameters['value'] == null) {
             throw new runtime.RequiredError(
                 'value',
-                'Required parameter "value" was null or undefined when calling getAccountTxs().'
+                'Required parameter "value" was null or undefined when calling accountTxs().'
             );
         }
 
@@ -219,29 +219,29 @@ export class TransactionApi extends runtime.BaseAPI {
 
     /**
      * Get transactions of a specific account
-     * GetAccountTxs
+     * accountTxs
      */
-    async getAccountTxs(requestParameters: GetAccountTxsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Txs> {
-        const response = await this.getAccountTxsRaw(requestParameters, initOverrides);
+    async accountTxs(requestParameters: AccountTxsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Txs> {
+        const response = await this.accountTxsRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
      * Get transactions in a block
-     * GetBlockTxs
+     * blockTxs
      */
-    async getBlockTxsRaw(requestParameters: GetBlockTxsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Txs>> {
+    async blockTxsRaw(requestParameters: BlockTxsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Txs>> {
         if (requestParameters['by'] == null) {
             throw new runtime.RequiredError(
                 'by',
-                'Required parameter "by" was null or undefined when calling getBlockTxs().'
+                'Required parameter "by" was null or undefined when calling blockTxs().'
             );
         }
 
         if (requestParameters['value'] == null) {
             throw new runtime.RequiredError(
                 'value',
-                'Required parameter "value" was null or undefined when calling getBlockTxs().'
+                'Required parameter "value" was null or undefined when calling blockTxs().'
             );
         }
 
@@ -269,29 +269,29 @@ export class TransactionApi extends runtime.BaseAPI {
 
     /**
      * Get transactions in a block
-     * GetBlockTxs
+     * blockTxs
      */
-    async getBlockTxs(requestParameters: GetBlockTxsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Txs> {
-        const response = await this.getBlockTxsRaw(requestParameters, initOverrides);
+    async blockTxs(requestParameters: BlockTxsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Txs> {
+        const response = await this.blockTxsRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
      * Get transaction signature body
-     * GetL2SignatureBody
+     * l2Signature
      */
-    async getL2SignatureBodyRaw(requestParameters: GetL2SignatureBodyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SignBody>> {
+    async l2SignatureRaw(requestParameters: L2SignatureRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SignBody>> {
         if (requestParameters['tx_type'] == null) {
             throw new runtime.RequiredError(
                 'tx_type',
-                'Required parameter "tx_type" was null or undefined when calling getL2SignatureBody().'
+                'Required parameter "tx_type" was null or undefined when calling l2Signature().'
             );
         }
 
         if (requestParameters['tx_info'] == null) {
             throw new runtime.RequiredError(
                 'tx_info',
-                'Required parameter "tx_info" was null or undefined when calling getL2SignatureBody().'
+                'Required parameter "tx_info" was null or undefined when calling l2Signature().'
             );
         }
 
@@ -334,29 +334,29 @@ export class TransactionApi extends runtime.BaseAPI {
 
     /**
      * Get transaction signature body
-     * GetL2SignatureBody
+     * l2Signature
      */
-    async getL2SignatureBody(requestParameters: GetL2SignatureBodyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SignBody> {
-        const response = await this.getL2SignatureBodyRaw(requestParameters, initOverrides);
+    async l2Signature(requestParameters: L2SignatureRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SignBody> {
+        const response = await this.l2SignatureRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
      * Get next nonce for a specific account
-     * GetNextNonce
+     * nextNonce
      */
-    async getNextNonceRaw(requestParameters: GetNextNonceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<NextNonce>> {
+    async nextNonceRaw(requestParameters: NextNonceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<NextNonce>> {
         if (requestParameters['account_index'] == null) {
             throw new runtime.RequiredError(
                 'account_index',
-                'Required parameter "account_index" was null or undefined when calling getNextNonce().'
+                'Required parameter "account_index" was null or undefined when calling nextNonce().'
             );
         }
 
         if (requestParameters['api_key_index'] == null) {
             throw new runtime.RequiredError(
                 'api_key_index',
-                'Required parameter "api_key_index" was null or undefined when calling getNextNonce().'
+                'Required parameter "api_key_index" was null or undefined when calling nextNonce().'
             );
         }
 
@@ -384,22 +384,22 @@ export class TransactionApi extends runtime.BaseAPI {
 
     /**
      * Get next nonce for a specific account
-     * GetNextNonce
+     * nextNonce
      */
-    async getNextNonce(requestParameters: GetNextNonceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<NextNonce> {
-        const response = await this.getNextNonceRaw(requestParameters, initOverrides);
+    async nextNonce(requestParameters: NextNonceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<NextNonce> {
+        const response = await this.nextNonceRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
      * Get pending transactions
-     * GetPendingTxs
+     * pendingTxs
      */
-    async getPendingTxsRaw(requestParameters: GetPendingTxsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Txs>> {
+    async pendingTxsRaw(requestParameters: PendingTxsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Txs>> {
         if (requestParameters['limit'] == null) {
             throw new runtime.RequiredError(
                 'limit',
-                'Required parameter "limit" was null or undefined when calling getPendingTxs().'
+                'Required parameter "limit" was null or undefined when calling pendingTxs().'
             );
         }
 
@@ -427,272 +427,272 @@ export class TransactionApi extends runtime.BaseAPI {
 
     /**
      * Get pending transactions
-     * GetPendingTxs
+     * pendingTxs
      */
-    async getPendingTxs(requestParameters: GetPendingTxsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Txs> {
-        const response = await this.getPendingTxsRaw(requestParameters, initOverrides);
+    async pendingTxs(requestParameters: PendingTxsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Txs> {
+        const response = await this.pendingTxsRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Get transaction by hash or sequence index
-     * GetTx
+     * You need to sign the transaction body before sending it to the server. More details can be found in the Get Started docs: [Get Started For Programmers](https://apidocs.lighter.xyz/docs/get-started-for-programmers)
+     * sendTx
      */
-    async getTxRaw(requestParameters: GetTxRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<EnrichedTx>> {
-        if (requestParameters['by'] == null) {
+    async sendTxRaw(requestParameters: SendTxRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TxHash>> {
+        if (requestParameters['tx_type'] == null) {
             throw new runtime.RequiredError(
-                'by',
-                'Required parameter "by" was null or undefined when calling getTx().'
+                'tx_type',
+                'Required parameter "tx_type" was null or undefined when calling sendTx().'
             );
         }
 
-        if (requestParameters['value'] == null) {
+        if (requestParameters['tx_info'] == null) {
             throw new runtime.RequiredError(
-                'value',
-                'Required parameter "value" was null or undefined when calling getTx().'
+                'tx_info',
+                'Required parameter "tx_info" was null or undefined when calling sendTx().'
             );
         }
 
         const queryParameters: any = {};
 
-        if (requestParameters['by'] != null) {
-            queryParameters['by'] = requestParameters['by'];
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        const consumes: runtime.Consume[] = [
+            { contentType: 'multipart/form-data' },
+        ];
+        // @ts-ignore: canConsumeForm may be unused
+        const canConsumeForm = runtime.canConsumeForm(consumes);
+
+        let formParams: { append(param: string, value: any): any };
+        let useForm = false;
+        if (useForm) {
+            formParams = new FormData();
+        } else {
+            formParams = new URLSearchParams();
         }
 
-        if (requestParameters['value'] != null) {
-            queryParameters['value'] = requestParameters['value'];
+        if (requestParameters['tx_type'] != null) {
+            formParams.append('tx_type', requestParameters['tx_type'] as any);
         }
 
-        const headerParameters: runtime.HTTPHeaders = {};
+        if (requestParameters['tx_info'] != null) {
+            formParams.append('tx_info', requestParameters['tx_info'] as any);
+        }
 
         const response = await this.request({
-            path: `/api/v1/tx`,
-            method: 'GET',
+            path: `/api/v1/sendTx`,
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: formParams,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => EnrichedTxFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => TxHashFromJSON(jsonValue));
     }
 
     /**
-     * Get transaction by hash or sequence index
-     * GetTx
+     * You need to sign the transaction body before sending it to the server. More details can be found in the Get Started docs: [Get Started For Programmers](https://apidocs.lighter.xyz/docs/get-started-for-programmers)
+     * sendTx
      */
-    async getTx(requestParameters: GetTxRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EnrichedTx> {
-        const response = await this.getTxRaw(requestParameters, initOverrides);
+    async sendTx(requestParameters: SendTxRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TxHash> {
+        const response = await this.sendTxRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Get L1 transaction by L1 transaction hash
-     * getTxFromL1TxHash
+     * You need to sign the transaction body before sending it to the server. More details can be found in the Get Started docs: [Get Started For Programmers](https://apidocs.lighter.xyz/docs/get-started-for-programmers)
+     * sendTxBatch
      */
-    async getTxFromL1TxHashRaw(requestParameters: GetTxFromL1TxHashRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<EnrichedTx>> {
-        if (requestParameters['hash'] == null) {
+    async sendTxBatchRaw(requestParameters: SendTxBatchRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TxHashes>> {
+        if (requestParameters['tx_types'] == null) {
             throw new runtime.RequiredError(
-                'hash',
-                'Required parameter "hash" was null or undefined when calling getTxFromL1TxHash().'
+                'tx_types',
+                'Required parameter "tx_types" was null or undefined when calling sendTxBatch().'
+            );
+        }
+
+        if (requestParameters['tx_infos'] == null) {
+            throw new runtime.RequiredError(
+                'tx_infos',
+                'Required parameter "tx_infos" was null or undefined when calling sendTxBatch().'
             );
         }
 
         const queryParameters: any = {};
 
-        if (requestParameters['hash'] != null) {
-            queryParameters['hash'] = requestParameters['hash'];
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        const consumes: runtime.Consume[] = [
+            { contentType: 'multipart/form-data' },
+        ];
+        // @ts-ignore: canConsumeForm may be unused
+        const canConsumeForm = runtime.canConsumeForm(consumes);
+
+        let formParams: { append(param: string, value: any): any };
+        let useForm = false;
+        if (useForm) {
+            formParams = new FormData();
+        } else {
+            formParams = new URLSearchParams();
         }
 
-        const headerParameters: runtime.HTTPHeaders = {};
+        if (requestParameters['tx_types'] != null) {
+            formParams.append('tx_types', requestParameters['tx_types'] as any);
+        }
+
+        if (requestParameters['tx_infos'] != null) {
+            formParams.append('tx_infos', requestParameters['tx_infos'] as any);
+        }
 
         const response = await this.request({
-            path: `/api/v1/txFromL1TxHash`,
-            method: 'GET',
+            path: `/api/v1/sendTxBatch`,
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: formParams,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => EnrichedTxFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => TxHashesFromJSON(jsonValue));
     }
 
     /**
-     * Get L1 transaction by L1 transaction hash
-     * getTxFromL1TxHash
+     * You need to sign the transaction body before sending it to the server. More details can be found in the Get Started docs: [Get Started For Programmers](https://apidocs.lighter.xyz/docs/get-started-for-programmers)
+     * sendTxBatch
      */
-    async getTxFromL1TxHash(requestParameters: GetTxFromL1TxHashRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EnrichedTx> {
-        const response = await this.getTxFromL1TxHashRaw(requestParameters, initOverrides);
+    async sendTxBatch(requestParameters: SendTxBatchRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TxHashes> {
+        const response = await this.sendTxBatchRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Get transactions which are already packed into blocks
-     * GetTxs
+     * Get transaction by hash or sequence index
+     * tx
      */
-    async getTxsRaw(requestParameters: GetTxsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Txs>> {
-        if (requestParameters['limit'] == null) {
+    async txRaw(requestParameters: TxRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<EnrichedTx>> {
+        if (requestParameters['by'] == null) {
             throw new runtime.RequiredError(
-                'limit',
-                'Required parameter "limit" was null or undefined when calling getTxs().'
+                'by',
+                'Required parameter "by" was null or undefined when calling tx().'
+            );
+        }
+
+        if (requestParameters['value'] == null) {
+            throw new runtime.RequiredError(
+                'value',
+                'Required parameter "value" was null or undefined when calling tx().'
             );
         }
 
         const queryParameters: any = {};
 
-        if (requestParameters['index'] != null) {
-            queryParameters['index'] = requestParameters['index'];
+        if (requestParameters['by'] != null) {
+            queryParameters['by'] = requestParameters['by'];
         }
 
-        if (requestParameters['limit'] != null) {
-            queryParameters['limit'] = requestParameters['limit'];
+        if (requestParameters['value'] != null) {
+            queryParameters['value'] = requestParameters['value'];
         }
 
         const headerParameters: runtime.HTTPHeaders = {};
 
         const response = await this.request({
-            path: `/api/v1/txs`,
+            path: `/api/v1/tx`,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => TxsFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => EnrichedTxFromJSON(jsonValue));
     }
 
     /**
-     * Get transactions which are already packed into blocks
-     * GetTxs
+     * Get transaction by hash or sequence index
+     * tx
      */
-    async getTxs(requestParameters: GetTxsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Txs> {
-        const response = await this.getTxsRaw(requestParameters, initOverrides);
+    async tx(requestParameters: TxRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EnrichedTx> {
+        const response = await this.txRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Send raw transaction
-     * SendTx
+     * Get L1 transaction by L1 transaction hash
+     * txFromL1TxHash
      */
-    async sendTxRaw(requestParameters: SendTxRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TxHash>> {
-        if (requestParameters['tx_type'] == null) {
-            throw new runtime.RequiredError(
-                'tx_type',
-                'Required parameter "tx_type" was null or undefined when calling sendTx().'
-            );
-        }
-
-        if (requestParameters['tx_info'] == null) {
+    async txFromL1TxHashRaw(requestParameters: TxFromL1TxHashRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<EnrichedTx>> {
+        if (requestParameters['hash'] == null) {
             throw new runtime.RequiredError(
-                'tx_info',
-                'Required parameter "tx_info" was null or undefined when calling sendTx().'
+                'hash',
+                'Required parameter "hash" was null or undefined when calling txFromL1TxHash().'
             );
         }
 
         const queryParameters: any = {};
 
-        const headerParameters: runtime.HTTPHeaders = {};
-
-        const consumes: runtime.Consume[] = [
-            { contentType: 'multipart/form-data' },
-        ];
-        // @ts-ignore: canConsumeForm may be unused
-        const canConsumeForm = runtime.canConsumeForm(consumes);
-
-        let formParams: { append(param: string, value: any): any };
-        let useForm = false;
-        if (useForm) {
-            formParams = new FormData();
-        } else {
-            formParams = new URLSearchParams();
-        }
-
-        if (requestParameters['tx_type'] != null) {
-            formParams.append('tx_type', requestParameters['tx_type'] as any);
+        if (requestParameters['hash'] != null) {
+            queryParameters['hash'] = requestParameters['hash'];
         }
 
-        if (requestParameters['tx_info'] != null) {
-            formParams.append('tx_info', requestParameters['tx_info'] as any);
-        }
+        const headerParameters: runtime.HTTPHeaders = {};
 
         const response = await this.request({
-            path: `/api/v1/sendTx`,
-            method: 'POST',
+            path: `/api/v1/txFromL1TxHash`,
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: formParams,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => TxHashFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => EnrichedTxFromJSON(jsonValue));
     }
 
     /**
-     * Send raw transaction
-     * SendTx
+     * Get L1 transaction by L1 transaction hash
+     * txFromL1TxHash
      */
-    async sendTx(requestParameters: SendTxRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TxHash> {
-        const response = await this.sendTxRaw(requestParameters, initOverrides);
+    async txFromL1TxHash(requestParameters: TxFromL1TxHashRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EnrichedTx> {
+        const response = await this.txFromL1TxHashRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Send multiple raw transactions
-     * SendTxBatch
+     * Get transactions which are already packed into blocks
+     * txs
      */
-    async sendTxBatchRaw(requestParameters: SendTxBatchRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TxHashes>> {
-        if (requestParameters['tx_types'] == null) {
-            throw new runtime.RequiredError(
-                'tx_types',
-                'Required parameter "tx_types" was null or undefined when calling sendTxBatch().'
-            );
-        }
-
-        if (requestParameters['tx_infos'] == null) {
+    async txsRaw(requestParameters: TxsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Txs>> {
+        if (requestParameters['limit'] == null) {
             throw new runtime.RequiredError(
-                'tx_infos',
-                'Required parameter "tx_infos" was null or undefined when calling sendTxBatch().'
+                'limit',
+                'Required parameter "limit" was null or undefined when calling txs().'
             );
         }
 
         const queryParameters: any = {};
 
-        const headerParameters: runtime.HTTPHeaders = {};
-
-        const consumes: runtime.Consume[] = [
-            { contentType: 'multipart/form-data' },
-        ];
-        // @ts-ignore: canConsumeForm may be unused
-        const canConsumeForm = runtime.canConsumeForm(consumes);
-
-        let formParams: { append(param: string, value: any): any };
-        let useForm = false;
-        if (useForm) {
-            formParams = new FormData();
-        } else {
-            formParams = new URLSearchParams();
+        if (requestParameters['index'] != null) {
+            queryParameters['index'] = requestParameters['index'];
         }
 
-        if (requestParameters['tx_types'] != null) {
-            formParams.append('tx_types', requestParameters['tx_types'] as any);
+        if (requestParameters['limit'] != null) {
+            queryParameters['limit'] = requestParameters['limit'];
         }
 
-        if (requestParameters['tx_infos'] != null) {
-            formParams.append('tx_infos', requestParameters['tx_infos'] as any);
-        }
+        const headerParameters: runtime.HTTPHeaders = {};
 
         const response = await this.request({
-            path: `/api/v1/sendTxBatch`,
-            method: 'POST',
+            path: `/api/v1/txs`,
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: formParams,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => TxHashesFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => TxsFromJSON(jsonValue));
     }
 
     /**
-     * Send multiple raw transactions
-     * SendTxBatch
+     * Get transactions which are already packed into blocks
+     * txs
      */
-    async sendTxBatch(requestParameters: SendTxBatchRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TxHashes> {
-        const response = await this.sendTxBatchRaw(requestParameters, initOverrides);
+    async txs(requestParameters: TxsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Txs> {
+        const response = await this.txsRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
@@ -701,30 +701,30 @@ export class TransactionApi extends runtime.BaseAPI {
 /**
  * @export
  */
-export const GetAccountPendingTxsByEnum = {
+export const AccountPendingTxsByEnum = {
     AccountIndex: 'account_index'
 } as const;
-export type GetAccountPendingTxsByEnum = typeof GetAccountPendingTxsByEnum[keyof typeof GetAccountPendingTxsByEnum];
+export type AccountPendingTxsByEnum = typeof AccountPendingTxsByEnum[keyof typeof AccountPendingTxsByEnum];
 /**
  * @export
  */
-export const GetAccountTxsByEnum = {
+export const AccountTxsByEnum = {
     AccountIndex: 'account_index'
 } as const;
-export type GetAccountTxsByEnum = typeof GetAccountTxsByEnum[keyof typeof GetAccountTxsByEnum];
+export type AccountTxsByEnum = typeof AccountTxsByEnum[keyof typeof AccountTxsByEnum];
 /**
  * @export
  */
-export const GetBlockTxsByEnum = {
+export const BlockTxsByEnum = {
     Height: 'block_height',
     Commitment: 'block_commitment'
 } as const;
-export type GetBlockTxsByEnum = typeof GetBlockTxsByEnum[keyof typeof GetBlockTxsByEnum];
+export type BlockTxsByEnum = typeof BlockTxsByEnum[keyof typeof BlockTxsByEnum];
 /**
  * @export
  */
-export const GetTxByEnum = {
+export const TxByEnum = {
     Hash: 'hash',
     SequenceIndex: 'sequence_index'
 } as const;
-export type GetTxByEnum = typeof GetTxByEnum[keyof typeof GetTxByEnum];
+export type TxByEnum = typeof TxByEnum[keyof typeof TxByEnum];