@northstake/northstakeapi 1.0.39 → 1.0.41

package/api/validatorsApi.ts

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

package/api.ts

@@ -9,6 +9,7 @@ import { LidoWriteApi } from './api/lidoWriteApi';
 import { LinkedWalletsApi } from './api/linkedWalletsApi';
 import { OrganizationApi } from './api/organizationApi';
 import { ValidatorsApi } from './api/validatorsApi';
+export * from './model/./abandonDashboardRequest';
 export * from './model/./acceptedQuote';
 export * from './model/./accountEntity';
 export * from './model/./addLinkedWalletRequest';
@@ -19,6 +20,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';
@@ -48,9 +50,9 @@ export * from './model/./getLazyOracleReportCallData200ResponseDestructuredCalld
 export * from './model/./getLazyOracleReportData200Response';
 export * from './model/./getLazyOracleReportData200ResponseReportData';
 export * from './model/./getLidoTransactions200Response';
+export * from './model/./getOperatorGroup200Response';
 export * from './model/./getQuarantineInfo200Response';
 export * from './model/./getStETHPerWstETHRate200Response';
-export * from './model/./getWithdrawalsResponse';
 export * from './model/./grantRole';
 export * from './model/./internalTransaction';
 export * from './model/./inviteMemberRequest';
@@ -97,12 +99,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';
@@ -114,7 +118,6 @@ export * from './model/./validatorRewardsDaily';
 export * from './model/./validatorRewardsDailyResponse';
 export * from './model/./validatorRewardsRaw';
 export * from './model/./validatorType';
-export * from './model/./validatorWithdrawal';
 export * from './model/./vaultCreationStartResponse';
 export * from './model/./wallet';
 export * from './model/./webHookLookupAnswer';

package/dist/api/lidoReadApi.d.ts

@@ -11,6 +11,7 @@
  */
 import { GetLazyOracleReportData200Response } from '../model/getLazyOracleReportData200Response';
 import { GetLidoTransactions200Response } from '../model/getLidoTransactions200Response';
+import { GetOperatorGroup200Response } from '../model/getOperatorGroup200Response';
 import { GetQuarantineInfo200Response } from '../model/getQuarantineInfo200Response';
 import { GetStETHPerWstETHRate200Response } from '../model/getStETHPerWstETHRate200Response';
 import { Authentication, Interceptor } from '../model/models';
@@ -52,7 +53,7 @@ export declare class LidoReadApi {
     addInterceptor(interceptor: Interceptor): void;
     /**
      *
-     * @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
      */
     getAllDashboardRoleMembers(contractsId: string, options?: {
@@ -67,7 +68,7 @@ export declare 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
      */
     getLazyOracleReportData(contractsId: string, options?: {
@@ -97,7 +98,20 @@ export declare class LidoReadApi {
     }>;
     /**
      *
-     * @summary Get the vault report data from the lazy oracle for a specific Lido staking contract set
+     * @summary Get operator group info from the operator grid
+     * @param nodeOperator The Ethereum address of the node operator
+     */
+    getOperatorGroup(nodeOperator: string, options?: {
+        headers: {
+            [name: string]: string;
+        };
+    }): Promise<{
+        body: GetOperatorGroup200Response;
+        status: number;
+    }>;
+    /**
+     *
+     * @summary Get quarantine info for a vault
      * @param contractsId The unique identifier of the Lido staking contracts
      */
     getQuarantineInfo(contractsId: string, options?: {

package/dist/api/lidoReadApi.js

@@ -77,7 +77,7 @@ 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
      */
     async getAllDashboardRoleMembers(contractsId, options = { headers: {} }) {
@@ -144,7 +144,7 @@ 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
      */
     async getLazyOracleReportData(contractsId, options = { headers: {} }) {
@@ -292,7 +292,76 @@ class LidoReadApi {
     }
     /**
      *
-     * @summary Get the vault report data from the lazy oracle for a specific Lido staking contract set
+     * @summary Get operator group info from the operator grid
+     * @param nodeOperator The Ethereum address of the node operator
+     */
+    async getOperatorGroup(nodeOperator, options = { headers: {} }) {
+        const localVarPath = this.basePath + '/lidov3/operator-group';
+        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 'nodeOperator' is not null or undefined
+        if (nodeOperator === null || nodeOperator === undefined) {
+            throw new Error('Required parameter "nodeOperator" was null or undefined when calling getOperatorGroup.');
+        }
+        if (nodeOperator !== undefined) {
+            localVarQueryParameters['nodeOperator'] = models_1.ObjectSerializer.serialize(nodeOperator, "string");
+        }
+        Object.assign(localVarHeaderParams, options.headers);
+        let localVarUseFormData = false;
+        let localVarRequestOptions = {
+            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) {
+                    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, "GetOperatorGroup200Response");
+                            resolve({ body: body, status: response.statusCode });
+                        }
+                        else {
+                            console.error('API response error:', response.statusCode);
+                            resolve({ body: body, status: response.statusCode });
+                        }
+                    }
+                });
+            });
+        });
+    }
+    /**
+     *
+     * @summary Get quarantine info for a vault
      * @param contractsId The unique identifier of the Lido staking contracts
      */
     async getQuarantineInfo(contractsId, options = { headers: {} }) {

package/dist/api/lidoStakingVaultsApi.d.ts

@@ -14,6 +14,7 @@ import { CreateVaultRequest } from '../model/createVaultRequest';
 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 { Authentication, Interceptor } from '../model/models';
 import { HttpBearerAuth, ApiKeyAuth } from '../model/models';
@@ -66,6 +67,18 @@ export declare class LidoStakingVaultsApi {
         body: LidoStakingContractsWithData;
         status: number;
     }>;
+    /**
+     * 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
+     */
+    getSupportedValidatorProviders(options?: {
+        headers: {
+            [name: string]: string;
+        };
+    }): Promise<{
+        body: SupportedValidatorProvidersResponse;
+        status: number;
+    }>;
     /**
      *
      * @summary List all Lido staking contract sets

package/dist/api/lidoStakingVaultsApi.js

@@ -209,6 +209,67 @@ 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
+     */
+    async getSupportedValidatorProviders(options = { headers: {} }) {
+        const localVarPath = this.basePath + '/lidov3/staking-vaults/supported-providers';
+        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 = {};
+        Object.assign(localVarHeaderParams, options.headers);
+        let localVarUseFormData = false;
+        let localVarRequestOptions = {
+            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) {
+                    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, "SupportedValidatorProvidersResponse");
+                            resolve({ body: body, status: response.statusCode });
+                        }
+                        else {
+                            console.error('API response error:', response.statusCode);
+                            resolve({ body: body, status: response.statusCode });
+                        }
+                    }
+                });
+            });
+        });
+    }
     /**
      *
      * @summary List all Lido staking contract sets