@northstake/northstakeapi 1.0.38 → 1.0.40

package/api/lidoWriteApi.ts

@@ -0,0 +1,2773 @@
+/**
+ * Northstake
+ * Northstake api  Operation-level extensions used by the API: - x-roleRequired (array of strings): roles required to call the operation. - x-mfaApiScope (array of strings): MFA API scopes required when the user has MFA enrolled. - x-isProSvmFeature (boolean): when true, the operation is restricted to users whose Cosmos user document has is_pro_svm_user set to true. 
+ *
+ * The version of the OpenAPI document: 1.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+
+import localVarRequest from 'request';
+import http from 'http';
+
+/* tslint:disable:no-unused-locals */
+import { ApproveStETH } from '../model/approveStETH';
+import { ApproveWstETH } from '../model/approveWstETH';
+import { BurnShares } from '../model/burnShares';
+import { BurnStETH } from '../model/burnStETH';
+import { BurnWstETH } from '../model/burnWstETH';
+import { ChangeTier } from '../model/changeTier';
+import { CollectERC20FromVault } from '../model/collectERC20FromVault';
+import { ConsolidateValidators } from '../model/consolidateValidators';
+import { ConsolidateValidatorsErrorResponse } from '../model/consolidateValidatorsErrorResponse';
+import { ConsolidateValidatorsResponse } from '../model/consolidateValidatorsResponse';
+import { ErrorResponse } from '../model/errorResponse';
+import { FundVault } from '../model/fundVault';
+import { GetLazyOracleReportCallData200Response } from '../model/getLazyOracleReportCallData200Response';
+import { GrantRole } from '../model/grantRole';
+import { MintShares } from '../model/mintShares';
+import { MintStETH } from '../model/mintStETH';
+import { MintWstETH } from '../model/mintWstETH';
+import { PartialTransaction } from '../model/partialTransaction';
+import { RebalanceVaultWithEther } from '../model/rebalanceVaultWithEther';
+import { RebalanceVaultWithShares } from '../model/rebalanceVaultWithShares';
+import { RecoverERC20 } from '../model/recoverERC20';
+import { RevokeRole } from '../model/revokeRole';
+import { StakeEthRequest } from '../model/stakeEthRequest';
+import { StakeEthResponse } from '../model/stakeEthResponse';
+import { StakingRequest } from '../model/stakingRequest';
+import { TriggerValidatorWithdrawals } from '../model/triggerValidatorWithdrawals';
+import { UnwrapWstETH } from '../model/unwrapWstETH';
+import { UpdateShareLimit } from '../model/updateShareLimit';
+import { ValidateConsolidationRequestsResponse } from '../model/validateConsolidationRequestsResponse';
+import { WithdrawFromVault } from '../model/withdrawFromVault';
+import { WrapStETH } from '../model/wrapStETH';
+
+import { ObjectSerializer, Authentication, VoidAuth, Interceptor } from '../model/models';
+import { HttpBasicAuth, HttpBearerAuth, ApiKeyAuth, OAuth, JWTAuth } from '../model/models';
+
+import { HttpError, RequestFile } from './apis';
+
+let defaultBasePath = 'https://api.northstake.dk/v1';
+
+// ===============================================
+// This file is autogenerated - Please do not edit
+// ===============================================
+
+export enum LidoWriteApiApiKeys {
+    ApiKeyAuth,
+}
+
+
+
+export class LidoWriteApi {
+    protected _basePath = defaultBasePath;
+    protected _defaultHeaders : any = {};
+    protected _useQuerystring : boolean = false;
+
+    protected authentications = {
+        'default': <Authentication>new JWTAuth('your_api_key', 'your_private_key'),
+        'bearerTokenAuth': new HttpBearerAuth(),
+        'ApiKeyAuth': new ApiKeyAuth('header', 'x-api-key'),
+    }
+
+    protected interceptors: Interceptor[] = [];
+
+    constructor(basePath?: string);
+    constructor(basePathOrUsername: string, password?: string, basePath?: string) {
+        if (password) {
+            if (basePath) {
+                this.basePath = basePath;
+            }
+        } else {
+            if (basePathOrUsername) {
+                this.basePath = basePathOrUsername
+            }
+        }
+    }
+
+    set useQuerystring(value: boolean) {
+        this._useQuerystring = value;
+    }
+
+    set basePath(basePath: string) {
+        this._basePath = basePath;
+    }
+
+    set defaultHeaders(defaultHeaders: any) {
+        this._defaultHeaders = defaultHeaders;
+    }
+
+    get defaultHeaders() {
+        return this._defaultHeaders;
+    }
+
+    get basePath() {
+        return this._basePath;
+    }
+
+    public setDefaultAuthentication(auth: Authentication) {
+        this.authentications.default = auth;
+    }
+
+    public setApiKey(key: LidoWriteApiApiKeys, value: string) {
+        (this.authentications as any)[LidoWriteApiApiKeys[key]].apiKey = value;
+    }
+
+    set accessToken(accessToken: string | (() => string)) {
+        this.authentications.bearerTokenAuth.accessToken = accessToken;
+    }
+
+    public addInterceptor(interceptor: Interceptor) {
+        this.interceptors.push(interceptor);
+    }
+
+    /**
+     * 
+     * @summary Encode approval to burn stETH
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param approveStETH 
+     */
+
+   
+
+
+
+   public async approveBurnStETH (contractsId: string, approveStETH: ApproveStETH, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ body: PartialTransaction, status: number }> {
+
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/approve/burn/steth'
+            .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 approveBurnStETH.');
+        }
+        // Verify required parameter 'approveStETH' is not null or undefined
+        if (approveStETH === null || approveStETH === undefined) {
+            throw new Error('Required parameter "approveStETH" was null or undefined when calling approveBurnStETH.');
+        }
+
+
+
+
+
+
+
+        (<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(approveStETH, "ApproveStETH")
+        };
+
+        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 wstETH
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param approveWstETH 
+     */
+
+   
+
+
+
+   public async approveBurnWstETH (contractsId: string, approveWstETH: ApproveWstETH, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ body: PartialTransaction, status: number }> {
+
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/approve/burn/wsteth'
+            .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 approveBurnWstETH.');
+        }
+        // Verify required parameter 'approveWstETH' is not null or undefined
+        if (approveWstETH === null || approveWstETH === undefined) {
+            throw new Error('Required parameter "approveWstETH" was null or undefined when calling approveBurnWstETH.');
+        }
+
+
+
+
+
+
+
+        (<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(approveWstETH, "ApproveWstETH")
+        };
+
+        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 Approve wrapping stETH to wstETH
+     * @param approveStETH 
+     */
+
+   
+
+
+
+   public async approveWrapStETH (approveStETH: ApproveStETH, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ body: PartialTransaction, status: number }> {
+
+        const localVarPath = this.basePath + '/lidov3/approve/wrap/steth';
+       
+        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 'approveStETH' is not null or undefined
+        if (approveStETH === null || approveStETH === undefined) {
+            throw new Error('Required parameter "approveStETH" was null or undefined when calling approveWrapStETH.');
+        }
+
+
+
+
+
+
+
+        (<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(approveStETH, "ApproveStETH")
+        };
+
+        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 burn shares transaction
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param burnShares 
+     */
+
+   
+
+
+
+   public async burnShares (contractsId: string, burnShares: BurnShares, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ body: PartialTransaction, status: number }> {
+
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/burn/shares'
+            .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 burnShares.');
+        }
+        // Verify required parameter 'burnShares' is not null or undefined
+        if (burnShares === null || burnShares === undefined) {
+            throw new Error('Required parameter "burnShares" was null or undefined when calling burnShares.');
+        }
+
+
+
+
+
+
+
+        (<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(burnShares, "BurnShares")
+        };
+
+        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 burn stETH transaction
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param burnStETH 
+     */
+
+   
+
+
+
+   public async burnStETH (contractsId: string, burnStETH: BurnStETH, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ body: PartialTransaction, status: number }> {
+
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/burn/steth'
+            .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 burnStETH.');
+        }
+        // Verify required parameter 'burnStETH' is not null or undefined
+        if (burnStETH === null || burnStETH === undefined) {
+            throw new Error('Required parameter "burnStETH" was null or undefined when calling burnStETH.');
+        }
+
+
+
+
+
+
+
+        (<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(burnStETH, "BurnStETH")
+        };
+
+        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 burn wstETH transaction
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param burnWstETH 
+     */
+
+   
+
+
+
+   public async burnWstETH (contractsId: string, burnWstETH: BurnWstETH, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ body: PartialTransaction, status: number }> {
+
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/burn/wsteth'
+            .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 burnWstETH.');
+        }
+        // Verify required parameter 'burnWstETH' is not null or undefined
+        if (burnWstETH === null || burnWstETH === undefined) {
+            throw new Error('Required parameter "burnWstETH" was null or undefined when calling burnWstETH.');
+        }
+
+
+
+
+
+
+
+        (<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(burnWstETH, "BurnWstETH")
+        };
+
+        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 change tier transaction
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param changeTier 
+     */
+
+   
+
+
+
+   public async changeTier (contractsId: string, changeTier: ChangeTier, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ body: PartialTransaction, status: number }> {
+
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/vault/change-tier'
+            .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 changeTier.');
+        }
+        // Verify required parameter 'changeTier' is not null or undefined
+        if (changeTier === null || changeTier === undefined) {
+            throw new Error('Required parameter "changeTier" was null or undefined when calling changeTier.');
+        }
+
+
+
+
+
+
+
+        (<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(changeTier, "ChangeTier")
+        };
+
+        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 Collect ERC20 from vault
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param collectERC20FromVault 
+     */
+
+   
+
+
+
+   public async collectERC20FromVault (contractsId: string, collectERC20FromVault: CollectERC20FromVault, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ body: PartialTransaction, status: number }> {
+
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/collect-erc20'
+            .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 collectERC20FromVault.');
+        }
+        // Verify required parameter 'collectERC20FromVault' is not null or undefined
+        if (collectERC20FromVault === null || collectERC20FromVault === undefined) {
+            throw new Error('Required parameter "collectERC20FromVault" was null or undefined when calling collectERC20FromVault.');
+        }
+
+
+
+
+
+
+
+        (<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(collectERC20FromVault, "CollectERC20FromVault")
+        };
+
+        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
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param consolidateValidators 
+     */
+
+   
+
+
+
+   public async consolidateValidators (contractsId: string, consolidateValidators: ConsolidateValidators, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ body: ConsolidateValidatorsResponse, status: number }> {
+
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/consolidate-validators'
+            .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 consolidateValidators.');
+        }
+        // Verify required parameter 'consolidateValidators' is not null or undefined
+        if (consolidateValidators === null || consolidateValidators === undefined) {
+            throw new Error('Required parameter "consolidateValidators" was null or undefined when calling consolidateValidators.');
+        }
+
+
+
+
+
+
+
+        (<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(consolidateValidators, "ConsolidateValidators")
+        };
+
+        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: ConsolidateValidatorsResponse, 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, "ConsolidateValidatorsResponse");
+                        resolve({ body: body, status: response.statusCode });
+                    } else {
+                        console.error('API response error:', response.statusCode);
+                        resolve({ body: body, status: response.statusCode });
+                    }
+                }
+            });
+        });
+    } )
+}
+    /**
+     * 
+     * @summary Fund vault with ETH
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param fundVault 
+     */
+
+   
+
+
+
+   public async fundVault (contractsId: string, fundVault: FundVault, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ body: PartialTransaction, status: number }> {
+
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/fund'
+            .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 fundVault.');
+        }
+        // Verify required parameter 'fundVault' is not null or undefined
+        if (fundVault === null || fundVault === undefined) {
+            throw new Error('Required parameter "fundVault" was null or undefined when calling fundVault.');
+        }
+
+
+
+
+
+
+
+        (<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(fundVault, "FundVault")
+        };
+
+        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 the calldata needed to submit the updateVaultData transaction to the lazy oracle contract for a specific Lido staking contract set.
+     * @summary Update lazy oracle report
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param simulateAddress Optional Ethereum address to simulate the transaction from. If provided, the transaction will be simulated and any revert errors will be returned.
+     */
+
+   
+
+
+
+   public async getLazyOracleReportCallData (contractsId: string, simulateAddress?: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ body: GetLazyOracleReportCallData200Response, status: number }> {
+
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/update-vault-report'
+            .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 getLazyOracleReportCallData.');
+        }
+
+
+
+    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: GetLazyOracleReportCallData200Response, 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, "GetLazyOracleReportCallData200Response");
+                        resolve({ body: body, status: response.statusCode });
+                    } else {
+                        console.error('API response error:', response.statusCode);
+                        resolve({ body: body, status: response.statusCode });
+                    }
+                }
+            });
+        });
+    } )
+}
+    /**
+     * 
+     * @summary Get details for a specific staking request
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param stakingRequestId The staking request ID
+     */
+
+   
+
+
+
+   public async getStakingRequest (contractsId: string, stakingRequestId: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ body: StakingRequest, status: number }> {
+
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/staking-requests/{stakingRequestId}'
+            .replace('{' + 'contractsId' + '}', encodeURIComponent(String(contractsId)))
+            .replace('{' + 'stakingRequestId' + '}', encodeURIComponent(String(stakingRequestId)));
+       
+        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 getStakingRequest.');
+        }
+        // Verify required parameter 'stakingRequestId' is not null or undefined
+        if (stakingRequestId === null || stakingRequestId === undefined) {
+            throw new Error('Required parameter "stakingRequestId" was null or undefined when calling getStakingRequest.');
+        }
+
+
+
+
+
+
+
+        (<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: StakingRequest, 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, "StakingRequest");
+                        resolve({ body: body, status: response.statusCode });
+                    } else {
+                        console.error('API response error:', response.statusCode);
+                        resolve({ body: body, status: response.statusCode });
+                    }
+                }
+            });
+        });
+    } )
+}
+    /**
+     * 
+     * @summary Grant vault role
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param grantRole 
+     */
+
+   
+
+
+
+   public async grantRole (contractsId: string, grantRole: GrantRole, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ body: PartialTransaction, status: number }> {
+
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/vault/grant-role'
+            .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 grantRole.');
+        }
+        // Verify required parameter 'grantRole' is not null or undefined
+        if (grantRole === null || grantRole === undefined) {
+            throw new Error('Required parameter "grantRole" was null or undefined when calling grantRole.');
+        }
+
+
+
+
+
+
+
+        (<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(grantRole, "GrantRole")
+        };
+
+        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 List staking request IDs for a vault
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param status 
+     */
+
+   
+
+
+
+   public async listStakingRequests (contractsId: string, status?: 'pending' | 'completed' | 'failed', options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ body: Array<string>, status: number }> {
+
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/staking-requests'
+            .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 listStakingRequests.');
+        }
+
+
+
+    if (status !== undefined) {
+        localVarQueryParameters['status'] = ObjectSerializer.serialize(status, "'pending' | 'completed' | 'failed'");
+    }
+
+
+
+
+        (<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: Array<string>, 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, "Array<string>");
+                        resolve({ body: body, status: response.statusCode });
+                    } else {
+                        console.error('API response error:', response.statusCode);
+                        resolve({ body: body, status: response.statusCode });
+                    }
+                }
+            });
+        });
+    } )
+}
+    /**
+     * 
+     * @summary Encode mint shares transaction
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param mintShares 
+     */
+
+   
+
+
+
+   public async mintShares (contractsId: string, mintShares: MintShares, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ body: PartialTransaction, status: number }> {
+
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/vault/mint/shares'
+            .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 mintShares.');
+        }
+        // Verify required parameter 'mintShares' is not null or undefined
+        if (mintShares === null || mintShares === undefined) {
+            throw new Error('Required parameter "mintShares" was null or undefined when calling mintShares.');
+        }
+
+
+
+
+
+
+
+        (<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(mintShares, "MintShares")
+        };
+
+        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 mint stETH transaction
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param mintStETH 
+     */
+
+   
+
+
+
+   public async mintStETH (contractsId: string, mintStETH: MintStETH, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ body: PartialTransaction, status: number }> {
+
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/vault/mint/steth'
+            .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 mintStETH.');
+        }
+        // Verify required parameter 'mintStETH' is not null or undefined
+        if (mintStETH === null || mintStETH === undefined) {
+            throw new Error('Required parameter "mintStETH" was null or undefined when calling mintStETH.');
+        }
+
+
+
+
+
+
+
+        (<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(mintStETH, "MintStETH")
+        };
+
+        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 mint wstETH transaction
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param mintWstETH 
+     */
+
+   
+
+
+
+   public async mintWstETH (contractsId: string, mintWstETH: MintWstETH, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ body: PartialTransaction, status: number }> {
+
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/vault/mint/wsteth'
+            .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 mintWstETH.');
+        }
+        // Verify required parameter 'mintWstETH' is not null or undefined
+        if (mintWstETH === null || mintWstETH === undefined) {
+            throw new Error('Required parameter "mintWstETH" was null or undefined when calling mintWstETH.');
+        }
+
+
+
+
+
+
+
+        (<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(mintWstETH, "MintWstETH")
+        };
+
+        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 Rebalance vault with ETH
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param rebalanceVaultWithEther 
+     */
+
+   
+
+
+
+   public async rebalanceVaultWithEther (contractsId: string, rebalanceVaultWithEther: RebalanceVaultWithEther, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ body: PartialTransaction, status: number }> {
+
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/vault/rebalance/ether'
+            .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 rebalanceVaultWithEther.');
+        }
+        // Verify required parameter 'rebalanceVaultWithEther' is not null or undefined
+        if (rebalanceVaultWithEther === null || rebalanceVaultWithEther === undefined) {
+            throw new Error('Required parameter "rebalanceVaultWithEther" was null or undefined when calling rebalanceVaultWithEther.');
+        }
+
+
+
+
+
+
+
+        (<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(rebalanceVaultWithEther, "RebalanceVaultWithEther")
+        };
+
+        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 Rebalance vault with shares
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param rebalanceVaultWithShares 
+     */
+
+   
+
+
+
+   public async rebalanceVaultWithShares (contractsId: string, rebalanceVaultWithShares: RebalanceVaultWithShares, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ body: PartialTransaction, status: number }> {
+
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/vault/rebalance/shares'
+            .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 rebalanceVaultWithShares.');
+        }
+        // Verify required parameter 'rebalanceVaultWithShares' is not null or undefined
+        if (rebalanceVaultWithShares === null || rebalanceVaultWithShares === undefined) {
+            throw new Error('Required parameter "rebalanceVaultWithShares" was null or undefined when calling rebalanceVaultWithShares.');
+        }
+
+
+
+
+
+
+
+        (<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(rebalanceVaultWithShares, "RebalanceVaultWithShares")
+        };
+
+        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 Recover ERC20 from vault
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param recoverERC20 
+     */
+
+   
+
+
+
+   public async recoverERC20 (contractsId: string, recoverERC20: RecoverERC20, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ body: PartialTransaction, status: number }> {
+
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/recover-erc20'
+            .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 recoverERC20.');
+        }
+        // Verify required parameter 'recoverERC20' is not null or undefined
+        if (recoverERC20 === null || recoverERC20 === undefined) {
+            throw new Error('Required parameter "recoverERC20" was null or undefined when calling recoverERC20.');
+        }
+
+
+
+
+
+
+
+        (<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(recoverERC20, "RecoverERC20")
+        };
+
+        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 Revoke vault role
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param revokeRole 
+     */
+
+   
+
+
+
+   public async revokeRole (contractsId: string, revokeRole: RevokeRole, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ body: PartialTransaction, status: number }> {
+
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/vault/revoke-role'
+            .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 revokeRole.');
+        }
+        // Verify required parameter 'revokeRole' is not null or undefined
+        if (revokeRole === null || revokeRole === undefined) {
+            throw new Error('Required parameter "revokeRole" was null or undefined when calling revokeRole.');
+        }
+
+
+
+
+
+
+
+        (<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(revokeRole, "RevokeRole")
+        };
+
+        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 the call data needed to submit the unguaranteed deposit transaction to the dashboard contract.
+     * @summary Stake ETH with a Lido staking vault
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param stakeEthRequest 
+     */
+
+   
+
+
+
+   public async stakeEthWithLidoContracts (contractsId: string, stakeEthRequest: StakeEthRequest, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ body: StakeEthResponse, status: number }> {
+
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/create-validator'
+            .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 stakeEthWithLidoContracts.');
+        }
+        // Verify required parameter 'stakeEthRequest' is not null or undefined
+        if (stakeEthRequest === null || stakeEthRequest === undefined) {
+            throw new Error('Required parameter "stakeEthRequest" was null or undefined when calling stakeEthWithLidoContracts.');
+        }
+
+
+
+
+
+
+
+        (<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(stakeEthRequest, "StakeEthRequest")
+        };
+
+        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: StakeEthResponse, 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, "StakeEthResponse");
+                        resolve({ body: body, status: response.statusCode });
+                    } else {
+                        console.error('API response error:', response.statusCode);
+                        resolve({ body: body, status: response.statusCode });
+                    }
+                }
+            });
+        });
+    } )
+}
+    /**
+     * 
+     * @summary Encode sync tier transaction
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param simulateAddress Optional Ethereum address to simulate the transaction from. If provided, the transaction will be simulated and any revert errors will be returned.
+     */
+
+   
+
+
+
+   public async syncTier (contractsId: string, simulateAddress?: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ body: PartialTransaction, status: number }> {
+
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/vault/sync-tier'
+            .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 syncTier.');
+        }
+
+
+
+    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 Trigger validator withdrawals
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param triggerValidatorWithdrawals 
+     */
+
+   
+
+
+
+   public async triggerValidatorWithdrawals (contractsId: string, triggerValidatorWithdrawals: TriggerValidatorWithdrawals, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ body: PartialTransaction, status: number }> {
+
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/trigger-validator-withdrawals'
+            .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 triggerValidatorWithdrawals.');
+        }
+        // Verify required parameter 'triggerValidatorWithdrawals' is not null or undefined
+        if (triggerValidatorWithdrawals === null || triggerValidatorWithdrawals === undefined) {
+            throw new Error('Required parameter "triggerValidatorWithdrawals" was null or undefined when calling triggerValidatorWithdrawals.');
+        }
+
+
+
+
+
+
+
+        (<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(triggerValidatorWithdrawals, "TriggerValidatorWithdrawals")
+        };
+
+        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 Unwrap wstETH to stETH
+     * @param unwrapWstETH 
+     */
+
+   
+
+
+
+   public async unwrapWstETH (unwrapWstETH: UnwrapWstETH, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ body: PartialTransaction, status: number }> {
+
+        const localVarPath = this.basePath + '/lidov3/unwrap-wsteth';
+       
+        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 'unwrapWstETH' is not null or undefined
+        if (unwrapWstETH === null || unwrapWstETH === undefined) {
+            throw new Error('Required parameter "unwrapWstETH" was null or undefined when calling unwrapWstETH.');
+        }
+
+
+
+
+
+
+
+        (<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(unwrapWstETH, "UnwrapWstETH")
+        };
+
+        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 update share limit transaction
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param updateShareLimit 
+     */
+
+   
+
+
+
+   public async updateShareLimit (contractsId: string, updateShareLimit: UpdateShareLimit, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ body: PartialTransaction, status: number }> {
+
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/vault/update-share-limit'
+            .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 updateShareLimit.');
+        }
+        // Verify required parameter 'updateShareLimit' is not null or undefined
+        if (updateShareLimit === null || updateShareLimit === undefined) {
+            throw new Error('Required parameter "updateShareLimit" was null or undefined when calling updateShareLimit.');
+        }
+
+
+
+
+
+
+
+        (<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(updateShareLimit, "UpdateShareLimit")
+        };
+
+        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 validator balances and signing wallet information for the given consolidation requests.
+     * @summary Validate consolidation requests
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param consolidateValidators 
+     */
+
+   
+
+
+
+   public async validateConsolidationRequests (contractsId: string, consolidateValidators: ConsolidateValidators, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ body: ValidateConsolidationRequestsResponse, status: number }> {
+
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/validate-consolidation-requests'
+            .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 validateConsolidationRequests.');
+        }
+        // Verify required parameter 'consolidateValidators' is not null or undefined
+        if (consolidateValidators === null || consolidateValidators === undefined) {
+            throw new Error('Required parameter "consolidateValidators" was null or undefined when calling validateConsolidationRequests.');
+        }
+
+
+
+
+
+
+
+        (<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(consolidateValidators, "ConsolidateValidators")
+        };
+
+        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: ValidateConsolidationRequestsResponse, 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, "ValidateConsolidationRequestsResponse");
+                        resolve({ body: body, status: response.statusCode });
+                    } else {
+                        console.error('API response error:', response.statusCode);
+                        resolve({ body: body, status: response.statusCode });
+                    }
+                }
+            });
+        });
+    } )
+}
+    /**
+     * 
+     * @summary Withdraw from vault
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param withdrawFromVault 
+     */
+
+   
+
+
+
+   public async withdrawFromVault (contractsId: string, withdrawFromVault: WithdrawFromVault, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ body: PartialTransaction, status: number }> {
+
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/withdraw'
+            .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 withdrawFromVault.');
+        }
+        // Verify required parameter 'withdrawFromVault' is not null or undefined
+        if (withdrawFromVault === null || withdrawFromVault === undefined) {
+            throw new Error('Required parameter "withdrawFromVault" was null or undefined when calling withdrawFromVault.');
+        }
+
+
+
+
+
+
+
+        (<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(withdrawFromVault, "WithdrawFromVault")
+        };
+
+        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 Wrap stETH to wstETH
+     * @param wrapStETH 
+     */
+
+   
+
+
+
+   public async wrapStETH (wrapStETH: WrapStETH, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ body: PartialTransaction, status: number }> {
+
+        const localVarPath = this.basePath + '/lidov3/wrap-steth';
+       
+        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 'wrapStETH' is not null or undefined
+        if (wrapStETH === null || wrapStETH === undefined) {
+            throw new Error('Required parameter "wrapStETH" was null or undefined when calling wrapStETH.');
+        }
+
+
+
+
+
+
+
+        (<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(wrapStETH, "WrapStETH")
+        };
+
+        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 });
+                    }
+                }
+            });
+        });
+    } )
+}
+}