fix lint errors

Author: vr16x

src/core/contract/contract.test.ts

@@ -1,7 +1,7 @@
-import { describe, expect, it } from 'vitest';
 import { getAddress } from 'viem';
-import { contract } from './contract';
+import { describe, expect, it } from 'vitest';
 import { publicClient } from '../../test/utils';
+import { contract } from './contract';
 
 // Uniswap V3 Factory on Base Sepolia
 const UNISWAP_V3_FACTORY = getAddress('0x4752ba5DBc23f44D87826276BF6Fd6b1C372aD24');

src/core/encoding/encoding.ts

@@ -3,25 +3,25 @@ import {
   encodeFunctionData,
   encodePacked,
   erc20Abi,
+  type Hex,
   isAddress,
   isHex,
   zeroAddress,
-  type Hex,
 } from 'viem';
 import type { AnyData } from '../types';
 import {
-  ConstraintType,
-  InputParamFetcherType,
-  OutputParamFetcherType,
   type Constraint,
   type ConstraintField,
+  ConstraintType,
   type InputParam,
+  InputParamFetcherType,
   type OutputParam,
+  type OutputParamFetcherType,
   type RuntimeBalanceOfParams,
-  type runtimeERC20AllowanceOfParams,
   type RuntimeNativeBalanceOfParams,
   type RuntimeParamViaCustomStaticCallParams,
   type RuntimeValue,
+  type runtimeERC20AllowanceOfParams,
 } from './types';
 import { toBytes32 } from './utils';
 

src/core/encoding/runtimeAbiEncoding.ts

@@ -18,13 +18,13 @@ import {
   type AbiParameter,
   type AbiParameterToPrimitiveType,
   BaseError,
+  boolToHex,
+  concat,
   type Hex,
   IntegerOutOfRangeError,
   InvalidAbiEncodingTypeError,
   InvalidAddressError,
   InvalidArrayError,
-  boolToHex,
-  concat,
   isAddress,
   numberToHex,
   padHex,
@@ -42,7 +42,10 @@ import {
 } from './types';
 import { isRuntimeComposableValue } from './utils';
 
-type PreparedParam = { dynamic: boolean; data: (Hex | RuntimeValue)[] };
+interface PreparedParam {
+  dynamic: boolean;
+  data: (Hex | RuntimeValue)[];
+}
 type TupleAbiParameter = AbiParameter & { components: readonly AbiParameter[] };
 type Tuple = AbiParameterToPrimitiveType<TupleAbiParameter>;
 
@@ -120,9 +123,9 @@ const encodeBytes = <const param extends AbiParameter>(
   }
 
   // Check for param size which is extracted from type with actual byte size
-  if (bytesSize !== Number.parseInt(paramSize))
+  if (bytesSize !== Number.parseInt(paramSize, 10))
     throw new AbiEncodingBytesSizeMismatchError({
-      expectedSize: Number.parseInt(paramSize),
+      expectedSize: Number.parseInt(paramSize, 10),
       value: value,
     });
 
@@ -203,7 +206,7 @@ const encodeArray = <const param extends AbiParameter>(
   // If there is a length specified, the static array length is validated with its elements count
   if (!dynamic && value.length !== length)
     throw new AbiEncodingArrayLengthMismatchError({
-      expectedLength: length!,
+      expectedLength: length as number,
       givenLength: value.length,
       type: `${param.type}[${length}]`,
     });
@@ -264,11 +267,11 @@ const encodeTuple = <const param extends AbiParameter & { components: readonly A
 
   for (let i = 0; i < param.components.length; i++) {
     const param_ = param.components[i];
-    const index = Array.isArray(value) ? i : param_.name;
+    const index = Array.isArray(value) ? i : (param_.name ?? i);
     // The internal elements will be encoded based on its data type. It will handle the nested data type encoding as well
     const preparedParam = prepareParam({
       param: param_,
-      value: (value as AnyData)[index!] as readonly unknown[],
+      value: (value as AnyData)[index] as readonly unknown[],
     });
     preparedParams.push(preparedParam);
     // If any of the internal element of a tuple is dynamic ? The entire tuple is treated as dynamic tuple
@@ -382,7 +385,7 @@ const prepareParams = <const params extends readonly AbiParameter[]>({
   values,
 }: {
   params: params;
-  values: Array<AnyData>;
+  values: AnyData[];
 }): PreparedParam[] => {
   const preparedParams: PreparedParam[] = [];
   for (let i = 0; i < params.length; i++) {
@@ -465,7 +468,7 @@ const prepareParam = <const param extends AbiParameter>({
   });
 };
 
-export const encodeRuntimeFunctionData = (inputs: AbiParameter[], args: Array<AnyData>) => {
+export const encodeRuntimeFunctionData = (inputs: AbiParameter[], args: AnyData[]) => {
   // If there is no arguments to the function, no need for encoding at all.
   if (!inputs || inputs.length === 0) {
     return ['0x' as Hex];
@@ -482,7 +485,7 @@ export const encodeRuntimeFunctionData = (inputs: AbiParameter[], args: Array<An
   // Prepare the encoding
   const preparedParams = prepareParams({
     params: inputs,
-    values: args as Array<AnyData>,
+    values: args as AnyData[],
   });
 
   // Encoding the prepared data types based on static and dynamic natrue

src/core/encoding/types.ts

@@ -8,17 +8,17 @@ import type { AnyData } from '../types';
  * paramType: The type of the param. This field is optional and it is introduced in the composability version 1.1.0
  * If earlier versions are used, this field may not not present.
  */
-export type InputParam = {
+export interface InputParam {
   paramType?: InputParamType;
   fetcherType: InputParamFetcherType;
   paramData: string;
   constraints: Constraint[];
-};
+}
 
-export type OutputParam = {
+export interface OutputParam {
   fetcherType: OutputParamFetcherType;
   paramData: string;
-};
+}
 
 /**
  * paramType: The type of the param.
@@ -66,10 +66,10 @@ export type OutputParamFetcherType =
 export type ConstraintType = (typeof ConstraintType)[keyof typeof ConstraintType];
 export type InputParamType = (typeof InputParamType)[keyof typeof InputParamType];
 
-export type Constraint = {
+export interface Constraint {
   constraintType: ConstraintType;
   referenceData: string;
-};
+}
 
 /**
  * Base composable call type
@@ -81,52 +81,52 @@ export type Constraint = {
  * Since Composability version 1.1.0, to and value are not required
  * as they are replaced by the input params with according types (TARGET, VALUE)
  */
-export type BaseComposableCall = {
+export interface BaseComposableCall {
   to?: Address;
   value?: bigint;
   functionSig: string;
   inputParams: InputParam[];
   outputParams: OutputParam[];
-};
+}
 
-export type ConstraintField = {
+export interface ConstraintField {
   type: ConstraintType;
   value: AnyData; // type any is being implicitly used. The appropriate value validation happens in the runtime function
-};
+}
 
-export type RuntimeParamViaCustomStaticCallParams = {
+export interface RuntimeParamViaCustomStaticCallParams {
   targetContractAddress: Address;
   functionAbi: Abi;
-  args: Array<AnyData>;
+  args: AnyData[];
   functionName?: string;
   constraints?: ConstraintField[];
-};
+}
 
-export type runtimeERC20AllowanceOfParams = {
+export interface runtimeERC20AllowanceOfParams {
   owner: Address;
   spender: Address;
   tokenAddress: Address;
   constraints?: ConstraintField[];
-};
+}
 
-export type RuntimeBalanceOfParams = {
+export interface RuntimeBalanceOfParams {
   targetAddress: Address;
   tokenAddress: Address;
   constraints?: ConstraintField[];
-};
+}
 
 export type RuntimeNativeBalanceOfParams = Omit<RuntimeBalanceOfParams, 'tokenAddress'>;
 
-export type FunctionContext = {
+export interface FunctionContext {
   inputs: readonly AbiParameter[];
   outputs: readonly AbiParameter[];
   name: string;
   functionType: 'read' | 'write';
   functionSig: string;
-};
+}
 
-export type RuntimeValue = {
+export interface RuntimeValue {
   isRuntime: boolean;
   inputParams: InputParam[];
   outputParams: OutputParam[];
-};
+}

src/core/encoding/utils.ts

@@ -1,4 +1,4 @@
-import { isAddress, isHex, padHex, toHex, type Address, type Hex } from 'viem';
+import { type Address, type Hex, isAddress, isHex, padHex, toHex } from 'viem';
 import type { AnyData } from '../types';
 
 export const toBytes32 = (value: bigint | boolean | Address | Hex | number): Hex => {

src/core/index.ts

@@ -1,4 +1,4 @@
-export * from './token';
 export * from './contract';
 export * from './encoding';
+export * from './token';
 export * from './types';

src/core/token/token.test.ts

@@ -1,7 +1,7 @@
-import { describe, expect, it } from 'vitest';
 import { getAddress } from 'viem';
-import { ERC20Token, NativeToken } from './token';
+import { describe, expect, it } from 'vitest';
 import { publicClient } from '../../test/utils';
+import { ERC20Token, NativeToken } from './token';
 
 // Well-known Base Sepolia token addresses
 const USDC_ADDRESS = getAddress('0x036CbD53842c5426634e7929541eC2318f3dCF7e');

src/core/token/token.ts

@@ -1,5 +1,5 @@
-import { erc20Abi } from 'viem';
 import type { Address, Chain, PublicClient, Transport } from 'viem';
+import { erc20Abi } from 'viem';
 import type { ERC20TokenInstance, NativeTokenInstance } from './types';
 
 export function ERC20Token<

src/core/token/types.ts

@@ -1,9 +1,9 @@
-import { erc20Abi } from 'viem';
 import type {
   Address,
   ContractFunctionArgs,
   ContractFunctionName,
   ContractFunctionReturnType,
+  erc20Abi,
 } from 'viem';
 
 export type ERC20Abi = typeof erc20Abi;

src/core/types.ts

@@ -1,2 +1,2 @@
-// biome-ignore lint/suspicious/noExplicitAny: <explanation>
+// biome-ignore lint/suspicious/noExplicitAny: intentional escape hatch for ABI-encoded runtime values where types are unknown at compile time
 export type AnyData = any;