@northstake/northstakeapi 1.0.39 → 1.0.41

package/dist/api/lidoWriteApi.js

@@ -75,8 +75,157 @@ class LidoWriteApi {
     addInterceptor(interceptor) {
         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.
+     */
+    async abandonDashboard(contractsId, abandonDashboardRequest, simulateAddress, options = { headers: {} }) {
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/abandon-dashboard'
+            .replace('{' + 'contractsId' + '}', encodeURIComponent(String(contractsId)));
+        let localVarQueryParameters = {};
+        let localVarHeaderParams = 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 = {};
+        // 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'] = models_1.ObjectSerializer.serialize(simulateAddress, "string");
+        }
+        Object.assign(localVarHeaderParams, options.headers);
+        let localVarUseFormData = false;
+        let localVarRequestOptions = {
+            method: 'POST',
+            qs: localVarQueryParameters,
+            headers: localVarHeaderParams,
+            uri: localVarPath,
+            useQuerystring: this._useQuerystring,
+            json: true,
+            body: models_1.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) {
+                    localVarRequestOptions.formData = localVarFormParams;
+                }
+                else {
+                    localVarRequestOptions.form = localVarFormParams;
+                }
+            }
+            return new Promise((resolve, reject) => {
+                (0, request_1.default)(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 = models_1.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.
+     */
+    async acceptStakingVaultOwnership(contractsId, simulateAddress, options = { headers: {} }) {
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/accept-staking-vault-ownership'
+            .replace('{' + 'contractsId' + '}', encodeURIComponent(String(contractsId)));
+        let localVarQueryParameters = {};
+        let localVarHeaderParams = 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 = {};
+        // 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'] = models_1.ObjectSerializer.serialize(simulateAddress, "string");
+        }
+        Object.assign(localVarHeaderParams, options.headers);
+        let localVarUseFormData = false;
+        let localVarRequestOptions = {
+            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) {
+                    localVarRequestOptions.formData = localVarFormParams;
+                }
+                else {
+                    localVarRequestOptions.form = localVarFormParams;
+                }
+            }
+            return new Promise((resolve, reject) => {
+                (0, request_1.default)(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 = models_1.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
      */
@@ -149,6 +298,7 @@ class LidoWriteApi {
     }
     /**
      *
+     * @summary Encode approval to burn wstETH
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param approveWstETH
      */
@@ -221,6 +371,7 @@ class LidoWriteApi {
     }
     /**
      *
+     * @summary Approve wrapping stETH to wstETH
      * @param approveStETH
      */
     async approveWrapStETH(approveStETH, options = { headers: {} }) {
@@ -287,6 +438,7 @@ class LidoWriteApi {
     }
     /**
      *
+     * @summary Encode burn shares transaction
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param burnShares
      */
@@ -359,6 +511,7 @@ class LidoWriteApi {
     }
     /**
      *
+     * @summary Encode burn stETH transaction
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param burnStETH
      */
@@ -431,6 +584,7 @@ class LidoWriteApi {
     }
     /**
      *
+     * @summary Encode burn wstETH transaction
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param burnWstETH
      */
@@ -503,6 +657,80 @@ class LidoWriteApi {
     }
     /**
      *
+     * @summary Encode change tier transaction
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param changeTier
+     */
+    async changeTier(contractsId, changeTier, options = { headers: {} }) {
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/vault/change-tier'
+            .replace('{' + 'contractsId' + '}', encodeURIComponent(String(contractsId)));
+        let localVarQueryParameters = {};
+        let localVarHeaderParams = 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 = {};
+        // 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.');
+        }
+        Object.assign(localVarHeaderParams, options.headers);
+        let localVarUseFormData = false;
+        let localVarRequestOptions = {
+            method: 'POST',
+            qs: localVarQueryParameters,
+            headers: localVarHeaderParams,
+            uri: localVarPath,
+            useQuerystring: this._useQuerystring,
+            json: true,
+            body: models_1.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) {
+                    localVarRequestOptions.formData = localVarFormParams;
+                }
+                else {
+                    localVarRequestOptions.form = localVarFormParams;
+                }
+            }
+            return new Promise((resolve, reject) => {
+                (0, request_1.default)(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 = models_1.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
      */
@@ -573,6 +801,77 @@ class LidoWriteApi {
             });
         });
     }
+    /**
+     * Returns a partial transaction to connect the vault to the vault hub (payable with 1 ETH). Only allowed when the vault is not already connected; returns 400 if already connected.
+     * @summary Connect to vault hub
+     * @param contractsId The unique identifier of the Lido staking contracts
+     * @param simulateAddress Optional Ethereum address to simulate the transaction from.
+     */
+    async connectToVaultHub(contractsId, simulateAddress, options = { headers: {} }) {
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/connect-to-vault-hub'
+            .replace('{' + 'contractsId' + '}', encodeURIComponent(String(contractsId)));
+        let localVarQueryParameters = {};
+        let localVarHeaderParams = 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 = {};
+        // 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'] = models_1.ObjectSerializer.serialize(simulateAddress, "string");
+        }
+        Object.assign(localVarHeaderParams, options.headers);
+        let localVarUseFormData = false;
+        let localVarRequestOptions = {
+            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) {
+                    localVarRequestOptions.formData = localVarFormParams;
+                }
+                else {
+                    localVarRequestOptions.form = localVarFormParams;
+                }
+            }
+            return new Promise((resolve, reject) => {
+                (0, request_1.default)(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 = models_1.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
@@ -648,6 +947,7 @@ class LidoWriteApi {
     }
     /**
      *
+     * @summary Fund vault with ETH
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param fundVault
      */
@@ -719,11 +1019,12 @@ 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.
      */
-    async getLazyOracleReportCallData(contractsId, options = { headers: {} }) {
+    async getLazyOracleReportCallData(contractsId, simulateAddress, options = { headers: {} }) {
         const localVarPath = this.basePath + '/lidov3/{contractsId}/update-vault-report'
             .replace('{' + 'contractsId' + '}', encodeURIComponent(String(contractsId)));
         let localVarQueryParameters = {};
@@ -740,6 +1041,9 @@ class LidoWriteApi {
         if (contractsId === null || contractsId === undefined) {
             throw new Error('Required parameter "contractsId" was null or undefined when calling getLazyOracleReportCallData.');
         }
+        if (simulateAddress !== undefined) {
+            localVarQueryParameters['simulateAddress'] = models_1.ObjectSerializer.serialize(simulateAddress, "string");
+        }
         Object.assign(localVarHeaderParams, options.headers);
         let localVarUseFormData = false;
         let localVarRequestOptions = {
@@ -860,6 +1164,7 @@ class LidoWriteApi {
     }
     /**
      *
+     * @summary Grant vault role
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param grantRole
      */
@@ -932,7 +1237,7 @@ 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
      */
@@ -1003,6 +1308,7 @@ class LidoWriteApi {
     }
     /**
      *
+     * @summary Encode mint shares transaction
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param mintShares
      */
@@ -1075,6 +1381,7 @@ class LidoWriteApi {
     }
     /**
      *
+     * @summary Encode mint stETH transaction
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param mintStETH
      */
@@ -1147,6 +1454,7 @@ class LidoWriteApi {
     }
     /**
      *
+     * @summary Encode mint wstETH transaction
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param mintWstETH
      */
@@ -1219,6 +1527,7 @@ class LidoWriteApi {
     }
     /**
      *
+     * @summary Rebalance vault with ETH
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param rebalanceVaultWithEther
      */
@@ -1291,6 +1600,7 @@ class LidoWriteApi {
     }
     /**
      *
+     * @summary Rebalance vault with shares
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param rebalanceVaultWithShares
      */
@@ -1363,6 +1673,7 @@ class LidoWriteApi {
     }
     /**
      *
+     * @summary Recover ERC20 from vault
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param recoverERC20
      */
@@ -1435,6 +1746,7 @@ class LidoWriteApi {
     }
     /**
      *
+     * @summary Revoke vault role
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param revokeRole
      */
@@ -1506,8 +1818,8 @@ 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
      */
@@ -1580,6 +1892,78 @@ 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.
+     */
+    async syncTier(contractsId, simulateAddress, options = { headers: {} }) {
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/vault/sync-tier'
+            .replace('{' + 'contractsId' + '}', encodeURIComponent(String(contractsId)));
+        let localVarQueryParameters = {};
+        let localVarHeaderParams = 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 = {};
+        // 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'] = models_1.ObjectSerializer.serialize(simulateAddress, "string");
+        }
+        Object.assign(localVarHeaderParams, options.headers);
+        let localVarUseFormData = false;
+        let localVarRequestOptions = {
+            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) {
+                    localVarRequestOptions.formData = localVarFormParams;
+                }
+                else {
+                    localVarRequestOptions.form = localVarFormParams;
+                }
+            }
+            return new Promise((resolve, reject) => {
+                (0, request_1.default)(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 = models_1.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
      */
@@ -1652,6 +2036,7 @@ class LidoWriteApi {
     }
     /**
      *
+     * @summary Unwrap wstETH to stETH
      * @param unwrapWstETH
      */
     async unwrapWstETH(unwrapWstETH, options = { headers: {} }) {
@@ -1718,7 +2103,80 @@ 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
+     */
+    async updateShareLimit(contractsId, updateShareLimit, options = { headers: {} }) {
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/vault/update-share-limit'
+            .replace('{' + 'contractsId' + '}', encodeURIComponent(String(contractsId)));
+        let localVarQueryParameters = {};
+        let localVarHeaderParams = 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 = {};
+        // 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.');
+        }
+        Object.assign(localVarHeaderParams, options.headers);
+        let localVarUseFormData = false;
+        let localVarRequestOptions = {
+            method: 'POST',
+            qs: localVarQueryParameters,
+            headers: localVarHeaderParams,
+            uri: localVarPath,
+            useQuerystring: this._useQuerystring,
+            json: true,
+            body: models_1.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) {
+                    localVarRequestOptions.formData = localVarFormParams;
+                }
+                else {
+                    localVarRequestOptions.form = localVarFormParams;
+                }
+            }
+            return new Promise((resolve, reject) => {
+                (0, request_1.default)(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 = models_1.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
      */
@@ -1790,7 +2248,79 @@ 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.
+     */
+    async voluntaryDisconnectFromVaultHub(contractsId, simulateAddress, options = { headers: {} }) {
+        const localVarPath = this.basePath + '/lidov3/{contractsId}/voluntary-disconnect'
+            .replace('{' + 'contractsId' + '}', encodeURIComponent(String(contractsId)));
+        let localVarQueryParameters = {};
+        let localVarHeaderParams = 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 = {};
+        // 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'] = models_1.ObjectSerializer.serialize(simulateAddress, "string");
+        }
+        Object.assign(localVarHeaderParams, options.headers);
+        let localVarUseFormData = false;
+        let localVarRequestOptions = {
+            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) {
+                    localVarRequestOptions.formData = localVarFormParams;
+                }
+                else {
+                    localVarRequestOptions.form = localVarFormParams;
+                }
+            }
+            return new Promise((resolve, reject) => {
+                (0, request_1.default)(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 = models_1.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
      */
@@ -1863,6 +2393,7 @@ class LidoWriteApi {
     }
     /**
      *
+     * @summary Wrap stETH to wstETH
      * @param wrapStETH
      */
     async wrapStETH(wrapStETH, options = { headers: {} }) {