@northstake/northstakeapi 1.0.39 → 1.0.41

package/api/lidoWriteApi.ts

@@ -15,11 +15,13 @@ import localVarRequest from 'request';
 import http from 'http';
 
 /* tslint:disable:no-unused-locals */
+import { AbandonDashboardRequest } from '../model/abandonDashboardRequest';
 import { ApproveStETH } from '../model/approveStETH';
 import { ApproveWstETH } from '../model/approveWstETH';
 import { BurnShares } from '../model/burnShares';
 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';
@@ -41,6 +43,7 @@ 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';
@@ -124,8 +127,195 @@ export class LidoWriteApi {
         this.interceptors.push(interceptor);
     }
 
+    /**
+     * Returns a partial transaction to call Dashboard.abandonDashboard(newOwner). Only allowed when the vault is fully disconnected from the vault hub (after disconnect has completed). Step 3 of the stVault disconnect guide (with Dashboard). 
+     * @summary Abandon dashboard and transfer vault ownership (disconnect Step 3)
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param abandonDashboardRequest 
+     * @param simulateAddress Optional Ethereum address to simulate the transaction from.
+     */
+
+   
+
+
+
+   public async abandonDashboard (contractsId: string, abandonDashboardRequest: AbandonDashboardRequest, simulateAddress?: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ body: PartialTransaction, status: number }> {
+
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/abandon-dashboard'
+            .replace('{' + 'contractsId' + '}', encodeURIComponent(String(contractsId)));
+       
+        let localVarQueryParameters: any = {};
+        let localVarHeaderParams: any = (<any>Object).assign({}, this._defaultHeaders);
+        const produces = ['application/json'];
+        if (produces.indexOf('application/json') >= 0) {
+            localVarHeaderParams.Accept = 'application/json';
+        } else {
+            localVarHeaderParams.Accept = produces.join(',');
+        }
+        let localVarFormParams: any = {};
+
+
+        // Verify required parameter 'contractsId' is not null or undefined
+        if (contractsId === null || contractsId === undefined) {
+            throw new Error('Required parameter "contractsId" was null or undefined when calling abandonDashboard.');
+        }
+        // Verify required parameter 'abandonDashboardRequest' is not null or undefined
+        if (abandonDashboardRequest === null || abandonDashboardRequest === undefined) {
+            throw new Error('Required parameter "abandonDashboardRequest" was null or undefined when calling abandonDashboard.');
+        }
+
+
+
+    if (simulateAddress !== undefined) {
+        localVarQueryParameters['simulateAddress'] = ObjectSerializer.serialize(simulateAddress, "string");
+    }
+
+
+
+
+        (<any>Object).assign(localVarHeaderParams, options.headers);
+
+        let localVarUseFormData = false;
+
+
+
+        let localVarRequestOptions: localVarRequest.Options = {
+            method: 'POST',
+            qs: localVarQueryParameters,
+            headers: localVarHeaderParams,
+            uri: localVarPath,
+            useQuerystring: this._useQuerystring,
+            json: true,
+            body: ObjectSerializer.serialize(abandonDashboardRequest, "AbandonDashboardRequest")
+        };
+
+        let authenticationPromise = Promise.resolve();
+        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
+
+        let interceptorPromise = authenticationPromise;
+        for (const interceptor of this.interceptors) {
+            interceptorPromise = interceptorPromise.then(() => interceptor(localVarRequestOptions));
+        }
+
+        return interceptorPromise.then(() => {
+            if (Object.keys(localVarFormParams).length) {
+                if (localVarUseFormData) {
+                    (<any>localVarRequestOptions).formData = localVarFormParams;
+                } else {
+                    localVarRequestOptions.form = localVarFormParams;
+                }
+            }
+                 return new Promise<{ body: PartialTransaction, status: number }>((resolve, reject) => {
+            localVarRequest(localVarRequestOptions, (error, response, body) => {
+                if (error) {
+                    console.error('API call error:', error);
+                    reject(error);
+                } else {
+                    if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
+                        body = ObjectSerializer.deserialize(body, "PartialTransaction");
+                        resolve({ body: body, status: response.statusCode });
+                    } else {
+                        console.error('API response error:', response.statusCode);
+                        resolve({ body: body, status: response.statusCode });
+                    }
+                }
+            });
+        });
+    } )
+}
+    /**
+     * Returns a partial transaction to call StakingVault.acceptOwnership(). Only allowed when the vault is fully disconnected from the vault hub. Step 4 of the stVault disconnect guide (with Dashboard), or Step 3 without Dashboard. 
+     * @summary Accept staking vault ownership (disconnect Step 4)
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param simulateAddress Optional Ethereum address to simulate the transaction from.
+     */
+
+   
+
+
+
+   public async acceptStakingVaultOwnership (contractsId: string, simulateAddress?: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ body: PartialTransaction, status: number }> {
+
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/accept-staking-vault-ownership'
+            .replace('{' + 'contractsId' + '}', encodeURIComponent(String(contractsId)));
+       
+        let localVarQueryParameters: any = {};
+        let localVarHeaderParams: any = (<any>Object).assign({}, this._defaultHeaders);
+        const produces = ['application/json'];
+        if (produces.indexOf('application/json') >= 0) {
+            localVarHeaderParams.Accept = 'application/json';
+        } else {
+            localVarHeaderParams.Accept = produces.join(',');
+        }
+        let localVarFormParams: any = {};
+
+
+        // Verify required parameter 'contractsId' is not null or undefined
+        if (contractsId === null || contractsId === undefined) {
+            throw new Error('Required parameter "contractsId" was null or undefined when calling acceptStakingVaultOwnership.');
+        }
+
+
+
+    if (simulateAddress !== undefined) {
+        localVarQueryParameters['simulateAddress'] = ObjectSerializer.serialize(simulateAddress, "string");
+    }
+
+
+
+
+        (<any>Object).assign(localVarHeaderParams, options.headers);
+
+        let localVarUseFormData = false;
+
+
+
+        let localVarRequestOptions: localVarRequest.Options = {
+            method: 'POST',
+            qs: localVarQueryParameters,
+            headers: localVarHeaderParams,
+            uri: localVarPath,
+            useQuerystring: this._useQuerystring,
+            json: true,
+        };
+
+        let authenticationPromise = Promise.resolve();
+        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
+
+        let interceptorPromise = authenticationPromise;
+        for (const interceptor of this.interceptors) {
+            interceptorPromise = interceptorPromise.then(() => interceptor(localVarRequestOptions));
+        }
+
+        return interceptorPromise.then(() => {
+            if (Object.keys(localVarFormParams).length) {
+                if (localVarUseFormData) {
+                    (<any>localVarRequestOptions).formData = localVarFormParams;
+                } else {
+                    localVarRequestOptions.form = localVarFormParams;
+                }
+            }
+                 return new Promise<{ body: PartialTransaction, status: number }>((resolve, reject) => {
+            localVarRequest(localVarRequestOptions, (error, response, body) => {
+                if (error) {
+                    console.error('API call error:', error);
+                    reject(error);
+                } else {
+                    if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
+                        body = ObjectSerializer.deserialize(body, "PartialTransaction");
+                        resolve({ body: body, status: response.statusCode });
+                    } else {
+                        console.error('API response error:', response.statusCode);
+                        resolve({ body: body, status: response.statusCode });
+                    }
+                }
+            });
+        });
+    } )
+}
     /**
      * 
+     * @summary Encode approval to burn stETH
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param approveStETH 
      */
@@ -217,6 +407,7 @@ export class LidoWriteApi {
 }
     /**
      * 
+     * @summary Encode approval to burn wstETH
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param approveWstETH 
      */
@@ -308,6 +499,7 @@ export class LidoWriteApi {
 }
     /**
      * 
+     * @summary Approve wrapping stETH to wstETH
      * @param approveStETH 
      */
 
@@ -393,6 +585,7 @@ export class LidoWriteApi {
 }
     /**
      * 
+     * @summary Encode burn shares transaction
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param burnShares 
      */
@@ -484,6 +677,7 @@ export class LidoWriteApi {
 }
     /**
      * 
+     * @summary Encode burn stETH transaction
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param burnStETH 
      */
@@ -575,6 +769,7 @@ export class LidoWriteApi {
 }
     /**
      * 
+     * @summary Encode burn wstETH transaction
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param burnWstETH 
      */
@@ -666,6 +861,99 @@ export class LidoWriteApi {
 }
     /**
      * 
+     * @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 
      */
@@ -718,7 +1006,97 @@ export class LidoWriteApi {
             uri: localVarPath,
             useQuerystring: this._useQuerystring,
             json: true,
-            body: ObjectSerializer.serialize(collectERC20FromVault, "CollectERC20FromVault")
+            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 });
+                    }
+                }
+            });
+        });
+    } )
+}
+    /**
+     * Returns a partial transaction to connect the vault to the vault hub (payable with 1 ETH). Only allowed when the vault is not already connected; returns 400 if already connected. 
+     * @summary Connect to vault hub
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param simulateAddress Optional Ethereum address to simulate the transaction from.
+     */
+
+   
+
+
+
+   public async connectToVaultHub (contractsId: string, simulateAddress?: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ body: PartialTransaction, status: number }> {
+
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/connect-to-vault-hub'
+            .replace('{' + 'contractsId' + '}', encodeURIComponent(String(contractsId)));
+       
+        let localVarQueryParameters: any = {};
+        let localVarHeaderParams: any = (<any>Object).assign({}, this._defaultHeaders);
+        const produces = ['application/json'];
+        if (produces.indexOf('application/json') >= 0) {
+            localVarHeaderParams.Accept = 'application/json';
+        } else {
+            localVarHeaderParams.Accept = produces.join(',');
+        }
+        let localVarFormParams: any = {};
+
+
+        // Verify required parameter 'contractsId' is not null or undefined
+        if (contractsId === null || contractsId === undefined) {
+            throw new Error('Required parameter "contractsId" was null or undefined when calling connectToVaultHub.');
+        }
+
+
+
+    if (simulateAddress !== undefined) {
+        localVarQueryParameters['simulateAddress'] = ObjectSerializer.serialize(simulateAddress, "string");
+    }
+
+
+
+
+        (<any>Object).assign(localVarHeaderParams, options.headers);
+
+        let localVarUseFormData = false;
+
+
+
+        let localVarRequestOptions: localVarRequest.Options = {
+            method: 'POST',
+            qs: localVarQueryParameters,
+            headers: localVarHeaderParams,
+            uri: localVarPath,
+            useQuerystring: this._useQuerystring,
+            json: true,
         };
 
         let authenticationPromise = Promise.resolve();
@@ -849,6 +1227,7 @@ export class LidoWriteApi {
 }
     /**
      * 
+     * @summary Fund vault with ETH
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param fundVault 
      */
@@ -939,16 +1318,17 @@ export class LidoWriteApi {
     } )
 }
     /**
-     * 
-     * @summary Update the lazy oracle report for a specific Lido staking contract set, returns the calldata needed to submit the updateVaultData transaction to the lazy oracle contract.
+     * 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, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ body: GetLazyOracleReportCallData200Response, status: number }> {
+   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)));
@@ -971,6 +1351,9 @@ export class LidoWriteApi {
 
 
 
+    if (simulateAddress !== undefined) {
+        localVarQueryParameters['simulateAddress'] = ObjectSerializer.serialize(simulateAddress, "string");
+    }
 
 
 
@@ -1118,6 +1501,7 @@ export class LidoWriteApi {
 }
     /**
      * 
+     * @summary Grant vault role
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param grantRole 
      */
@@ -1209,7 +1593,7 @@ export class LidoWriteApi {
 }
     /**
      * 
-     * @summary List staking request IDs for a specific Lido staking contract set
+     * @summary List staking request IDs for a vault
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param status 
      */
@@ -1299,6 +1683,7 @@ export class LidoWriteApi {
 }
     /**
      * 
+     * @summary Encode mint shares transaction
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param mintShares 
      */
@@ -1390,6 +1775,7 @@ export class LidoWriteApi {
 }
     /**
      * 
+     * @summary Encode mint stETH transaction
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param mintStETH 
      */
@@ -1481,6 +1867,7 @@ export class LidoWriteApi {
 }
     /**
      * 
+     * @summary Encode mint wstETH transaction
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param mintWstETH 
      */
@@ -1572,6 +1959,7 @@ export class LidoWriteApi {
 }
     /**
      * 
+     * @summary Rebalance vault with ETH
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param rebalanceVaultWithEther 
      */
@@ -1663,6 +2051,7 @@ export class LidoWriteApi {
 }
     /**
      * 
+     * @summary Rebalance vault with shares
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param rebalanceVaultWithShares 
      */
@@ -1754,6 +2143,7 @@ export class LidoWriteApi {
 }
     /**
      * 
+     * @summary Recover ERC20 from vault
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param recoverERC20 
      */
@@ -1845,6 +2235,7 @@ export class LidoWriteApi {
 }
     /**
      * 
+     * @summary Revoke vault role
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param revokeRole 
      */
@@ -1935,8 +2326,8 @@ export class LidoWriteApi {
     } )
 }
     /**
-     * 
-     * @summary Stake ETH using a specific Lido staking contract set. Returns the call data needed to submit the unguaranteed deposit transaction to the dashboard contract.
+     * 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 
      */
@@ -2028,6 +2419,97 @@ export class LidoWriteApi {
 }
     /**
      * 
+     * @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 });
+                    }
+                }
+            });
+        });
+    } )
+}
+    /**
+     * Returns a partial transaction to trigger EIP-7002 validator withdrawals. When the vault is connected, uses Dashboard. When the vault is disconnected (e.g. after the disconnect wizard), uses StakingVault.triggerValidatorWithdrawals. 
+     * @summary Trigger validator withdrawals
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param triggerValidatorWithdrawals 
      */
@@ -2119,6 +2601,7 @@ export class LidoWriteApi {
 }
     /**
      * 
+     * @summary Unwrap wstETH to stETH
      * @param unwrapWstETH 
      */
 
@@ -2204,7 +2687,99 @@ export class LidoWriteApi {
 }
     /**
      * 
-     * @summary Validate consolidation requests and return validator balances and signing wallet information
+     * @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 
      */
@@ -2295,7 +2870,98 @@ export class LidoWriteApi {
     } )
 }
     /**
-     * 
+     * Returns a partial transaction to voluntarily disconnect the vault from the vault hub. This is the only write operation allowed when the vault is already disconnected. 
+     * @summary Voluntary disconnect from vault hub
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param simulateAddress Optional Ethereum address to simulate the transaction from.
+     */
+
+   
+
+
+
+   public async voluntaryDisconnectFromVaultHub (contractsId: string, simulateAddress?: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ body: PartialTransaction, status: number }> {
+
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/voluntary-disconnect'
+            .replace('{' + 'contractsId' + '}', encodeURIComponent(String(contractsId)));
+       
+        let localVarQueryParameters: any = {};
+        let localVarHeaderParams: any = (<any>Object).assign({}, this._defaultHeaders);
+        const produces = ['application/json'];
+        if (produces.indexOf('application/json') >= 0) {
+            localVarHeaderParams.Accept = 'application/json';
+        } else {
+            localVarHeaderParams.Accept = produces.join(',');
+        }
+        let localVarFormParams: any = {};
+
+
+        // Verify required parameter 'contractsId' is not null or undefined
+        if (contractsId === null || contractsId === undefined) {
+            throw new Error('Required parameter "contractsId" was null or undefined when calling voluntaryDisconnectFromVaultHub.');
+        }
+
+
+
+    if (simulateAddress !== undefined) {
+        localVarQueryParameters['simulateAddress'] = ObjectSerializer.serialize(simulateAddress, "string");
+    }
+
+
+
+
+        (<any>Object).assign(localVarHeaderParams, options.headers);
+
+        let localVarUseFormData = false;
+
+
+
+        let localVarRequestOptions: localVarRequest.Options = {
+            method: 'POST',
+            qs: localVarQueryParameters,
+            headers: localVarHeaderParams,
+            uri: localVarPath,
+            useQuerystring: this._useQuerystring,
+            json: true,
+        };
+
+        let authenticationPromise = Promise.resolve();
+        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
+
+        let interceptorPromise = authenticationPromise;
+        for (const interceptor of this.interceptors) {
+            interceptorPromise = interceptorPromise.then(() => interceptor(localVarRequestOptions));
+        }
+
+        return interceptorPromise.then(() => {
+            if (Object.keys(localVarFormParams).length) {
+                if (localVarUseFormData) {
+                    (<any>localVarRequestOptions).formData = localVarFormParams;
+                } else {
+                    localVarRequestOptions.form = localVarFormParams;
+                }
+            }
+                 return new Promise<{ body: PartialTransaction, status: number }>((resolve, reject) => {
+            localVarRequest(localVarRequestOptions, (error, response, body) => {
+                if (error) {
+                    console.error('API call error:', error);
+                    reject(error);
+                } else {
+                    if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
+                        body = ObjectSerializer.deserialize(body, "PartialTransaction");
+                        resolve({ body: body, status: response.statusCode });
+                    } else {
+                        console.error('API response error:', response.statusCode);
+                        resolve({ body: body, status: response.statusCode });
+                    }
+                }
+            });
+        });
+    } )
+}
+    /**
+     * Returns a partial transaction to withdraw ETH. When the vault is connected, uses Dashboard.withdraw. When the vault is disconnected (e.g. after the disconnect wizard), uses StakingVault.withdraw(recipient, amount). 
+     * @summary Withdraw from vault
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param withdrawFromVault 
      */
@@ -2387,6 +3053,7 @@ export class LidoWriteApi {
 }
     /**
      * 
+     * @summary Wrap stETH to wstETH
      * @param wrapStETH 
      */