diff --git a/package.json b/package.json
index 657ce3123d..bed080fa88 100644
--- a/package.json
+++ b/package.json
@@ -40,7 +40,7 @@
     "test:one": "polkadot-dev-run-test --env node"
   },
   "devDependencies": {
-    "@polkadot/dev": "^0.72.9",
+    "@polkadot/dev": "^0.72.15",
     "@polkadot/typegen": "workspace:packages/typegen",
     "@types/node": "^18.15.3"
   },
diff --git a/packages/api-base/src/types/base.ts b/packages/api-base/src/types/base.ts
index e7367fd19e..f733b7f5a7 100644
--- a/packages/api-base/src/types/base.ts
+++ b/packages/api-base/src/types/base.ts
@@ -62,8 +62,7 @@ export interface PaginationOptions<A = unknown> {
   startKey?: string;
 }
 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-export type DecorateMethod<ApiType extends ApiTypes, T = any> =
+export type DecorateMethod<_ApiType extends ApiTypes, T = any> =
   <M extends (...args: any[]) => Observable<any>>(method: M, options?: DecorateMethodOptions) => T;
 
 type AsCodec<R extends Codec | any> = R extends Codec
@@ -71,3 +70,9 @@ type AsCodec<R extends Codec | any> = R extends Codec
   : Codec;
 
 export type ReturnCodec<F extends AnyFunction> = AsCodec<ObsInnerType<ReturnType<F>>>;
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface EmptyBase<_> {
+  // this is use to allow use to have unused vars in augmented interfaces,
+  // so intentionally left empty
+}
diff --git a/packages/api-base/src/types/calls.ts b/packages/api-base/src/types/calls.ts
index b9637c2150..98ae1a9a3a 100644
--- a/packages/api-base/src/types/calls.ts
+++ b/packages/api-base/src/types/calls.ts
@@ -3,14 +3,13 @@
 
 import type { Observable } from 'rxjs';
 import type { AnyFunction, Codec, DefinitionCallNamed } from '@polkadot/types/types';
-import type { ApiTypes, ReturnCodec } from './base.js';
+import type { ApiTypes, EmptyBase, ReturnCodec } from './base.js';
 
 export type DecoratedCallBase<ApiType extends ApiTypes, F extends AnyFunction = (...args: any[]) => Observable<Codec>> =
   ApiType extends 'rxjs'
     ? <T extends Codec | any = ReturnCodec<F>> (...args: Parameters<F>) => Observable<T>
     : <T extends Codec | any = ReturnCodec<F>> (...args: Parameters<F>) => Promise<T>;
 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 export type AugmentedCall<ApiType extends ApiTypes, F extends AnyFunction = (...args: any[]) => Observable<Codec>> = DecoratedCallBase<ApiType, F> & {
   /** The metadata/description/definition for this method */
   meta: DefinitionCallNamed
@@ -18,8 +17,8 @@ export type AugmentedCall<ApiType extends ApiTypes, F extends AnyFunction = (...
 
 // augmented interfaces
 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars,@typescript-eslint/no-empty-interface
-export interface AugmentedCalls<ApiType extends ApiTypes> {
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface AugmentedCalls<ApiType extends ApiTypes> extends EmptyBase<ApiType> {
   // augmented
 }
 
diff --git a/packages/api-base/src/types/consts.ts b/packages/api-base/src/types/consts.ts
index 98967eb3f8..920a2e20f2 100644
--- a/packages/api-base/src/types/consts.ts
+++ b/packages/api-base/src/types/consts.ts
@@ -3,17 +3,16 @@
 
 import type { PalletConstantMetadataLatest } from '@polkadot/types/interfaces';
 import type { Codec } from '@polkadot/types/types';
-import type { ApiTypes } from './base.js';
+import type { ApiTypes, EmptyBase } from './base.js';
 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-export interface AugmentedConst<ApiType extends ApiTypes> {
+export interface AugmentedConst<_ extends ApiTypes> {
   meta: PalletConstantMetadataLatest;
 }
 
 // augmented interfaces
 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars,@typescript-eslint/no-empty-interface
-export interface AugmentedConsts<ApiType extends ApiTypes> {
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface AugmentedConsts<ApiType extends ApiTypes> extends EmptyBase<ApiType> {
   // augmented
 }
 
diff --git a/packages/api-base/src/types/errors.ts b/packages/api-base/src/types/errors.ts
index 780869d672..396a784070 100644
--- a/packages/api-base/src/types/errors.ts
+++ b/packages/api-base/src/types/errors.ts
@@ -2,15 +2,14 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import type { IsError } from '@polkadot/types/metadata/decorate/types';
-import type { ApiTypes } from './base.js';
+import type { ApiTypes, EmptyBase } from './base.js';
 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-export type AugmentedError<ApiType extends ApiTypes> = IsError;
+export type AugmentedError<_ extends ApiTypes> = IsError;
 
 // augmented interfaces
 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars,@typescript-eslint/no-empty-interface
-export interface AugmentedErrors<ApiType extends ApiTypes> {
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface AugmentedErrors<ApiType extends ApiTypes> extends EmptyBase<ApiType> {
   // augmented
 }
 
diff --git a/packages/api-base/src/types/events.ts b/packages/api-base/src/types/events.ts
index 2923bd2424..ee5b7e0ef8 100644
--- a/packages/api-base/src/types/events.ts
+++ b/packages/api-base/src/types/events.ts
@@ -3,15 +3,14 @@
 
 import type { IsEvent } from '@polkadot/types/metadata/decorate/types';
 import type { AnyTuple } from '@polkadot/types/types';
-import type { ApiTypes } from './base.js';
+import type { ApiTypes, EmptyBase } from './base.js';
 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-export type AugmentedEvent<ApiType extends ApiTypes, T extends AnyTuple = AnyTuple, N = unknown> = IsEvent<T, N>;
+export type AugmentedEvent<_ extends ApiTypes, T extends AnyTuple = AnyTuple, N = unknown> = IsEvent<T, N>;
 
 // augmented interfaces
 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars,@typescript-eslint/no-empty-interface
-export interface AugmentedEvents<ApiType extends ApiTypes> {
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface AugmentedEvents<ApiType extends ApiTypes> extends EmptyBase<ApiType> {
   // augmented
 }
 
diff --git a/packages/api-base/src/types/storage.ts b/packages/api-base/src/types/storage.ts
index d142439124..abbf502a0b 100644
--- a/packages/api-base/src/types/storage.ts
+++ b/packages/api-base/src/types/storage.ts
@@ -6,7 +6,7 @@ import type { StorageKey, u64 } from '@polkadot/types';
 import type { Hash } from '@polkadot/types/interfaces';
 import type { StorageEntry } from '@polkadot/types/primitive/types';
 import type { AnyFunction, AnyTuple, Callback, Codec, IStorageKey } from '@polkadot/types/types';
-import type { ApiTypes, DropLast, MethodResult, PaginationOptions, PromiseOrObs, ReturnCodec, UnsubscribePromise } from './base.js';
+import type { ApiTypes, DropLast, EmptyBase, MethodResult, PaginationOptions, PromiseOrObs, ReturnCodec, UnsubscribePromise } from './base.js';
 
 interface StorageEntryObservableMulti<R extends Codec = Codec> {
   <T extends Codec = R>(args: (unknown[] | unknown)[]): Observable<T[]>;
@@ -114,8 +114,8 @@ export type AugmentedQueryDoubleMap<ApiType extends ApiTypes, F extends AnyFunct
 
 // augmented interfaces
 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars,@typescript-eslint/no-empty-interface
-export interface AugmentedQueries<ApiType extends ApiTypes> {
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface AugmentedQueries<ApiType extends ApiTypes> extends EmptyBase<ApiType> {
   // augmented
 }
 
diff --git a/packages/api-base/src/types/submittable.ts b/packages/api-base/src/types/submittable.ts
index ff956e98a6..64c421db5a 100644
--- a/packages/api-base/src/types/submittable.ts
+++ b/packages/api-base/src/types/submittable.ts
@@ -4,7 +4,7 @@
 import type { Observable } from 'rxjs';
 import type { AccountId, Address, ApplyExtrinsicResult, BlockNumber, Call, DispatchError, DispatchInfo, EventRecord, Extrinsic, ExtrinsicStatus, Hash, RuntimeDispatchInfo } from '@polkadot/types/interfaces';
 import type { AnyFunction, AnyNumber, AnyTuple, Callback, CallBase, Codec, IExtrinsicEra, IKeyringPair, ISubmittableResult, Signer } from '@polkadot/types/types';
-import type { ApiTypes, PromiseOrObs } from './base.js';
+import type { ApiTypes, EmptyBase, PromiseOrObs } from './base.js';
 
 export type AugmentedSubmittable<T extends AnyFunction, A extends AnyTuple = AnyTuple> = T & CallBase<A>;
 
@@ -81,8 +81,8 @@ export interface SubmittableExtrinsicFunction<ApiType extends ApiTypes, A extend
 
 // augmented interfaces
 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars,@typescript-eslint/no-empty-interface
-export interface AugmentedSubmittables<ApiType extends ApiTypes> {
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface AugmentedSubmittables<ApiType extends ApiTypes> extends EmptyBase<ApiType> {
   // augmented
 }
 
diff --git a/packages/api-contract/src/Abi/toLatest.ts b/packages/api-contract/src/Abi/toLatest.ts
index babc38882d..c41aa71e75 100644
--- a/packages/api-contract/src/Abi/toLatest.ts
+++ b/packages/api-contract/src/Abi/toLatest.ts
@@ -23,7 +23,7 @@ function createConverter <I, O> (next: (registry: Registry, input: O) => Contrac
     next(registry, step(registry, input));
 }
 
-export function v4ToLatest (registry: Registry, v4: ContractMetadataV4): ContractMetadataLatest {
+export function v4ToLatest (_registry: Registry, v4: ContractMetadataV4): ContractMetadataLatest {
   return v4;
 }
 
diff --git a/packages/api-contract/src/Abi/toV4.ts b/packages/api-contract/src/Abi/toV4.ts
index ba98584205..fd6d04ca86 100644
--- a/packages/api-contract/src/Abi/toV4.ts
+++ b/packages/api-contract/src/Abi/toV4.ts
@@ -4,6 +4,6 @@
 import type { ContractMetadataV3, ContractMetadataV4 } from '@polkadot/types/interfaces';
 import type { Registry } from '@polkadot/types/types';
 
-export function v3ToV4 (registry: Registry, v3: ContractMetadataV3): ContractMetadataV4 {
+export function v3ToV4 (_registry: Registry, v3: ContractMetadataV3): ContractMetadataV4 {
   return v3;
 }
diff --git a/packages/api-derive/src/accounts/idAndIndex.ts b/packages/api-derive/src/accounts/idAndIndex.ts
index 876c593b9d..bc996a57ad 100644
--- a/packages/api-derive/src/accounts/idAndIndex.ts
+++ b/packages/api-derive/src/accounts/idAndIndex.ts
@@ -46,7 +46,7 @@ export function idAndIndex (instanceId: string, api: DeriveApi): (address?: Addr
       return api.derive.accounts.indexToId(accountIndex.toString()).pipe(
         map((accountId): AccountIdAndIndex => [accountId, accountIndex])
       );
-    } catch (error) {
+    } catch {
       return of([undefined, undefined]);
     }
   });
diff --git a/packages/api-derive/src/staking/ownExposure.ts b/packages/api-derive/src/staking/ownExposure.ts
index ec97b483fe..f8713581fc 100644
--- a/packages/api-derive/src/staking/ownExposure.ts
+++ b/packages/api-derive/src/staking/ownExposure.ts
@@ -11,7 +11,6 @@ import { firstMemo, memo } from '../util/index.js';
 import { erasHistoricApplyAccount } from './util.js';
 
 export function _ownExposures (instanceId: string, api: DeriveApi): (accountId: Uint8Array | string, eras: EraIndex[], withActive: boolean) => Observable<DeriveOwnExposure[]> {
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   return memo(instanceId, (accountId: Uint8Array | string, eras: EraIndex[], _withActive: boolean): Observable<DeriveOwnExposure[]> =>
     eras.length
       ? combineLatest([
diff --git a/packages/api-derive/src/staking/ownSlashes.ts b/packages/api-derive/src/staking/ownSlashes.ts
index 82f94b986f..c6c8c5fbd9 100644
--- a/packages/api-derive/src/staking/ownSlashes.ts
+++ b/packages/api-derive/src/staking/ownSlashes.ts
@@ -12,7 +12,6 @@ import { firstMemo, memo } from '../util/index.js';
 import { erasHistoricApplyAccount } from './util.js';
 
 export function _ownSlashes (instanceId: string, api: DeriveApi): (accountId: Uint8Array | string, eras: EraIndex[], withActive: boolean) => Observable<DeriveStakerSlashes[]> {
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   return memo(instanceId, (accountId: Uint8Array | string, eras: EraIndex[], _withActive: boolean): Observable<DeriveStakerSlashes[]> =>
     eras.length
       ? combineLatest([
diff --git a/packages/api-derive/src/staking/stakerPrefs.ts b/packages/api-derive/src/staking/stakerPrefs.ts
index 6fffce4386..ae7e6fc7d8 100644
--- a/packages/api-derive/src/staking/stakerPrefs.ts
+++ b/packages/api-derive/src/staking/stakerPrefs.ts
@@ -11,7 +11,6 @@ import { memo } from '../util/index.js';
 import { erasHistoricApplyAccount } from './util.js';
 
 export function _stakerPrefs (instanceId: string, api: DeriveApi): (accountId: Uint8Array | string, eras: EraIndex[], withActive: boolean) => Observable<DeriveStakerPrefs[]> {
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   return memo(instanceId, (accountId: Uint8Array | string, eras: EraIndex[], _withActive: boolean): Observable<DeriveStakerPrefs[]> =>
     api.query.staking.erasValidatorPrefs.multi(eras.map((e) => [e, accountId])).pipe(
       map((all): DeriveStakerPrefs[] =>
diff --git a/packages/api/src/promise/Combinator.ts b/packages/api/src/promise/Combinator.ts
index ca1c817fca..3e93f98b13 100644
--- a/packages/api/src/promise/Combinator.ts
+++ b/packages/api/src/promise/Combinator.ts
@@ -62,7 +62,7 @@ export class Combinator<T extends unknown[] = unknown[]> {
     try {
       // eslint-disable-next-line @typescript-eslint/no-floating-promises
       this.#callback(this.#results as T);
-    } catch (error) {
+    } catch {
       // swallow, we don't want the handler to trip us up
     }
   }
@@ -82,7 +82,7 @@ export class Combinator<T extends unknown[] = unknown[]> {
         if (isFunction(unsubscribe)) {
           unsubscribe();
         }
-      } catch (error) {
+      } catch {
         // ignore
       }
     });
diff --git a/packages/api/src/promise/Combinators.spec.ts b/packages/api/src/promise/Combinators.spec.ts
index 057a1dc0ee..61d7633683 100644
--- a/packages/api/src/promise/Combinators.spec.ts
+++ b/packages/api/src/promise/Combinators.spec.ts
@@ -98,8 +98,7 @@ describe('Combinator', (): void => {
         mocker,
         // eslint-disable-next-line @typescript-eslint/require-await
         async (): UnsubscribePromise => (): void => undefined
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      ], (value: any[]): void => {
+      ], (_: any[]): void => {
         // ignore
       });
 
diff --git a/packages/rpc-core/src/methodSend.spec.ts b/packages/rpc-core/src/methodSend.spec.ts
index 90d072d9bf..7f0bf8cb8e 100644
--- a/packages/rpc-core/src/methodSend.spec.ts
+++ b/packages/rpc-core/src/methodSend.spec.ts
@@ -33,7 +33,7 @@ describe('methodSend', (): void => {
     };
 
     provider = {
-      send: jest.fn((method: string, params: unknown[]): Promise<unknown> =>
+      send: jest.fn((_method: string, params: unknown[]): Promise<unknown> =>
         Promise.resolve(params[0])
       )
     } as unknown as ProviderInterface;
diff --git a/packages/rpc-provider/src/http/index.ts b/packages/rpc-provider/src/http/index.ts
index bac56c7f92..402d5d1eed 100644
--- a/packages/rpc-provider/src/http/index.ts
+++ b/packages/rpc-provider/src/http/index.ts
@@ -112,8 +112,7 @@ export class HttpProvider implements ProviderInterface {
    * @summary Events are not supported with the HttpProvider, see [[WsProvider]].
    * @description HTTP Provider does not have 'on' emitters. WebSockets should be used instead.
    */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  public on (type: ProviderInterfaceEmitted, sub: ProviderInterfaceEmitCb): () => void {
+  public on (_type: ProviderInterfaceEmitted, _sub: ProviderInterfaceEmitCb): () => void {
     l.error('HTTP Provider does not have \'on\' emitters, use WebSockets instead');
 
     return (): void => {
@@ -185,8 +184,8 @@ export class HttpProvider implements ProviderInterface {
   /**
    * @summary Subscriptions are not supported with the HttpProvider, see [[WsProvider]].
    */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars,@typescript-eslint/require-await
-  public async subscribe (types: string, method: string, params: unknown[], cb: ProviderInterfaceCallback): Promise<number> {
+  // eslint-disable-next-line @typescript-eslint/require-await
+  public async subscribe (_types: string, _method: string, _params: unknown[], _cb: ProviderInterfaceCallback): Promise<number> {
     l.error(ERROR_SUBSCRIBE);
 
     throw new Error(ERROR_SUBSCRIBE);
@@ -195,8 +194,8 @@ export class HttpProvider implements ProviderInterface {
   /**
    * @summary Subscriptions are not supported with the HttpProvider, see [[WsProvider]].
    */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars,@typescript-eslint/require-await
-  public async unsubscribe (type: string, method: string, id: number): Promise<boolean> {
+  // eslint-disable-next-line @typescript-eslint/require-await
+  public async unsubscribe (_type: string, _method: string, _id: number): Promise<boolean> {
     l.error(ERROR_SUBSCRIBE);
 
     throw new Error(ERROR_SUBSCRIBE);
diff --git a/packages/rpc-provider/src/mock/index.ts b/packages/rpc-provider/src/mock/index.ts
index 64435bc3b0..4cebf66ba4 100644
--- a/packages/rpc-provider/src/mock/index.ts
+++ b/packages/rpc-provider/src/mock/index.ts
@@ -53,9 +53,8 @@ export class MockProvider implements ProviderInterface {
   private prevNumber = new BN(-1);
 
   private requests: Record<string, (...params: any[]) => unknown> = {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars,@typescript-eslint/no-unsafe-member-access
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     chain_getBlock: () => this.registry.createType('SignedBlock', rpcSignedBlock.result).toJSON(),
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     chain_getBlockHash: () => '0x1234000000000000000000000000000000000000000000000000000000000000',
     // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     chain_getFinalizedHead: () => this.registry.createType('Header', rpcHeader.result).hash,
@@ -144,7 +143,7 @@ export class MockProvider implements ProviderInterface {
   }
 
   // eslint-disable-next-line @typescript-eslint/require-await
-  public async subscribe (type: string, method: string, ...params: unknown[]): Promise<number> {
+  public async subscribe (_type: string, method: string, ...params: unknown[]): Promise<number> {
     l.debug(() => ['subscribe', method, params]);
 
     if (!this.subscriptions[method]) {
@@ -165,7 +164,7 @@ export class MockProvider implements ProviderInterface {
   }
 
   // eslint-disable-next-line @typescript-eslint/require-await
-  public async unsubscribe (type: string, method: string, id: number): Promise<boolean> {
+  public async unsubscribe (_type: string, _method: string, id: number): Promise<boolean> {
     const sub = this.subscriptionMap[id];
 
     l.debug(() => ['unsubscribe', id, sub]);
diff --git a/packages/rpc-provider/src/mock/mockHttp.ts b/packages/rpc-provider/src/mock/mockHttp.ts
index d4f8bd754a..764edbd0e5 100644
--- a/packages/rpc-provider/src/mock/mockHttp.ts
+++ b/packages/rpc-provider/src/mock/mockHttp.ts
@@ -25,7 +25,7 @@ export function mockHttp (requests: Request[]): Mock {
   return requests.reduce((scope: HttpMock, request: Request) =>
     scope
       .post('/')
-      .reply(request.code || 200, (uri: string, body: { id: string }) => {
+      .reply(request.code || 200, (_uri: string, body: { id: string }) => {
         scope.body = scope.body || {};
         scope.body[request.method] = body;
 
diff --git a/packages/rpc-provider/src/substrate-connect/Health.ts b/packages/rpc-provider/src/substrate-connect/Health.ts
index f7a37c1739..ba6fcd079d 100644
--- a/packages/rpc-provider/src/substrate-connect/Health.ts
+++ b/packages/rpc-provider/src/substrate-connect/Health.ts
@@ -113,7 +113,7 @@ class InnerChecker {
 
     try {
       parsedRequest = JSON.parse(request) as JSONRequest;
-    } catch (err) {
+    } catch {
       return;
     }
 
@@ -131,7 +131,7 @@ class InnerChecker {
 
     try {
       parsedResponse = JSON.parse(jsonRpcResponse) as { id: string, result: undefined | SmoldotHealth };
-    } catch (err) {
+    } catch {
       return jsonRpcResponse;
     }
 
diff --git a/packages/rpc-provider/src/ws/index.ts b/packages/rpc-provider/src/ws/index.ts
index f2f8e65d0f..6bbf6ae1d1 100644
--- a/packages/rpc-provider/src/ws/index.ts
+++ b/packages/rpc-provider/src/ws/index.ts
@@ -243,7 +243,7 @@ export class WsProvider implements ProviderInterface {
     if (this.#autoConnectMs > 0) {
       try {
         await this.connect();
-      } catch (error) {
+      } catch {
         setTimeout((): void => {
           this.connectWithRetry().catch((): void => {
             // does not throw
@@ -417,7 +417,7 @@ export class WsProvider implements ProviderInterface {
       return this.isConnected && !isNull(this.#websocket)
         ? this.send<boolean>(method, [id])
         : true;
-    } catch (error) {
+    } catch {
       return false;
     }
   }
diff --git a/packages/typegen/src/generate/lookup.ts b/packages/typegen/src/generate/lookup.ts
index fe9612770d..024b83f437 100644
--- a/packages/typegen/src/generate/lookup.ts
+++ b/packages/typegen/src/generate/lookup.ts
@@ -218,7 +218,7 @@ function generateLookupTypes (registry: Registry, filtered: [PortableType, TypeD
   writeFile(path.join(destDir, 'index.ts'), () => generateLookupIndexTmpl({ headerType: 'defs' }), true);
 }
 
-function generateRegistry (registry: Registry, filtered: [PortableType, TypeDef][], destDir: string, subPath: string): void {
+function generateRegistry (_registry: Registry, filtered: [PortableType, TypeDef][], destDir: string, subPath: string): void {
   writeFile(path.join(destDir, `${subPath}.ts`), (): string => {
     const items = filtered
       .map(([, { lookupName }]) => lookupName)
diff --git a/packages/typegen/src/generate/tsDef.ts b/packages/typegen/src/generate/tsDef.ts
index 66dc38a80e..922357f342 100644
--- a/packages/typegen/src/generate/tsDef.ts
+++ b/packages/typegen/src/generate/tsDef.ts
@@ -32,8 +32,7 @@ export function createGetter (definitions: Record<string, ModuleTypes>, name = '
 }
 
 /** @internal */
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-function errorUnhandled (_: Registry, definitions: Record<string, ModuleTypes>, def: TypeDef, imports: TypeImports): string {
+function errorUnhandled (_: Registry, _definitions: Record<string, ModuleTypes>, def: TypeDef, _imports: TypeImports): string {
   throw new Error(`Generate: ${def.name || ''}: Unhandled type ${TypeDefInfo[def.info]}`);
 }
 
@@ -96,7 +95,7 @@ function tsInt (_: Registry, definitions: Record<string, ModuleTypes>, def: Type
 }
 
 /** @internal */
-function tsNull (registry: Registry, definitions: Record<string, ModuleTypes>, { lookupIndex = -1, name }: TypeDef, imports: TypeImports): string {
+function tsNull (_registry: Registry, definitions: Record<string, ModuleTypes>, { lookupIndex = -1, name }: TypeDef, imports: TypeImports): string {
   setImports(definitions, imports, ['Null']);
 
   // * @description extends [[${base}]]
@@ -151,8 +150,7 @@ function tsResult (registry: Registry, definitions: Record<string, ModuleTypes>,
 }
 
 /** @internal */
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-function tsSi (registry: Registry, definitions: Record<string, ModuleTypes>, typeDef: TypeDef, imports: TypeImports): string {
+function tsSi (_registry: Registry, _definitions: Record<string, ModuleTypes>, typeDef: TypeDef, _imports: TypeImports): string {
   // FIXME
   return `// SI: ${JSON.stringify(typeDef)}`;
 }
diff --git a/packages/typegen/src/util/formatting.ts b/packages/typegen/src/util/formatting.ts
index 99ba5ce1cc..65fb2c536b 100644
--- a/packages/typegen/src/util/formatting.ts
+++ b/packages/typegen/src/util/formatting.ts
@@ -1,8 +1,6 @@
 // Copyright 2017-2023 @polkadot/typegen authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-/* eslint-disable @typescript-eslint/no-unused-vars */
-
 import type { AnyString, Registry } from '@polkadot/types/types';
 import type { LookupString } from '@polkadot/types-codec/types';
 import type { TypeDef } from '@polkadot/types-create/types';
@@ -139,13 +137,13 @@ const formatters: Record<TypeDefInfo, (registry: Registry, typeDef: TypeDef, def
     return singleParamNotation(registry, 'Compact', typeDef, definitions, imports, withShortcut);
   },
 
-  [TypeDefInfo.DoNotConstruct]: (registry: Registry, { lookupName }: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
+  [TypeDefInfo.DoNotConstruct]: (_registry: Registry, _typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, _withShortcut: boolean) => {
     setImports(definitions, imports, ['DoNotConstruct']);
 
     return 'DoNotConstruct';
   },
 
-  [TypeDefInfo.Enum]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
+  [TypeDefInfo.Enum]: (_registry: Registry, typeDef: TypeDef, _definitions: Record<string, ModuleTypes>, _imports: TypeImports, _withShortcut: boolean) => {
     if (typeDef.lookupName) {
       return typeDef.lookupName;
     }
@@ -153,15 +151,15 @@ const formatters: Record<TypeDefInfo, (registry: Registry, typeDef: TypeDef, def
     throw new Error(`TypeDefInfo.Enum: Parameter formatting not implemented on ${stringify(typeDef)}`);
   },
 
-  [TypeDefInfo.Int]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
+  [TypeDefInfo.Int]: (_registry: Registry, typeDef: TypeDef, _definitions: Record<string, ModuleTypes>, _imports: TypeImports, _withShortcut: boolean) => {
     throw new Error(`TypeDefInfo.Int: Parameter formatting not implemented on ${stringify(typeDef)}`);
   },
 
-  [TypeDefInfo.UInt]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
+  [TypeDefInfo.UInt]: (_registry: Registry, typeDef: TypeDef, _definitions: Record<string, ModuleTypes>, _imports: TypeImports, _withShortcut: boolean) => {
     throw new Error(`TypeDefInfo.UInt: Parameter formatting not implemented on ${stringify(typeDef)}`);
   },
 
-  [TypeDefInfo.Null]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
+  [TypeDefInfo.Null]: (_registry: Registry, _typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, _withShortcut: boolean) => {
     setImports(definitions, imports, ['Null']);
 
     return 'Null';
@@ -171,7 +169,7 @@ const formatters: Record<TypeDefInfo, (registry: Registry, typeDef: TypeDef, def
     return singleParamNotation(registry, 'Option', typeDef, definitions, imports, withShortcut);
   },
 
-  [TypeDefInfo.Plain]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
+  [TypeDefInfo.Plain]: (_registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, _withShortcut: boolean) => {
     setImports(definitions, imports, [typeDef.type]);
 
     return typeDef.type;
@@ -185,7 +183,7 @@ const formatters: Record<TypeDefInfo, (registry: Registry, typeDef: TypeDef, def
     return singleParamNotation(registry, 'RangeInclusive', typeDef, definitions, imports, withShortcut);
   },
 
-  [TypeDefInfo.Set]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
+  [TypeDefInfo.Set]: (_registry: Registry, typeDef: TypeDef, _definitions: Record<string, ModuleTypes>, _imports: TypeImports, _withShortcut: boolean) => {
     throw new Error(`TypeDefInfo.Set: Parameter formatting not implemented on ${stringify(typeDef)}`);
   },
 
diff --git a/packages/typegen/src/util/wsMeta.ts b/packages/typegen/src/util/wsMeta.ts
index c5da2fa809..ba53e83b5f 100644
--- a/packages/typegen/src/util/wsMeta.ts
+++ b/packages/typegen/src/util/wsMeta.ts
@@ -36,6 +36,9 @@ async function getWsData <T> (endpoint: string, method: 'rpc_methods' | 'state_g
         websocket.close();
       };
     } catch (error) {
+      console.error();
+      console.error(error);
+      console.error();
       process.exit(1);
     }
   });
diff --git a/packages/types-codec/src/abstract/Int.ts b/packages/types-codec/src/abstract/Int.ts
index f38d8b6540..152ec10df6 100644
--- a/packages/types-codec/src/abstract/Int.ts
+++ b/packages/types-codec/src/abstract/Int.ts
@@ -197,8 +197,7 @@ export abstract class AbstractInt extends BN implements INumber {
   /**
    * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
    */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  public toHuman (isExpanded?: boolean): string {
+  public toHuman (_isExpanded?: boolean): string {
     const rawType = this.toRawType();
 
     if (rawType === 'Balance') {
@@ -263,8 +262,7 @@ export abstract class AbstractInt extends BN implements INumber {
    * @description Encodes the value as a Uint8Array as per the SCALE specifications
    * @param isBare true when the value has none of the type-specific prefixes (internal)
    */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  public toU8a (isBare?: boolean): Uint8Array {
+  public toU8a (_isBare?: boolean): Uint8Array {
     return bnToU8a(this, {
       bitLength: this.bitLength(),
       isLe: true,
diff --git a/packages/types-codec/src/base/Compact.ts b/packages/types-codec/src/base/Compact.ts
index 19a254b6f2..11c75e0113 100644
--- a/packages/types-codec/src/base/Compact.ts
+++ b/packages/types-codec/src/base/Compact.ts
@@ -195,8 +195,7 @@ export class Compact<T extends INumber> implements ICompact<T> {
    * @description Encodes the value as a Uint8Array as per the SCALE specifications
    * @param isBare true when the value has none of the type-specific prefixes (internal)
    */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  public toU8a (isBare?: boolean): Uint8Array {
+  public toU8a (_isBare?: boolean): Uint8Array {
     return compactToU8a(this.#raw.toBn());
   }
 
diff --git a/packages/types-codec/src/base/Null.ts b/packages/types-codec/src/base/Null.ts
index e11036a1fa..659ec846ff 100644
--- a/packages/types-codec/src/base/Null.ts
+++ b/packages/types-codec/src/base/Null.ts
@@ -91,8 +91,7 @@ export class Null implements Codec {
    * @description Encodes the value as a Uint8Array as per the SCALE specifications
    * @param isBare true when the value has none of the type-specific prefixes (internal)
    */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  public toU8a (isBare?: boolean): Uint8Array {
+  public toU8a (_isBare?: boolean): Uint8Array {
     return new Uint8Array();
   }
 }
diff --git a/packages/types-codec/src/base/Vec.spec.ts b/packages/types-codec/src/base/Vec.spec.ts
index be3b9200cf..21c842825e 100644
--- a/packages/types-codec/src/base/Vec.spec.ts
+++ b/packages/types-codec/src/base/Vec.spec.ts
@@ -131,7 +131,7 @@ describe('Vec', (): void => {
 
     it('exposes a working filter', (): void => {
       expect(
-        vector.filter((e, i): boolean => i >= 3).toString()
+        vector.filter((_, i): boolean => i >= 3).toString()
       ).toEqual('4567,56789');
     });
 
diff --git a/packages/types-codec/src/base/Vec.ts b/packages/types-codec/src/base/Vec.ts
index 4dd52ca01b..d25e92ef45 100644
--- a/packages/types-codec/src/base/Vec.ts
+++ b/packages/types-codec/src/base/Vec.ts
@@ -118,14 +118,14 @@ export class Vec<T extends Codec> extends AbstractArray<T> {
   /**
    * @description Finds the index of the value in the array
    */
-  public override indexOf (_other?: unknown): number {
+  public override indexOf (other?: unknown): number {
     // convert type first, this removes overhead from the eq
-    const other = _other instanceof this.#Type
-      ? _other
-      : new this.#Type(this.registry, _other);
+    const check = other instanceof this.#Type
+      ? other
+      : new this.#Type(this.registry, other);
 
     for (let i = 0; i < this.length; i++) {
-      if (other.eq(this[i])) {
+      if (check.eq(this[i])) {
         return i;
       }
     }
diff --git a/packages/types-codec/src/native/Bool.ts b/packages/types-codec/src/native/Bool.ts
index 575b7db6b0..ee75db4a02 100644
--- a/packages/types-codec/src/native/Bool.ts
+++ b/packages/types-codec/src/native/Bool.ts
@@ -132,8 +132,7 @@ export class bool extends Boolean implements Codec {
    * @description Encodes the value as a Uint8Array as per the SCALE specifications
    * @param isBare true when the value has none of the type-specific prefixes (internal)
    */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  public toU8a (isBare?: boolean): Uint8Array {
+  public toU8a (_isBare?: boolean): Uint8Array {
     return new Uint8Array([this.valueOf() ? 1 : 0]);
   }
 }
diff --git a/packages/types-codec/src/native/Date.ts b/packages/types-codec/src/native/Date.ts
index 3c72df97a3..33b11ea76b 100644
--- a/packages/types-codec/src/native/Date.ts
+++ b/packages/types-codec/src/native/Date.ts
@@ -164,8 +164,7 @@ export class CodecDate extends Date implements INumber {
    * @description Encodes the value as a Uint8Array as per the SCALE specifications
    * @param isBare true when the value has none of the type-specific prefixes (internal)
    */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  public toU8a (isBare?: boolean): Uint8Array {
+  public toU8a (_isBare?: boolean): Uint8Array {
     return bnToU8a(this.toNumber(), U8A_OPTS);
   }
 }
diff --git a/packages/types-codec/src/native/Json.ts b/packages/types-codec/src/native/Json.ts
index c7f569a739..2cc5e6b919 100644
--- a/packages/types-codec/src/native/Json.ts
+++ b/packages/types-codec/src/native/Json.ts
@@ -141,8 +141,7 @@ export class Json extends Map<string, any> implements Codec {
   /**
    * @description Unimplemented, will throw
    */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  public toU8a (isBare?: boolean): Uint8Array {
+  public toU8a (_isBare?: boolean): Uint8Array {
     throw new Error('Unimplemented');
   }
 }
diff --git a/packages/types-codec/src/native/Raw.ts b/packages/types-codec/src/native/Raw.ts
index 4da879bf48..910da6fdeb 100644
--- a/packages/types-codec/src/native/Raw.ts
+++ b/packages/types-codec/src/native/Raw.ts
@@ -155,8 +155,7 @@ export class Raw extends Uint8Array implements IU8a {
    * @description Encodes the value as a Uint8Array as per the SCALE specifications
    * @param isBare true when the value has none of the type-specific prefixes (internal)
    */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  public toU8a (isBare?: boolean): Uint8Array {
+  public toU8a (_isBare?: boolean): Uint8Array {
     return Uint8Array.from(this);
   }
 
diff --git a/packages/types-codec/src/native/Set.ts b/packages/types-codec/src/native/Set.ts
index b4bb74d5d1..dd4e036f9e 100644
--- a/packages/types-codec/src/native/Set.ts
+++ b/packages/types-codec/src/native/Set.ts
@@ -259,8 +259,7 @@ export class CodecSet extends Set<string> implements ISet<string> {
    * @description Encodes the value as a Uint8Array as per the SCALE specifications
    * @param isBare true when the value has none of the type-specific prefixes (internal)
    */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  public toU8a (isBare?: boolean): Uint8Array {
+  public toU8a (_isBare?: boolean): Uint8Array {
     return bnToU8a(this.valueEncoded, {
       bitLength: this.#byteLength * 8,
       isLe: true
diff --git a/packages/types-codec/src/native/Struct.ts b/packages/types-codec/src/native/Struct.ts
index 19b509a5b5..5d15430c62 100644
--- a/packages/types-codec/src/native/Struct.ts
+++ b/packages/types-codec/src/native/Struct.ts
@@ -75,7 +75,7 @@ function decodeStructFromObject (registry: Registry, [Types, keys]: Definition,
 
       try {
         type = new Type(registry).toRawType();
-      } catch (error) {
+      } catch {
         // ignore
       }
 
diff --git a/packages/types-codec/src/utils/decodeU8a.ts b/packages/types-codec/src/utils/decodeU8a.ts
index c22e3fae3f..0f3071ced4 100644
--- a/packages/types-codec/src/utils/decodeU8a.ts
+++ b/packages/types-codec/src/utils/decodeU8a.ts
@@ -6,7 +6,7 @@ import type { Codec, CodecClass, Registry } from '../types/index.js';
 import { u8aToHex } from '@polkadot/util';
 
 /** @internal */
-function formatFailure (registry: Registry, fn: 'decodeU8a' | 'decodeU8aStruct' | 'decodeU8aVec', result: unknown[], { message }: Error, u8a: Uint8Array, i: number, count: number, Type: CodecClass, key?: string): string {
+function formatFailure (registry: Registry, fn: 'decodeU8a' | 'decodeU8aStruct' | 'decodeU8aVec', _result: unknown[], { message }: Error, u8a: Uint8Array, i: number, count: number, Type: CodecClass, key?: string): string {
   let type = '';
 
   try {
diff --git a/packages/types-create/src/create/class.ts b/packages/types-create/src/create/class.ts
index 7475129332..d85960ba06 100644
--- a/packages/types-create/src/create/class.ts
+++ b/packages/types-create/src/create/class.ts
@@ -70,19 +70,19 @@ function createWithSub (Clazz: { with: (t: string) => CodecClass<Codec> }, value
 }
 
 const infoMapping: Record<TypeDefInfo, (registry: Registry, value: TypeDef) => CodecClass<Codec>> = {
-  [TypeDefInfo.BTreeMap]: (registry: Registry, value: TypeDef): CodecClass<Codec> =>
+  [TypeDefInfo.BTreeMap]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
     createHashMap(BTreeMap, value),
 
-  [TypeDefInfo.BTreeSet]: (registry: Registry, value: TypeDef): CodecClass<Codec> =>
+  [TypeDefInfo.BTreeSet]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
     createWithSub(BTreeSet, value),
 
-  [TypeDefInfo.Compact]: (registry: Registry, value: TypeDef): CodecClass<Codec> =>
+  [TypeDefInfo.Compact]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
     createWithSub(Compact, value),
 
-  [TypeDefInfo.DoNotConstruct]: (registry: Registry, value: TypeDef): CodecClass<Codec> =>
+  [TypeDefInfo.DoNotConstruct]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
     DoNotConstruct.with(value.displayName || value.type),
 
-  [TypeDefInfo.Enum]: (registry: Registry, value: TypeDef): CodecClass<Codec> => {
+  [TypeDefInfo.Enum]: (_registry: Registry, value: TypeDef): CodecClass<Codec> => {
     const subs = getSubDefArray(value);
 
     return Enum.with(
@@ -96,14 +96,14 @@ const infoMapping: Record<TypeDefInfo, (registry: Registry, value: TypeDef) => C
     );
   },
 
-  [TypeDefInfo.HashMap]: (registry: Registry, value: TypeDef): CodecClass<Codec> =>
+  [TypeDefInfo.HashMap]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
     createHashMap(HashMap, value),
 
-  [TypeDefInfo.Int]: (registry: Registry, value: TypeDef): CodecClass<Codec> =>
+  [TypeDefInfo.Int]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
     createInt(Int, value),
 
   // We have circular deps between Linkage & Struct
-  [TypeDefInfo.Linkage]: (registry: Registry, value: TypeDef): CodecClass<Codec> => {
+  [TypeDefInfo.Linkage]: (_registry: Registry, value: TypeDef): CodecClass<Codec> => {
     const type = `Option<${getSubType(value)}>`;
     // eslint-disable-next-line sort-keys
     const Clazz = Struct.with({ previous: type, next: type } as any);
@@ -117,11 +117,10 @@ const infoMapping: Record<TypeDefInfo, (registry: Registry, value: TypeDef) => C
     return Clazz;
   },
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  [TypeDefInfo.Null]: (registry: Registry, _: TypeDef): CodecClass<Codec> =>
+  [TypeDefInfo.Null]: (_registry: Registry, _value: TypeDef): CodecClass<Codec> =>
     Null,
 
-  [TypeDefInfo.Option]: (registry: Registry, value: TypeDef): CodecClass<Codec> => {
+  [TypeDefInfo.Option]: (_registry: Registry, value: TypeDef): CodecClass<Codec> => {
     if (!value.sub || Array.isArray(value.sub)) {
       throw new Error('Expected type information for Option');
     }
@@ -137,20 +136,20 @@ const infoMapping: Record<TypeDefInfo, (registry: Registry, value: TypeDef) => C
   [TypeDefInfo.Plain]: (registry: Registry, value: TypeDef): CodecClass<Codec> =>
     registry.getOrUnknown(value.type),
 
-  [TypeDefInfo.Range]: (registry: Registry, value: TypeDef): CodecClass<Codec> =>
+  [TypeDefInfo.Range]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
     createWithSub(Range, value),
 
-  [TypeDefInfo.RangeInclusive]: (registry: Registry, value: TypeDef): CodecClass<Codec> =>
+  [TypeDefInfo.RangeInclusive]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
     createWithSub(RangeInclusive, value),
 
-  [TypeDefInfo.Result]: (registry: Registry, value: TypeDef): CodecClass<Codec> => {
+  [TypeDefInfo.Result]: (_registry: Registry, value: TypeDef): CodecClass<Codec> => {
     const [Ok, Err] = getTypeClassArray(value);
 
     // eslint-disable-next-line @typescript-eslint/no-use-before-define
     return Result.with({ Err, Ok });
   },
 
-  [TypeDefInfo.Set]: (registry: Registry, value: TypeDef): CodecClass<Codec> =>
+  [TypeDefInfo.Set]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
     CodecSet.with(
       getSubDefArray(value).reduce<Record<string, number>>((result, { index, name }) => {
         result[name as string] = index as number;
@@ -163,16 +162,16 @@ const infoMapping: Record<TypeDefInfo, (registry: Registry, value: TypeDef) => C
   [TypeDefInfo.Si]: (registry: Registry, value: TypeDef): CodecClass<Codec> =>
     getTypeClass(registry, registry.lookup.getTypeDef(value.type as LookupString)),
 
-  [TypeDefInfo.Struct]: (registry: Registry, value: TypeDef): CodecClass<Codec> =>
+  [TypeDefInfo.Struct]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
     Struct.with(getTypeClassMap(value), value.alias),
 
-  [TypeDefInfo.Tuple]: (registry: Registry, value: TypeDef): CodecClass<Codec> =>
+  [TypeDefInfo.Tuple]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
     Tuple.with(getTypeClassArray(value)),
 
-  [TypeDefInfo.UInt]: (registry: Registry, value: TypeDef): CodecClass<Codec> =>
+  [TypeDefInfo.UInt]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
     createInt(UInt, value),
 
-  [TypeDefInfo.Vec]: (registry: Registry, { sub }: TypeDef): CodecClass<Codec> => {
+  [TypeDefInfo.Vec]: (_registry: Registry, { sub }: TypeDef): CodecClass<Codec> => {
     if (!sub || Array.isArray(sub)) {
       throw new Error('Expected type information for vector');
     }
@@ -184,7 +183,7 @@ const infoMapping: Record<TypeDefInfo, (registry: Registry, value: TypeDef) => C
     );
   },
 
-  [TypeDefInfo.VecFixed]: (registry: Registry, { displayName, length, sub }: TypeDef): CodecClass<Codec> => {
+  [TypeDefInfo.VecFixed]: (_registry: Registry, { displayName, length, sub }: TypeDef): CodecClass<Codec> => {
     if (!isNumber(length) || !sub || Array.isArray(sub)) {
       throw new Error('Expected length & type information for fixed vector');
     }
@@ -196,10 +195,10 @@ const infoMapping: Record<TypeDefInfo, (registry: Registry, value: TypeDef) => C
     );
   },
 
-  [TypeDefInfo.WrapperKeepOpaque]: (registry: Registry, value: TypeDef): CodecClass<Codec> =>
+  [TypeDefInfo.WrapperKeepOpaque]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
     createWithSub(WrapperKeepOpaque, value),
 
-  [TypeDefInfo.WrapperOpaque]: (registry: Registry, value: TypeDef): CodecClass<Codec> =>
+  [TypeDefInfo.WrapperOpaque]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
     createWithSub(WrapperOpaque, value)
 };
 
diff --git a/packages/types-create/src/util/encodeTypes.ts b/packages/types-create/src/util/encodeTypes.ts
index a7e536d341..58401acdb7 100644
--- a/packages/types-create/src/util/encodeTypes.ts
+++ b/packages/types-create/src/util/encodeTypes.ts
@@ -96,21 +96,19 @@ const encoders: Record<TypeDefInfo, (registry: Registry, typeDef: TypeDef) => st
   [TypeDefInfo.HashMap]: (registry: Registry, typeDef: TypeDef) =>
     encodeWithParams(registry, typeDef, 'HashMap'),
 
-  [TypeDefInfo.Int]: (registry: Registry, { length = 32 }: TypeDef) =>
+  [TypeDefInfo.Int]: (_registry: Registry, { length = 32 }: TypeDef) =>
     `Int<${length}>`,
 
   [TypeDefInfo.Linkage]: (registry: Registry, typeDef: TypeDef) =>
     encodeWithParams(registry, typeDef, 'Linkage'),
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  [TypeDefInfo.Null]: (registry: Registry, typeDef: TypeDef) =>
+  [TypeDefInfo.Null]: (_registry: Registry, _typeDef: TypeDef) =>
     'Null',
 
   [TypeDefInfo.Option]: (registry: Registry, typeDef: TypeDef) =>
     encodeWithParams(registry, typeDef, 'Option'),
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  [TypeDefInfo.Plain]: (registry: Registry, { displayName, type }: TypeDef) =>
+  [TypeDefInfo.Plain]: (_registry: Registry, { displayName, type }: TypeDef) =>
     displayName || type,
 
   [TypeDefInfo.Range]: (registry: Registry, typeDef: TypeDef) =>
@@ -122,8 +120,7 @@ const encoders: Record<TypeDefInfo, (registry: Registry, typeDef: TypeDef) => st
   [TypeDefInfo.Result]: (registry: Registry, typeDef: TypeDef) =>
     encodeWithParams(registry, typeDef, 'Result'),
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  [TypeDefInfo.Set]: (registry: Registry, { length = 8, sub }: TypeDef): string => {
+  [TypeDefInfo.Set]: (_registry: Registry, { length = 8, sub }: TypeDef): string => {
     if (!Array.isArray(sub)) {
       throw new Error('Unable to encode Set type');
     }
@@ -135,8 +132,7 @@ const encoders: Record<TypeDefInfo, (registry: Registry, typeDef: TypeDef) => st
     });
   },
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  [TypeDefInfo.Si]: (registry: Registry, { lookupName, type }: TypeDef) =>
+  [TypeDefInfo.Si]: (_registry: Registry, { lookupName, type }: TypeDef) =>
     lookupName || type,
 
   [TypeDefInfo.Struct]: (registry: Registry, { alias, sub }: TypeDef): string => {
@@ -163,13 +159,13 @@ const encoders: Record<TypeDefInfo, (registry: Registry, typeDef: TypeDef) => st
     return `(${sub.map((type) => encodeTypeDef(registry, type)).join(',')})`;
   },
 
-  [TypeDefInfo.UInt]: (registry: Registry, { length = 32 }: TypeDef) =>
+  [TypeDefInfo.UInt]: (_registry: Registry, { length = 32 }: TypeDef) =>
     `UInt<${length}>`,
 
   [TypeDefInfo.Vec]: (registry: Registry, typeDef: TypeDef) =>
     encodeWithParams(registry, typeDef, 'Vec'),
 
-  [TypeDefInfo.VecFixed]: (registry: Registry, { length, sub }: TypeDef): string => {
+  [TypeDefInfo.VecFixed]: (_registry: Registry, { length, sub }: TypeDef): string => {
     if (!isNumber(length) || !sub || Array.isArray(sub)) {
       throw new Error('Unable to encode VecFixed type');
     }
diff --git a/packages/types-create/src/util/getTypeDef.ts b/packages/types-create/src/util/getTypeDef.ts
index 2079649b44..3179e1df67 100644
--- a/packages/types-create/src/util/getTypeDef.ts
+++ b/packages/types-create/src/util/getTypeDef.ts
@@ -89,7 +89,6 @@ function _decodeSet (value: TypeDef, details: Record<string, number>, fallbackTy
 }
 
 // decode a struct, set or enum
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 function _decodeStruct (value: TypeDef, type: string, _: string, count: number): TypeDef {
   const parsed = JSON.parse(type) as Record<string, unknown> & { _alias: string, _fallback?: string };
   const keys = Object.keys(parsed);
@@ -114,7 +113,6 @@ function _decodeStruct (value: TypeDef, type: string, _: string, count: number):
 }
 
 // decode a fixed vector, e.g. [u8;32]
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 function _decodeFixedVec (value: TypeDef, type: string, _: string, count: number): TypeDef {
   const max = type.length - 1;
   let index = -1;
@@ -173,7 +171,6 @@ function _decodeTuple (value: TypeDef, _: string, subType: string, count: number
 }
 
 // decode a Int/UInt<bitLength[, name]>
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 function _decodeAnyInt (value: TypeDef, type: string, _: string, clazz: 'Int' | 'UInt'): TypeDef {
   const [strLength, displayName] = type.substring(clazz.length + 1, type.length - 1).split(',');
   const length = parseInt(strLength.trim(), 10);
@@ -196,7 +193,6 @@ function _decodeUInt (value: TypeDef, type: string, subType: string): TypeDef {
   return _decodeAnyInt(value, type, subType, 'UInt');
 }
 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 function _decodeDoNotConstruct (value: TypeDef, type: string, _: string): TypeDef {
   const NAME_LENGTH = 'DoNotConstruct'.length;
 
diff --git a/packages/types/src/extrinsic/ExtrinsicEra.ts b/packages/types/src/extrinsic/ExtrinsicEra.ts
index 31c543ec5f..be4629907f 100644
--- a/packages/types/src/extrinsic/ExtrinsicEra.ts
+++ b/packages/types/src/extrinsic/ExtrinsicEra.ts
@@ -118,8 +118,7 @@ function decodeExtrinsicEra (value: IExtrinsicEra | MortalMethod | MortalEnumDef
  * The ImmortalEra for an extrinsic
  */
 export class ImmortalEra extends Raw {
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  constructor (registry: Registry, value?: AnyU8a) {
+  constructor (registry: Registry, _value?: AnyU8a) {
     // For immortals, we always provide the known value (i.e. treated as a
     // constant no matter how it is constructed - it is a fixed structure)
     super(registry, IMMORTAL_ERA);
@@ -187,8 +186,7 @@ export class MortalEra extends Tuple {
    *     greater than 1 << 12, then it will be a factor of the times greater than 1<<12 that
    *     `period` is.
    */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  public override toU8a (isBare?: boolean): Uint8Array {
+  public override toU8a (_isBare?: boolean): Uint8Array {
     const period = this.period.toNumber();
     const encoded = Math.min(
       15,
diff --git a/packages/types/src/extrinsic/ExtrinsicPayloadUnknown.ts b/packages/types/src/extrinsic/ExtrinsicPayloadUnknown.ts
index 4ed6d68932..d01cf09de2 100644
--- a/packages/types/src/extrinsic/ExtrinsicPayloadUnknown.ts
+++ b/packages/types/src/extrinsic/ExtrinsicPayloadUnknown.ts
@@ -12,7 +12,7 @@ import { Struct } from '@polkadot/types-codec';
  * A default handler for payloads where the version is not known (default throw)
  */
 export class GenericExtrinsicPayloadUnknown extends Struct {
-  constructor (registry: Registry, value?: unknown, { version = 0 }: Partial<ExtrinsicPayloadOptions> = {}) {
+  constructor (registry: Registry, _value?: unknown, { version = 0 }: Partial<ExtrinsicPayloadOptions> = {}) {
     super(registry, {});
 
     throw new Error(`Unsupported extrinsic payload version ${version}`);
diff --git a/packages/types/src/extrinsic/ExtrinsicUnknown.ts b/packages/types/src/extrinsic/ExtrinsicUnknown.ts
index 54487cb03b..04508390a4 100644
--- a/packages/types/src/extrinsic/ExtrinsicUnknown.ts
+++ b/packages/types/src/extrinsic/ExtrinsicUnknown.ts
@@ -14,7 +14,7 @@ import { UNMASK_VERSION } from './constants.js';
  * A default handler for extrinsics where the version is not known (default throw)
  */
 export class GenericExtrinsicUnknown extends Struct {
-  constructor (registry: Registry, value?: unknown, { isSigned = false, version = 0 }: Partial<ExtrinsicOptions> = {}) {
+  constructor (registry: Registry, _value?: unknown, { isSigned = false, version = 0 }: Partial<ExtrinsicOptions> = {}) {
     super(registry, {});
 
     throw new Error(`Unsupported ${isSigned ? '' : 'un'}signed extrinsic version ${version & UNMASK_VERSION}`);
diff --git a/packages/types/src/generic/Call.ts b/packages/types/src/generic/Call.ts
index 89ac66dab3..54b1811fd1 100644
--- a/packages/types/src/generic/Call.ts
+++ b/packages/types/src/generic/Call.ts
@@ -137,7 +137,7 @@ export class GenericCall<A extends AnyTuple = AnyTuple> extends Struct implement
         const c = registry.findMetaCall(decoded.callIndex);
 
         method = `${c.section}.${c.method}`;
-      } catch (error) {
+      } catch {
         // ignore
       }
 
@@ -218,7 +218,7 @@ export class GenericCall<A extends AnyTuple = AnyTuple> extends Struct implement
 
     try {
       call = this.registry.findMetaCall(this.callIndex);
-    } catch (error) {
+    } catch {
       // swallow
     }
 
diff --git a/packages/types/src/metadata/Metadata.ts b/packages/types/src/metadata/Metadata.ts
index 97fc17852e..9c50a8292c 100644
--- a/packages/types/src/metadata/Metadata.ts
+++ b/packages/types/src/metadata/Metadata.ts
@@ -24,7 +24,7 @@ function decodeU8a (registry: Registry, u8a: Uint8Array): MetadataVersioned | Ui
     // when we fail on V9, try to re-parse it as v10...
     try {
       return new MetadataVersioned(registry, u8a);
-    } catch (error) {
+    } catch {
       u8a[VERSION_IDX] = 10;
 
       return u8a;
diff --git a/packages/types/src/metadata/decorate/constants/index.ts b/packages/types/src/metadata/decorate/constants/index.ts
index 2a6f1bb3d0..33e0a76a77 100644
--- a/packages/types/src/metadata/decorate/constants/index.ts
+++ b/packages/types/src/metadata/decorate/constants/index.ts
@@ -10,7 +10,6 @@ import { hexToU8a, lazyMethod, lazyMethods, stringCamelCase } from '@polkadot/ut
 import { objectNameToCamel } from '../util.js';
 
 /** @internal */
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 export function decorateConstants (registry: Registry, { pallets }: MetadataLatest, _version: number): Constants {
   const result: Constants = {};
 
diff --git a/packages/types/src/metadata/decorate/storage/index.ts b/packages/types/src/metadata/decorate/storage/index.ts
index 607d3ec78f..b79425feb3 100644
--- a/packages/types/src/metadata/decorate/storage/index.ts
+++ b/packages/types/src/metadata/decorate/storage/index.ts
@@ -17,7 +17,6 @@ const VERSION_KEY = ':__STORAGE_VERSION__:';
 const VERSION_DOCS = { docs: 'Returns the current pallet version from storage', type: 'u16' };
 
 /** @internal */
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 export function decorateStorage (registry: Registry, { pallets }: MetadataLatest, _metaVersion: number): Storage {
   const result: Storage = getStorage(registry);
 
diff --git a/packages/types/src/metadata/v13/toV14.ts b/packages/types/src/metadata/v13/toV14.ts
index c465dcf377..784ad527ed 100644
--- a/packages/types/src/metadata/v13/toV14.ts
+++ b/packages/types/src/metadata/v13/toV14.ts
@@ -174,7 +174,6 @@ function convertConstants (specs: TypeSpec[], registry: Registry, constants: Mod
  * Apply module-specific type overrides (always be done as part of toV14)
  * @internal
  */
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 function convertErrors (specs: TypeSpec[], registry: Registry, modName: Text, errors: ErrorMetadataV13[], _sectionTypes: OverrideModuleType): PalletErrorMetadataV14 {
   const variants = errors.map(({ docs, name }, index): SiVariant =>
     registry.createTypeUnsafe('SiVariant', [{
@@ -293,7 +292,6 @@ function convertStorage (specs: TypeSpec[], registry: Registry, { items, prefix
 }
 
 /** @internal */
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 function convertExtrinsic (registry: Registry, { signedExtensions, version }: ExtrinsicMetadataV13): ExtrinsicMetadataV14 {
   return registry.createTypeUnsafe('ExtrinsicMetadataV14', [{
     signedExtensions: signedExtensions.map((identifier) => ({
diff --git a/packages/types/src/metadata/v14/toLatest.ts b/packages/types/src/metadata/v14/toLatest.ts
index cc0081faca..7402636985 100644
--- a/packages/types/src/metadata/v14/toLatest.ts
+++ b/packages/types/src/metadata/v14/toLatest.ts
@@ -8,7 +8,6 @@ import type { MetadataLatest, MetadataV14 } from '../../interfaces/metadata/inde
  * Convert the Metadata (which is an alias) to latest
  * @internal
  **/
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-export function toLatest (registry: Registry, v14: MetadataV14, _metaVersion: number): MetadataLatest {
+export function toLatest (_registry: Registry, v14: MetadataV14, _metaVersion: number): MetadataLatest {
   return v14;
 }
diff --git a/packages/types/src/primitive/StorageKey.ts b/packages/types/src/primitive/StorageKey.ts
index 0806954587..f9f8d06357 100644
--- a/packages/types/src/primitive/StorageKey.ts
+++ b/packages/types/src/primitive/StorageKey.ts
@@ -241,7 +241,7 @@ export class StorageKey<A extends AnyTuple = AnyTuple> extends Bytes implements
 
     try {
       this.#args = decodeArgsFromMeta(this.registry, this.toU8a(true), meta);
-    } catch (error) {
+    } catch {
       // ignore...
     }
 
diff --git a/tsconfig.base.json b/tsconfig.base.json
index 3cdcdc45a3..16049a8702 100644
--- a/tsconfig.base.json
+++ b/tsconfig.base.json
@@ -67,7 +67,6 @@
       "@polkadot/types-support/json/*": ["types-support/src/json/*"],
       "@polkadot/types-support/metadata/*": ["types-support/src/metadata/*.ts"],
       "@polkadot/types-support/packageInfo": ["types-support/src/packageInfo.ts"]
-    },
-    "skipLibCheck": true
+    }
   }
  }
diff --git a/yarn.lock b/yarn.lock
index 9f2b425bde..72a8790c7c 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -452,34 +452,34 @@ __metadata:
   languageName: unknown
   linkType: soft
 
-"@polkadot/dev-test@npm:^0.72.9":
-  version: 0.72.9
-  resolution: "@polkadot/dev-test@npm:0.72.9"
+"@polkadot/dev-test@npm:^0.72.15":
+  version: 0.72.15
+  resolution: "@polkadot/dev-test@npm:0.72.15"
   dependencies:
     jsdom: ^21.1.1
     tslib: ^2.5.0
-  checksum: 8bbd4d5417cdc6ed1ca65af5bc8ec5ff6b26f172e02392cf627efc5093a49e9b6cb58f534fed9c8a997d07d69f1173b382f80210ff0bd4cfb8cbc9306e78180d
+  checksum: 827bc33d30dd305cc4e43f3e87aa8aad66d928d5692d9ec2df6f4490ee955cec7780a4e06d70631c7626f81f960b591e5bcd208e144cc8ecb7f60853a8878343
   languageName: node
   linkType: hard
 
-"@polkadot/dev-ts@npm:^0.72.9":
-  version: 0.72.9
-  resolution: "@polkadot/dev-ts@npm:0.72.9"
+"@polkadot/dev-ts@npm:^0.72.15":
+  version: 0.72.15
+  resolution: "@polkadot/dev-ts@npm:0.72.15"
   dependencies:
     json5: ^2.2.3
     tslib: ^2.5.0
     typescript: ^5.0.2
-  checksum: 40756eb32e7e72bd16a1d009ac9e11a0fe513df696ff90552af2ac2cea81d60b084015300d39e85e3006678533779ac03b174623f39f745a1b767cf08167ee49
+  checksum: 9ac0a59b3d7790ee747e6575e2c83a1c97c0aca9573a22c0423c3fdf33f2b61caf03561fe011756deb86a759540826cbbac718bc192298f22149479604bc5b54
   languageName: node
   linkType: hard
 
-"@polkadot/dev@npm:^0.72.9":
-  version: 0.72.9
-  resolution: "@polkadot/dev@npm:0.72.9"
+"@polkadot/dev@npm:^0.72.15":
+  version: 0.72.15
+  resolution: "@polkadot/dev@npm:0.72.15"
   dependencies:
     "@eslint/js": ^8.36.0
-    "@polkadot/dev-test": ^0.72.9
-    "@polkadot/dev-ts": ^0.72.9
+    "@polkadot/dev-test": ^0.72.15
+    "@polkadot/dev-ts": ^0.72.15
     "@rollup/plugin-alias": ^4.0.3
     "@rollup/plugin-commonjs": ^24.0.1
     "@rollup/plugin-dynamic-import-vars": ^2.0.3
@@ -513,7 +513,7 @@ __metadata:
     typescript: ^5.0.2
     webpack: ^5.76.2
     webpack-cli: ^5.0.1
-    webpack-dev-server: ^4.12.0
+    webpack-dev-server: ^4.13.0
     webpack-merge: ^5.8.0
     webpack-subresource-integrity: ^5.2.0-rc.1
     yargs: ^17.7.1
@@ -541,7 +541,7 @@ __metadata:
     polkadot-exec-rollup: scripts/polkadot-exec-rollup.mjs
     polkadot-exec-tsc: scripts/polkadot-exec-tsc.mjs
     polkadot-exec-webpack: scripts/polkadot-exec-webpack.mjs
-  checksum: da6e188058e31d8eb11e8547a4e75ae391b6620ce102f9c640c3acf70173c0d8b9f1e5ee0028858e37600575500d753436b5fd583493a14bedabb27f258f692d
+  checksum: 03ea1b1b886783a2cdaf978c8e51b2ef6f75ddd7e91b4d72dffc2d0efbf7f5c15ed9bb63fc331bbef93ff9df9bb280a3b74c5f1030ce7c6e3dd94be613c270ed
   languageName: node
   linkType: hard
 
@@ -7449,7 +7449,7 @@ fsevents@~2.3.2:
   version: 0.0.0-use.local
   resolution: "root-workspace-0b6124@workspace:."
   dependencies:
-    "@polkadot/dev": ^0.72.9
+    "@polkadot/dev": ^0.72.15
     "@polkadot/typegen": "workspace:packages/typegen"
     "@types/node": ^18.15.3
   languageName: unknown
@@ -8816,9 +8816,9 @@ fsevents@~2.3.2:
   languageName: node
   linkType: hard
 
-"webpack-dev-server@npm:^4.12.0":
-  version: 4.12.0
-  resolution: "webpack-dev-server@npm:4.12.0"
+"webpack-dev-server@npm:^4.13.0":
+  version: 4.13.0
+  resolution: "webpack-dev-server@npm:4.13.0"
   dependencies:
     "@types/bonjour": ^3.5.9
     "@types/connect-history-api-fallback": ^1.3.5
@@ -8857,7 +8857,7 @@ fsevents@~2.3.2:
       optional: true
   bin:
     webpack-dev-server: bin/webpack-dev-server.js
-  checksum: 3e33acb774457ee787038d66c12e04c3e4a9f91bbff7ca143083e4ac1937b1615a1b9e7387ec623df8ebc36f56b3c34742578c09f665fe811b6e38d2e8222a94
+  checksum: 7546dd3b5a05f886209caf3c06265c717dea292e5a1a8e392bb8f1c9c58c7f87cc03daa0b92fa6eb56812c8c88304044bef923642e18c54b0a17ea233c02fdf4
   languageName: node
   linkType: hard