@northstake/northstakeapi 1.0.40 → 1.0.41

package/.openapi-generator/FILES

@@ -12,6 +12,7 @@ api/linkedWalletsApi.ts
 api/organizationApi.ts
 api/validatorsApi.ts
 git_push.sh
+model/abandonDashboardRequest.ts
 model/acceptedQuote.ts
 model/accountEntity.ts
 model/addLinkedWalletRequest.ts
@@ -52,9 +53,9 @@ model/getLazyOracleReportCallData200ResponseDestructuredCalldata.ts
 model/getLazyOracleReportData200Response.ts
 model/getLazyOracleReportData200ResponseReportData.ts
 model/getLidoTransactions200Response.ts
+model/getOperatorGroup200Response.ts
 model/getQuarantineInfo200Response.ts
 model/getStETHPerWstETHRate200Response.ts
-model/getWithdrawalsResponse.ts
 model/grantRole.ts
 model/internalTransaction.ts
 model/inviteMemberRequest.ts
@@ -121,7 +122,6 @@ model/validatorRewardsDaily.ts
 model/validatorRewardsDailyResponse.ts
 model/validatorRewardsRaw.ts
 model/validatorType.ts
-model/validatorWithdrawal.ts
 model/vaultCreationStartResponse.ts
 model/wallet.ts
 model/webHookLookupAnswer.ts

package/api/lidoReadApi.ts

@@ -18,6 +18,7 @@ import http from 'http';
 import { ErrorResponse } from '../model/errorResponse';
 import { GetLazyOracleReportData200Response } from '../model/getLazyOracleReportData200Response';
 import { GetLidoTransactions200Response } from '../model/getLidoTransactions200Response';
+import { GetOperatorGroup200Response } from '../model/getOperatorGroup200Response';
 import { GetQuarantineInfo200Response } from '../model/getQuarantineInfo200Response';
 import { GetStETHPerWstETHRate200Response } from '../model/getStETHPerWstETHRate200Response';
 
@@ -385,6 +386,94 @@ export class LidoReadApi {
             });
         });
     } )
+}
+    /**
+     * 
+     * @summary Get operator group info from the operator grid
+     * @param nodeOperator The Ethereum address of the node operator
+     */
+
+   
+
+
+
+   public async getOperatorGroup (nodeOperator: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ body: GetOperatorGroup200Response, status: number }> {
+
+        const localVarPath = this.basePath + '/lidov3/operator-group';
+       
+        let localVarQueryParameters: any = {};
+        let localVarHeaderParams: any = (<any>Object).assign({}, this._defaultHeaders);
+        const produces = ['application/json'];
+        if (produces.indexOf('application/json') >= 0) {
+            localVarHeaderParams.Accept = 'application/json';
+        } else {
+            localVarHeaderParams.Accept = produces.join(',');
+        }
+        let localVarFormParams: any = {};
+
+
+        // Verify required parameter 'nodeOperator' is not null or undefined
+        if (nodeOperator === null || nodeOperator === undefined) {
+            throw new Error('Required parameter "nodeOperator" was null or undefined when calling getOperatorGroup.');
+        }
+
+
+
+    if (nodeOperator !== undefined) {
+        localVarQueryParameters['nodeOperator'] = ObjectSerializer.serialize(nodeOperator, "string");
+    }
+
+
+
+
+        (<any>Object).assign(localVarHeaderParams, options.headers);
+
+        let localVarUseFormData = false;
+
+
+
+        let localVarRequestOptions: localVarRequest.Options = {
+            method: 'GET',
+            qs: localVarQueryParameters,
+            headers: localVarHeaderParams,
+            uri: localVarPath,
+            useQuerystring: this._useQuerystring,
+            json: true,
+        };
+
+        let authenticationPromise = Promise.resolve();
+        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
+
+        let interceptorPromise = authenticationPromise;
+        for (const interceptor of this.interceptors) {
+            interceptorPromise = interceptorPromise.then(() => interceptor(localVarRequestOptions));
+        }
+
+        return interceptorPromise.then(() => {
+            if (Object.keys(localVarFormParams).length) {
+                if (localVarUseFormData) {
+                    (<any>localVarRequestOptions).formData = localVarFormParams;
+                } else {
+                    localVarRequestOptions.form = localVarFormParams;
+                }
+            }
+                 return new Promise<{ body: GetOperatorGroup200Response, status: number }>((resolve, reject) => {
+            localVarRequest(localVarRequestOptions, (error, response, body) => {
+                if (error) {
+                    console.error('API call error:', error);
+                    reject(error);
+                } else {
+                    if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
+                        body = ObjectSerializer.deserialize(body, "GetOperatorGroup200Response");
+                        resolve({ body: body, status: response.statusCode });
+                    } else {
+                        console.error('API response error:', response.statusCode);
+                        resolve({ body: body, status: response.statusCode });
+                    }
+                }
+            });
+        });
+    } )
 }
     /**
      * 

package/api/lidoWriteApi.ts

@@ -15,6 +15,7 @@ import localVarRequest from 'request';
 import http from 'http';
 
 /* tslint:disable:no-unused-locals */
+import { AbandonDashboardRequest } from '../model/abandonDashboardRequest';
 import { ApproveStETH } from '../model/approveStETH';
 import { ApproveWstETH } from '../model/approveWstETH';
 import { BurnShares } from '../model/burnShares';
@@ -126,6 +127,192 @@ export class LidoWriteApi {
         this.interceptors.push(interceptor);
     }
 
+    /**
+     * Returns a partial transaction to call Dashboard.abandonDashboard(newOwner). Only allowed when the vault is fully disconnected from the vault hub (after disconnect has completed). Step 3 of the stVault disconnect guide (with Dashboard). 
+     * @summary Abandon dashboard and transfer vault ownership (disconnect Step 3)
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param abandonDashboardRequest 
+     * @param simulateAddress Optional Ethereum address to simulate the transaction from.
+     */
+
+   
+
+
+
+   public async abandonDashboard (contractsId: string, abandonDashboardRequest: AbandonDashboardRequest, simulateAddress?: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ body: PartialTransaction, status: number }> {
+
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/abandon-dashboard'
+            .replace('{' + 'contractsId' + '}', encodeURIComponent(String(contractsId)));
+       
+        let localVarQueryParameters: any = {};
+        let localVarHeaderParams: any = (<any>Object).assign({}, this._defaultHeaders);
+        const produces = ['application/json'];
+        if (produces.indexOf('application/json') >= 0) {
+            localVarHeaderParams.Accept = 'application/json';
+        } else {
+            localVarHeaderParams.Accept = produces.join(',');
+        }
+        let localVarFormParams: any = {};
+
+
+        // Verify required parameter 'contractsId' is not null or undefined
+        if (contractsId === null || contractsId === undefined) {
+            throw new Error('Required parameter "contractsId" was null or undefined when calling abandonDashboard.');
+        }
+        // Verify required parameter 'abandonDashboardRequest' is not null or undefined
+        if (abandonDashboardRequest === null || abandonDashboardRequest === undefined) {
+            throw new Error('Required parameter "abandonDashboardRequest" was null or undefined when calling abandonDashboard.');
+        }
+
+
+
+    if (simulateAddress !== undefined) {
+        localVarQueryParameters['simulateAddress'] = ObjectSerializer.serialize(simulateAddress, "string");
+    }
+
+
+
+
+        (<any>Object).assign(localVarHeaderParams, options.headers);
+
+        let localVarUseFormData = false;
+
+
+
+        let localVarRequestOptions: localVarRequest.Options = {
+            method: 'POST',
+            qs: localVarQueryParameters,
+            headers: localVarHeaderParams,
+            uri: localVarPath,
+            useQuerystring: this._useQuerystring,
+            json: true,
+            body: ObjectSerializer.serialize(abandonDashboardRequest, "AbandonDashboardRequest")
+        };
+
+        let authenticationPromise = Promise.resolve();
+        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
+
+        let interceptorPromise = authenticationPromise;
+        for (const interceptor of this.interceptors) {
+            interceptorPromise = interceptorPromise.then(() => interceptor(localVarRequestOptions));
+        }
+
+        return interceptorPromise.then(() => {
+            if (Object.keys(localVarFormParams).length) {
+                if (localVarUseFormData) {
+                    (<any>localVarRequestOptions).formData = localVarFormParams;
+                } else {
+                    localVarRequestOptions.form = localVarFormParams;
+                }
+            }
+                 return new Promise<{ body: PartialTransaction, status: number }>((resolve, reject) => {
+            localVarRequest(localVarRequestOptions, (error, response, body) => {
+                if (error) {
+                    console.error('API call error:', error);
+                    reject(error);
+                } else {
+                    if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
+                        body = ObjectSerializer.deserialize(body, "PartialTransaction");
+                        resolve({ body: body, status: response.statusCode });
+                    } else {
+                        console.error('API response error:', response.statusCode);
+                        resolve({ body: body, status: response.statusCode });
+                    }
+                }
+            });
+        });
+    } )
+}
+    /**
+     * Returns a partial transaction to call StakingVault.acceptOwnership(). Only allowed when the vault is fully disconnected from the vault hub. Step 4 of the stVault disconnect guide (with Dashboard), or Step 3 without Dashboard. 
+     * @summary Accept staking vault ownership (disconnect Step 4)
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param simulateAddress Optional Ethereum address to simulate the transaction from.
+     */
+
+   
+
+
+
+   public async acceptStakingVaultOwnership (contractsId: string, simulateAddress?: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ body: PartialTransaction, status: number }> {
+
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/accept-staking-vault-ownership'
+            .replace('{' + 'contractsId' + '}', encodeURIComponent(String(contractsId)));
+       
+        let localVarQueryParameters: any = {};
+        let localVarHeaderParams: any = (<any>Object).assign({}, this._defaultHeaders);
+        const produces = ['application/json'];
+        if (produces.indexOf('application/json') >= 0) {
+            localVarHeaderParams.Accept = 'application/json';
+        } else {
+            localVarHeaderParams.Accept = produces.join(',');
+        }
+        let localVarFormParams: any = {};
+
+
+        // Verify required parameter 'contractsId' is not null or undefined
+        if (contractsId === null || contractsId === undefined) {
+            throw new Error('Required parameter "contractsId" was null or undefined when calling acceptStakingVaultOwnership.');
+        }
+
+
+
+    if (simulateAddress !== undefined) {
+        localVarQueryParameters['simulateAddress'] = ObjectSerializer.serialize(simulateAddress, "string");
+    }
+
+
+
+
+        (<any>Object).assign(localVarHeaderParams, options.headers);
+
+        let localVarUseFormData = false;
+
+
+
+        let localVarRequestOptions: localVarRequest.Options = {
+            method: 'POST',
+            qs: localVarQueryParameters,
+            headers: localVarHeaderParams,
+            uri: localVarPath,
+            useQuerystring: this._useQuerystring,
+            json: true,
+        };
+
+        let authenticationPromise = Promise.resolve();
+        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
+
+        let interceptorPromise = authenticationPromise;
+        for (const interceptor of this.interceptors) {
+            interceptorPromise = interceptorPromise.then(() => interceptor(localVarRequestOptions));
+        }
+
+        return interceptorPromise.then(() => {
+            if (Object.keys(localVarFormParams).length) {
+                if (localVarUseFormData) {
+                    (<any>localVarRequestOptions).formData = localVarFormParams;
+                } else {
+                    localVarRequestOptions.form = localVarFormParams;
+                }
+            }
+                 return new Promise<{ body: PartialTransaction, status: number }>((resolve, reject) => {
+            localVarRequest(localVarRequestOptions, (error, response, body) => {
+                if (error) {
+                    console.error('API call error:', error);
+                    reject(error);
+                } else {
+                    if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
+                        body = ObjectSerializer.deserialize(body, "PartialTransaction");
+                        resolve({ body: body, status: response.statusCode });
+                    } else {
+                        console.error('API response error:', response.statusCode);
+                        resolve({ body: body, status: response.statusCode });
+                    }
+                }
+            });
+        });
+    } )
+}
     /**
      * 
      * @summary Encode approval to burn stETH
@@ -856,6 +1043,96 @@ export class LidoWriteApi {
         });
     } )
 }
+    /**
+     * Returns a partial transaction to connect the vault to the vault hub (payable with 1 ETH). Only allowed when the vault is not already connected; returns 400 if already connected. 
+     * @summary Connect to vault hub
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param simulateAddress Optional Ethereum address to simulate the transaction from.
+     */
+
+   
+
+
+
+   public async connectToVaultHub (contractsId: string, simulateAddress?: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ body: PartialTransaction, status: number }> {
+
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/connect-to-vault-hub'
+            .replace('{' + 'contractsId' + '}', encodeURIComponent(String(contractsId)));
+       
+        let localVarQueryParameters: any = {};
+        let localVarHeaderParams: any = (<any>Object).assign({}, this._defaultHeaders);
+        const produces = ['application/json'];
+        if (produces.indexOf('application/json') >= 0) {
+            localVarHeaderParams.Accept = 'application/json';
+        } else {
+            localVarHeaderParams.Accept = produces.join(',');
+        }
+        let localVarFormParams: any = {};
+
+
+        // Verify required parameter 'contractsId' is not null or undefined
+        if (contractsId === null || contractsId === undefined) {
+            throw new Error('Required parameter "contractsId" was null or undefined when calling connectToVaultHub.');
+        }
+
+
+
+    if (simulateAddress !== undefined) {
+        localVarQueryParameters['simulateAddress'] = ObjectSerializer.serialize(simulateAddress, "string");
+    }
+
+
+
+
+        (<any>Object).assign(localVarHeaderParams, options.headers);
+
+        let localVarUseFormData = false;
+
+
+
+        let localVarRequestOptions: localVarRequest.Options = {
+            method: 'POST',
+            qs: localVarQueryParameters,
+            headers: localVarHeaderParams,
+            uri: localVarPath,
+            useQuerystring: this._useQuerystring,
+            json: true,
+        };
+
+        let authenticationPromise = Promise.resolve();
+        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
+
+        let interceptorPromise = authenticationPromise;
+        for (const interceptor of this.interceptors) {
+            interceptorPromise = interceptorPromise.then(() => interceptor(localVarRequestOptions));
+        }
+
+        return interceptorPromise.then(() => {
+            if (Object.keys(localVarFormParams).length) {
+                if (localVarUseFormData) {
+                    (<any>localVarRequestOptions).formData = localVarFormParams;
+                } else {
+                    localVarRequestOptions.form = localVarFormParams;
+                }
+            }
+                 return new Promise<{ body: PartialTransaction, status: number }>((resolve, reject) => {
+            localVarRequest(localVarRequestOptions, (error, response, body) => {
+                if (error) {
+                    console.error('API call error:', error);
+                    reject(error);
+                } else {
+                    if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
+                        body = ObjectSerializer.deserialize(body, "PartialTransaction");
+                        resolve({ body: body, status: response.statusCode });
+                    } else {
+                        console.error('API response error:', response.statusCode);
+                        resolve({ body: body, status: response.statusCode });
+                    }
+                }
+            });
+        });
+    } )
+}
     /**
      * 
      * @summary Create EIP-7251 consolidation requests for validators
@@ -2231,7 +2508,7 @@ export class LidoWriteApi {
     } )
 }
     /**
-     * 
+     * Returns a partial transaction to trigger EIP-7002 validator withdrawals. When the vault is connected, uses Dashboard. When the vault is disconnected (e.g. after the disconnect wizard), uses StakingVault.triggerValidatorWithdrawals. 
      * @summary Trigger validator withdrawals
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param triggerValidatorWithdrawals 
@@ -2593,7 +2870,97 @@ export class LidoWriteApi {
     } )
 }
     /**
-     * 
+     * Returns a partial transaction to voluntarily disconnect the vault from the vault hub. This is the only write operation allowed when the vault is already disconnected. 
+     * @summary Voluntary disconnect from vault hub
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param simulateAddress Optional Ethereum address to simulate the transaction from.
+     */
+
+   
+
+
+
+   public async voluntaryDisconnectFromVaultHub (contractsId: string, simulateAddress?: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ body: PartialTransaction, status: number }> {
+
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/voluntary-disconnect'
+            .replace('{' + 'contractsId' + '}', encodeURIComponent(String(contractsId)));
+       
+        let localVarQueryParameters: any = {};
+        let localVarHeaderParams: any = (<any>Object).assign({}, this._defaultHeaders);
+        const produces = ['application/json'];
+        if (produces.indexOf('application/json') >= 0) {
+            localVarHeaderParams.Accept = 'application/json';
+        } else {
+            localVarHeaderParams.Accept = produces.join(',');
+        }
+        let localVarFormParams: any = {};
+
+
+        // Verify required parameter 'contractsId' is not null or undefined
+        if (contractsId === null || contractsId === undefined) {
+            throw new Error('Required parameter "contractsId" was null or undefined when calling voluntaryDisconnectFromVaultHub.');
+        }
+
+
+
+    if (simulateAddress !== undefined) {
+        localVarQueryParameters['simulateAddress'] = ObjectSerializer.serialize(simulateAddress, "string");
+    }
+
+
+
+
+        (<any>Object).assign(localVarHeaderParams, options.headers);
+
+        let localVarUseFormData = false;
+
+
+
+        let localVarRequestOptions: localVarRequest.Options = {
+            method: 'POST',
+            qs: localVarQueryParameters,
+            headers: localVarHeaderParams,
+            uri: localVarPath,
+            useQuerystring: this._useQuerystring,
+            json: true,
+        };
+
+        let authenticationPromise = Promise.resolve();
+        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
+
+        let interceptorPromise = authenticationPromise;
+        for (const interceptor of this.interceptors) {
+            interceptorPromise = interceptorPromise.then(() => interceptor(localVarRequestOptions));
+        }
+
+        return interceptorPromise.then(() => {
+            if (Object.keys(localVarFormParams).length) {
+                if (localVarUseFormData) {
+                    (<any>localVarRequestOptions).formData = localVarFormParams;
+                } else {
+                    localVarRequestOptions.form = localVarFormParams;
+                }
+            }
+                 return new Promise<{ body: PartialTransaction, status: number }>((resolve, reject) => {
+            localVarRequest(localVarRequestOptions, (error, response, body) => {
+                if (error) {
+                    console.error('API call error:', error);
+                    reject(error);
+                } else {
+                    if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
+                        body = ObjectSerializer.deserialize(body, "PartialTransaction");
+                        resolve({ body: body, status: response.statusCode });
+                    } else {
+                        console.error('API response error:', response.statusCode);
+                        resolve({ body: body, status: response.statusCode });
+                    }
+                }
+            });
+        });
+    } )
+}
+    /**
+     * Returns a partial transaction to withdraw ETH. When the vault is connected, uses Dashboard.withdraw. When the vault is disconnected (e.g. after the disconnect wizard), uses StakingVault.withdraw(recipient, amount). 
      * @summary Withdraw from vault
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param withdrawFromVault 

package/api/validatorsApi.ts

@@ -16,7 +16,6 @@ import http from 'http';
 
 /* tslint:disable:no-unused-locals */
 import { ErrorResponse } from '../model/errorResponse';
-import { GetWithdrawalsResponse } from '../model/getWithdrawalsResponse';
 import { PartialTransaction } from '../model/partialTransaction';
 import { ValidatorInfo } from '../model/validatorInfo';
 
@@ -36,15 +35,6 @@ export enum ValidatorsApiApiKeys {
 }
 
 
-// If vendorExtensions.x-packageParams is true, use a single object to pass parameters
-export interface ValidatorsApiParams {
-    startDate?: Date;
-    endDate?: Date;
-    page?: number;
-    limit?: number;
-    validatorIndices?: string;
-    withdrawalType?: 'full' | 'partial';
-}
 
 export class ValidatorsApi {
     protected _basePath = defaultBasePath;
@@ -108,110 +98,6 @@ export class ValidatorsApi {
         this.interceptors.push(interceptor);
     }
 
-    /**
-     * Retrieves a paginated list of validator withdrawals. The endpoint supports filtering by start and end date, page number, and limit. Additionally, it allows filtering by validator indices. 
-     * @summary Get a list of validator withdrawals
-     * @param startDate Start date for filtering withdrawal statistics
-     * @param endDate End date for filtering withdrawal statistics
-     * @param page Withdrawal list page number
-     * @param limit Number of withdrawals to return per page
-     * @param validatorIndices Comma-separated list of validator indices to filter withdrawals (e.g., \"123,456,789\")
-     * @param withdrawalType 
-     */
-
-   
-
-
-
-    public async getValidatorWithdrawals(params?: ValidatorsApiParams, options: { headers: { [name: string]: string } } = { headers: {} }): Promise<{ body: GetWithdrawalsResponse, status: number }> {
-
-        const localVarPath = this.basePath + '/validators/withdrawals';
-       
-        let localVarQueryParameters: any = {};
-        let localVarHeaderParams: any = (<any>Object).assign({}, this._defaultHeaders);
-        const produces = ['application/json'];
-        if (produces.indexOf('application/json') >= 0) {
-            localVarHeaderParams.Accept = 'application/json';
-        } else {
-            localVarHeaderParams.Accept = produces.join(',');
-        }
-        let localVarFormParams: any = {};
-
-
-
-
-
-    if (params?.startDate !== undefined) {
-        localVarQueryParameters['start_date'] = ObjectSerializer.serialize(params?.startDate, "Date");
-    }
-    if (params?.endDate !== undefined) {
-        localVarQueryParameters['end_date'] = ObjectSerializer.serialize(params?.endDate, "Date");
-    }
-    if (params?.page !== undefined) {
-        localVarQueryParameters['page'] = ObjectSerializer.serialize(params?.page, "number");
-    }
-    if (params?.limit !== undefined) {
-        localVarQueryParameters['limit'] = ObjectSerializer.serialize(params?.limit, "number");
-    }
-    if (params?.validatorIndices !== undefined) {
-        localVarQueryParameters['validator_indices'] = ObjectSerializer.serialize(params?.validatorIndices, "string");
-    }
-    if (params?.withdrawalType !== undefined) {
-        localVarQueryParameters['withdrawal_type'] = ObjectSerializer.serialize(params?.withdrawalType, "'full' | 'partial'");
-    }
-
-
-
-
-        (<any>Object).assign(localVarHeaderParams, options.headers);
-
-        let localVarUseFormData = false;
-
-
-
-        let localVarRequestOptions: localVarRequest.Options = {
-            method: 'GET',
-            qs: localVarQueryParameters,
-            headers: localVarHeaderParams,
-            uri: localVarPath,
-            useQuerystring: this._useQuerystring,
-            json: true,
-        };
-
-        let authenticationPromise = Promise.resolve();
-        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
-
-        let interceptorPromise = authenticationPromise;
-        for (const interceptor of this.interceptors) {
-            interceptorPromise = interceptorPromise.then(() => interceptor(localVarRequestOptions));
-        }
-
-        return interceptorPromise.then(() => {
-            if (Object.keys(localVarFormParams).length) {
-                if (localVarUseFormData) {
-                    (<any>localVarRequestOptions).formData = localVarFormParams;
-                } else {
-                    localVarRequestOptions.form = localVarFormParams;
-                }
-            }
-                 return new Promise<{ body: GetWithdrawalsResponse, status: number }>((resolve, reject) => {
-            localVarRequest(localVarRequestOptions, (error, response, body) => {
-                if (error) {
-                    console.error('API call error:', error);
-                    reject(error);
-                } else {
-                    if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
-                        body = ObjectSerializer.deserialize(body, "GetWithdrawalsResponse");
-                        resolve({ body: body, status: response.statusCode });
-                    } else {
-                        console.error('API response error:', response.statusCode);
-                        resolve({ body: body, status: response.statusCode });
-                    }
-                }
-            });
-        });
-    } )
-}
     /**
      * 
      * @summary Get a list of validators