@northstake/northstakeapi 1.0.39 → 1.0.40

package/.openapi-generator/FILES

@@ -22,6 +22,7 @@ model/asset.ts
 model/burnShares.ts
 model/burnStETH.ts
 model/burnWstETH.ts
+model/changeTier.ts
 model/collectERC20FromVault.ts
 model/consolidateValidators.ts
 model/consolidateValidatorsErrorResponse.ts
@@ -101,12 +102,14 @@ model/stakeEthResponse.ts
 model/stakeEthResponseDestructuredCallDataInner.ts
 model/stakingRequest.ts
 model/stakingRequestStatus.ts
+model/supportedValidatorProvidersResponse.ts
 model/transaction.ts
 model/triggerValidatorWithdrawals.ts
 model/unwrapWstETH.ts
 model/updateLinkedWalletNameRequest.ts
 model/updateMemberRoleRequest.ts
 model/updateOrganizationNameRequest.ts
+model/updateShareLimit.ts
 model/validateConsolidationRequestsResponse.ts
 model/validateConsolidationRequestsResponseConsolidationDetailsInner.ts
 model/validatorDailyReward.ts

package/api/lidoReadApi.ts

@@ -116,7 +116,7 @@ export class LidoReadApi {
 
     /**
      * 
-     * @summary Get all dashboard role members for a specific Lido staking contract set
+     * @summary Get dashboard role members for a vault
      * @param contractsId The unique identifier of the Lido staking contracts
      */
 
@@ -202,7 +202,7 @@ export class LidoReadApi {
 }
     /**
      * 
-     * @summary Get the vault report data from the lazy oracle for a specific Lido staking contract set
+     * @summary Get vault report data from lazy oracle
      * @param contractsId The unique identifier of the Lido staking contracts
      */
 
@@ -388,7 +388,7 @@ export class LidoReadApi {
 }
     /**
      * 
-     * @summary Get the vault report data from the lazy oracle for a specific Lido staking contract set
+     * @summary Get quarantine info for a vault
      * @param contractsId The unique identifier of the Lido staking contracts
      */
 

package/api/lidoStakingVaultsApi.ts

@@ -22,6 +22,7 @@ import { ErrorWithTransactionResponse } from '../model/errorWithTransactionRespo
 import { LidoStakingContracts } from '../model/lidoStakingContracts';
 import { LidoStakingContractsWithData } from '../model/lidoStakingContractsWithData';
 import { RenameVaultRequest } from '../model/renameVaultRequest';
+import { SupportedValidatorProvidersResponse } from '../model/supportedValidatorProvidersResponse';
 import { VaultCreationStartResponse } from '../model/vaultCreationStartResponse';
 
 import { ObjectSerializer, Authentication, VoidAuth, Interceptor } from '../model/models';
@@ -274,6 +275,86 @@ export class LidoStakingVaultsApi {
             });
         });
     } )
+}
+    /**
+     * Returns the list of validator providers that the current user can use when creating a Lido staking vault. 
+     * @summary List supported validator providers for vault creation
+     */
+
+   
+
+
+
+   public async getSupportedValidatorProviders (options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ body: SupportedValidatorProvidersResponse, status: number }> {
+
+        const localVarPath = this.basePath + '/lidov3/staking-vaults/supported-providers';
+       
+        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 = {};
+
+
+
+
+
+
+
+
+
+        (<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: SupportedValidatorProvidersResponse, 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, "SupportedValidatorProvidersResponse");
+                        resolve({ body: body, status: response.statusCode });
+                    } else {
+                        console.error('API response error:', response.statusCode);
+                        resolve({ body: body, status: response.statusCode });
+                    }
+                }
+            });
+        });
+    } )
 }
     /**
      * 

package/api/lidoWriteApi.ts

@@ -20,6 +20,7 @@ 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 +42,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';
@@ -126,6 +128,7 @@ export class LidoWriteApi {
 
     /**
      * 
+     * @summary Encode approval to burn stETH
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param approveStETH 
      */
@@ -217,6 +220,7 @@ export class LidoWriteApi {
 }
     /**
      * 
+     * @summary Encode approval to burn wstETH
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param approveWstETH 
      */
@@ -308,6 +312,7 @@ export class LidoWriteApi {
 }
     /**
      * 
+     * @summary Approve wrapping stETH to wstETH
      * @param approveStETH 
      */
 
@@ -393,6 +398,7 @@ export class LidoWriteApi {
 }
     /**
      * 
+     * @summary Encode burn shares transaction
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param burnShares 
      */
@@ -484,6 +490,7 @@ export class LidoWriteApi {
 }
     /**
      * 
+     * @summary Encode burn stETH transaction
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param burnStETH 
      */
@@ -575,6 +582,7 @@ export class LidoWriteApi {
 }
     /**
      * 
+     * @summary Encode burn wstETH transaction
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param burnWstETH 
      */
@@ -666,6 +674,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 
      */
@@ -849,6 +950,7 @@ export class LidoWriteApi {
 }
     /**
      * 
+     * @summary Fund vault with ETH
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param fundVault 
      */
@@ -939,16 +1041,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 +1074,9 @@ export class LidoWriteApi {
 
 
 
+    if (simulateAddress !== undefined) {
+        localVarQueryParameters['simulateAddress'] = ObjectSerializer.serialize(simulateAddress, "string");
+    }
 
 
 
@@ -1118,6 +1224,7 @@ export class LidoWriteApi {
 }
     /**
      * 
+     * @summary Grant vault role
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param grantRole 
      */
@@ -1209,7 +1316,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 +1406,7 @@ export class LidoWriteApi {
 }
     /**
      * 
+     * @summary Encode mint shares transaction
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param mintShares 
      */
@@ -1390,6 +1498,7 @@ export class LidoWriteApi {
 }
     /**
      * 
+     * @summary Encode mint stETH transaction
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param mintStETH 
      */
@@ -1481,6 +1590,7 @@ export class LidoWriteApi {
 }
     /**
      * 
+     * @summary Encode mint wstETH transaction
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param mintWstETH 
      */
@@ -1572,6 +1682,7 @@ export class LidoWriteApi {
 }
     /**
      * 
+     * @summary Rebalance vault with ETH
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param rebalanceVaultWithEther 
      */
@@ -1663,6 +1774,7 @@ export class LidoWriteApi {
 }
     /**
      * 
+     * @summary Rebalance vault with shares
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param rebalanceVaultWithShares 
      */
@@ -1754,6 +1866,7 @@ export class LidoWriteApi {
 }
     /**
      * 
+     * @summary Recover ERC20 from vault
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param recoverERC20 
      */
@@ -1845,6 +1958,7 @@ export class LidoWriteApi {
 }
     /**
      * 
+     * @summary Revoke vault role
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param revokeRole 
      */
@@ -1935,8 +2049,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 +2142,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 });
+                    }
+                }
+            });
+        });
+    } )
+}
+    /**
+     * 
+     * @summary Trigger validator withdrawals
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param triggerValidatorWithdrawals 
      */
@@ -2119,6 +2324,7 @@ export class LidoWriteApi {
 }
     /**
      * 
+     * @summary Unwrap wstETH to stETH
      * @param unwrapWstETH 
      */
 
@@ -2204,7 +2410,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 
      */
@@ -2296,6 +2594,7 @@ export class LidoWriteApi {
 }
     /**
      * 
+     * @summary Withdraw from vault
      * @param contractsId The unique identifier of the Lido staking contracts
      * @param withdrawFromVault 
      */
@@ -2387,6 +2686,7 @@ export class LidoWriteApi {
 }
     /**
      * 
+     * @summary Wrap stETH to wstETH
      * @param wrapStETH 
      */
 

package/api.ts

@@ -19,6 +19,7 @@ export * from './model/./asset';
 export * from './model/./burnShares';
 export * from './model/./burnStETH';
 export * from './model/./burnWstETH';
+export * from './model/./changeTier';
 export * from './model/./collectERC20FromVault';
 export * from './model/./consolidateValidators';
 export * from './model/./consolidateValidatorsErrorResponse';
@@ -97,12 +98,14 @@ export * from './model/./stakeEthResponse';
 export * from './model/./stakeEthResponseDestructuredCallDataInner';
 export * from './model/./stakingRequest';
 export * from './model/./stakingRequestStatus';
+export * from './model/./supportedValidatorProvidersResponse';
 export * from './model/./transaction';
 export * from './model/./triggerValidatorWithdrawals';
 export * from './model/./unwrapWstETH';
 export * from './model/./updateLinkedWalletNameRequest';
 export * from './model/./updateMemberRoleRequest';
 export * from './model/./updateOrganizationNameRequest';
+export * from './model/./updateShareLimit';
 export * from './model/./validateConsolidationRequestsResponse';
 export * from './model/./validateConsolidationRequestsResponseConsolidationDetailsInner';
 export * from './model/./validatorDailyReward';