cleanup

src/actions/public/callContract.ts

@@ -10,6 +10,7 @@ import type {
   GetValue,
 } from '../../types'
 import {
+  EncodeFunctionDataArgs,
   decodeFunctionResult,
   encodeFunctionData,
   getContractError,
@@ -55,7 +56,7 @@ export async function callContract<
     abi,
     args,
     functionName,
-  } as any)
+  } as unknown as EncodeFunctionDataArgs<TAbi, TFunctionName>)
   try {
     const { data } = await call(client, {
       data: calldata,

src/index.ts

@@ -264,6 +264,17 @@ export type {
 } from './types'
 
 export type {
+  DecodeAbiArgs,
+  DecodeErrorResultArgs,
+  DecodeFunctionDataArgs,
+  DecodeFunctionResultArgs,
+  DecodeFunctionResultResponse,
+  EncodeAbiArgs,
+  EncodeDeployDataArgs,
+  EncodeErrorResultArgs,
+  EncodeEventTopicsArgs,
+  EncodeFunctionDataArgs,
+  EncodeFunctionResultArgs,
   GetContractAddressOptions,
   GetCreateAddressOptions,
   GetCreate2AddressOptions,

src/utils/abi/decodeAbi.ts

@@ -15,10 +15,15 @@ import { size, slice, trim } from '../data'
 import { hexToBigInt, hexToBool, hexToNumber, hexToString } from '../encoding'
 import { getArrayComponents } from './encodeAbi'
 
+export type DecodeAbiArgs<TParams extends readonly AbiParameter[]> = {
+  data: Hex
+  params: TParams
+}
+
 export function decodeAbi<TParams extends readonly AbiParameter[]>({
   data,
   params,
-}: { data: Hex; params: TParams }) {
+}: DecodeAbiArgs<TParams>) {
   if (data === '0x' && params.length > 0) throw new AbiDecodingZeroDataError()
   if (size(data) % 32 !== 0)
     throw new AbiDecodingDataSizeInvalidError(size(data))

src/utils/abi/decodeDeployData.ts

@@ -9,14 +9,21 @@ import { decodeAbi } from './decodeAbi'
 
 const docsPath = '/docs/contract/decodeDeployData'
 
+export type DecodeDeployDataArgs<TAbi extends Abi = Abi> = {
+  abi: TAbi
+  bytecode: Hex
+  data: Hex
+}
+export type DecodeDeployDataResponse = {
+  args?: readonly unknown[] | undefined
+  bytecode: Hex
+}
+
 export function decodeDeployData<TAbi extends Abi = Abi>({
   abi,
   bytecode,
   data,
-}: { abi: TAbi; bytecode: Hex; data: Hex }): {
-  args?: readonly unknown[] | undefined
-  bytecode: Hex
-} {
+}: DecodeDeployDataArgs<TAbi>): DecodeDeployDataResponse {
   if (data === bytecode) return { bytecode }
 
   const description = abi.find((x) => 'type' in x && x.type === 'constructor')

src/utils/abi/decodeErrorResult.ts

@@ -6,7 +6,9 @@ import { getFunctionSignature } from '../hash'
 import { decodeAbi } from './decodeAbi'
 import { formatAbiItemWithParams } from './formatAbiItemWithParams'
 
-export function decodeErrorResult({ abi, data }: { abi: Abi; data: Hex }) {
+export type DecodeErrorResultArgs = { abi: Abi; data: Hex }
+
+export function decodeErrorResult({ abi, data }: DecodeErrorResultArgs) {
   const signature = slice(data, 0, 4)
   const description = abi.find(
     (x) => signature === getFunctionSignature(formatAbiItemWithParams(x)),

src/utils/abi/decodeFunctionData.ts

@@ -7,7 +7,9 @@ import { getFunctionSignature } from '../hash'
 import { decodeAbi } from './decodeAbi'
 import { formatAbiItemWithParams } from './formatAbiItemWithParams'
 
-export function decodeFunctionData({ abi, data }: { abi: Abi; data: Hex }) {
+export type DecodeFunctionDataArgs = { abi: Abi; data: Hex }
+
+export function decodeFunctionData({ abi, data }: DecodeFunctionDataArgs) {
   const signature = slice(data, 0, 4)
   const description = abi.find(
     (x) => signature === getFunctionSignature(formatAbiItemWithParams(x)),

src/utils/abi/decodeFunctionResult.ts

@@ -13,18 +13,31 @@ import { decodeAbi } from './decodeAbi'
 
 const docsPath = '/docs/contract/decodeFunctionResult'
 
+export type DecodeFunctionResultArgs<
+  TAbi extends Abi | readonly unknown[] = Abi,
+  TFunctionName extends string = any,
+> = {
+  abi: TAbi
+  functionName: ExtractFunctionNameFromAbi<TAbi, TFunctionName>
+  data: Hex
+}
+
+export type DecodeFunctionResultResponse<
+  TAbi extends Abi | readonly unknown[] = Abi,
+  TFunctionName extends string = any,
+> = ExtractResultFromAbi<TAbi, TFunctionName>
+
 export function decodeFunctionResult<
   TAbi extends Abi | readonly unknown[] = Abi,
   TFunctionName extends string = any,
 >({
   abi,
   functionName,
   data,
-}: {
-  abi: TAbi
-  functionName: ExtractFunctionNameFromAbi<TAbi, TFunctionName>
-  data: Hex
-}): ExtractResultFromAbi<TAbi, TFunctionName> {
+}: DecodeFunctionResultArgs<TAbi, TFunctionName>): DecodeFunctionResultResponse<
+  TAbi,
+  TFunctionName
+> {
   const description = (abi as Abi).find(
     (x) => 'name' in x && x.name === functionName,
   )

src/utils/abi/encodeAbi.ts

@@ -14,16 +14,18 @@ import { Hex } from '../../types'
 import { concat, padHex, size } from '../data'
 import { boolToHex, numberToHex, stringToHex } from '../encoding'
 
+export type EncodeAbiArgs<TParams extends readonly AbiParameter[]> = {
+  params: TParams
+  values: AbiParametersToPrimitiveTypes<TParams>
+}
+
 /**
  * @description Encodes a list of primitive values into an ABI-encoded hex value.
  */
 export function encodeAbi<TParams extends readonly AbiParameter[]>({
   params,
   values,
-}: {
-  params: TParams
-  values: AbiParametersToPrimitiveTypes<TParams>
-}) {
+}: EncodeAbiArgs<TParams>) {
   if (params.length !== values.length)
     throw new AbiEncodingLengthMismatchError({
       expectedLength: params.length,

src/utils/abi/encodeDeployData.ts

@@ -10,11 +10,16 @@ import { encodeAbi } from './encodeAbi'
 
 const docsPath = '/docs/contract/encodeDeployData'
 
+export type EncodeDeployDataArgs<TAbi extends Abi = Abi> = {
+  abi: TAbi
+  bytecode: Hex
+} & ExtractConstructorArgsFromAbi<TAbi>
+
 export function encodeDeployData<TAbi extends Abi = Abi>({
   abi,
   args,
   bytecode,
-}: { abi: TAbi; bytecode: Hex } & ExtractConstructorArgsFromAbi<TAbi>) {
+}: EncodeDeployDataArgs<TAbi>) {
   if (!args || args.length === 0) return bytecode
 
   const description = abi.find((x) => 'type' in x && x.type === 'constructor')

src/utils/abi/encodeErrorResult.ts

@@ -13,17 +13,18 @@ import { getAbiItem } from './getAbiItem'
 
 const docsPath = '/docs/contract/encodeErrorResult'
 
+export type EncodeErrorResultArgs<
+  TAbi extends Abi = Abi,
+  TErrorName extends ExtractAbiErrorNames<TAbi> = any,
+> = {
+  abi: TAbi
+  errorName: TErrorName
+} & ExtractErrorArgsFromAbi<TAbi, TErrorName>
+
 export function encodeErrorResult<
   TAbi extends Abi = Abi,
   TErrorName extends ExtractAbiErrorNames<TAbi> = any,
->({
-  abi,
-  errorName,
-  args,
-}: { abi: TAbi; errorName: TErrorName } & ExtractErrorArgsFromAbi<
-  TAbi,
-  TErrorName
->) {
+>({ abi, errorName, args }: EncodeErrorResultArgs<TAbi, TErrorName>) {
   const description = getAbiItem({ abi, name: errorName })
   if (!description) throw new AbiErrorNotFoundError(errorName, { docsPath })
   const definition = formatAbiItemWithParams(description)

src/utils/abi/encodeEventTopics.ts

@@ -16,17 +16,18 @@ import { encodeAbi } from './encodeAbi'
 import { formatAbiItemWithParams } from './formatAbiItemWithParams'
 import { getAbiItem } from './getAbiItem'
 
-export function encodeEventTopics<
+export type EncodeEventTopicsArgs<
   TAbi extends Abi = Abi,
   TEventName extends ExtractAbiEventNames<TAbi> = any,
->({
-  abi,
-  eventName,
-  args,
-}: {
+> = {
   abi: TAbi
   eventName: TEventName
-} & ExtractEventArgsFromAbi<TAbi, TEventName>) {
+} & ExtractEventArgsFromAbi<TAbi, TEventName>
+
+export function encodeEventTopics<
+  TAbi extends Abi = Abi,
+  TEventName extends ExtractAbiEventNames<TAbi> = any,
+>({ abi, eventName, args }: EncodeEventTopicsArgs<TAbi, TEventName>) {
   const abiItem = getAbiItem({ abi, name: eventName })
   if (!abiItem)
     throw new AbiEventNotFoundError(eventName, {

src/utils/abi/encodeFunctionData.ts

@@ -8,17 +8,22 @@ import { encodeAbi } from './encodeAbi'
 import { formatAbiItemWithParams } from './formatAbiItemWithParams'
 import { getAbiItem } from './getAbiItem'
 
+export type EncodeFunctionDataArgs<
+TAbi extends Abi = Abi,
+TFunctionName extends string = any,
+> = {
+  abi: TAbi
+  functionName: ExtractFunctionNameFromAbi<TAbi, TFunctionName>
+} & ExtractArgsFromAbi<TAbi, TFunctionName>
+
 export function encodeFunctionData<
   TAbi extends Abi = Abi,
   TFunctionName extends string = any,
 >({
   abi,
   args,
   functionName,
-}: {
-  abi: TAbi
-  functionName: ExtractFunctionNameFromAbi<TAbi, TFunctionName>
-} & ExtractArgsFromAbi<TAbi, TFunctionName>) {
+}: EncodeFunctionDataArgs<TAbi, TFunctionName>) {
   const description = getAbiItem({ abi, name: functionName })
   if (!description)
     throw new AbiFunctionNotFoundError(functionName, {

src/utils/abi/encodeFunctionResult.ts

@@ -9,18 +9,23 @@ import { encodeAbi } from './encodeAbi'
 
 const docsPath = '/docs/contract/encodeFunctionResult'
 
+export type EncodeFunctionResultArgs<
+  TAbi extends Abi = Abi,
+  TFunctionName extends string = any,
+> = {
+  abi: TAbi
+  functionName: ExtractFunctionNameFromAbi<TAbi, TFunctionName>
+  result?: ExtractResultFromAbi<TAbi, TFunctionName>
+}
+
 export function encodeFunctionResult<
   TAbi extends Abi = Abi,
   TFunctionName extends string = any,
 >({
   abi,
   functionName,
   result,
-}: {
-  abi: TAbi
-  functionName: ExtractFunctionNameFromAbi<TAbi, TFunctionName>
-  result?: ExtractResultFromAbi<TAbi, TFunctionName>
-}) {
+}: EncodeFunctionResultArgs<TAbi, TFunctionName>) {
   const description = abi.find((x) => 'name' in x && x.name === functionName)
   if (!description)
     throw new AbiFunctionNotFoundError(functionName, { docsPath })

src/utils/abi/index.ts

@@ -1,21 +1,34 @@
+export type { DecodeAbiArgs } from './decodeAbi'
 export { decodeAbi } from './decodeAbi'
 
+export type { DecodeErrorResultArgs } from './decodeErrorResult'
 export { decodeErrorResult } from './decodeErrorResult'
 
+export type { DecodeFunctionDataArgs } from './decodeFunctionData'
 export { decodeFunctionData } from './decodeFunctionData'
 
+export type {
+  DecodeFunctionResultArgs,
+  DecodeFunctionResultResponse,
+} from './decodeFunctionResult'
 export { decodeFunctionResult } from './decodeFunctionResult'
 
+export type { EncodeAbiArgs } from './encodeAbi'
 export { encodeAbi } from './encodeAbi'
 
+export type { EncodeDeployDataArgs } from './encodeDeployData'
 export { encodeDeployData } from './encodeDeployData'
 
+export type { EncodeErrorResultArgs } from './encodeErrorResult'
 export { encodeErrorResult } from './encodeErrorResult'
 
+export type { EncodeEventTopicsArgs } from './encodeEventTopics'
 export { encodeEventTopics } from './encodeEventTopics'
 
+export type { EncodeFunctionDataArgs } from './encodeFunctionData'
 export { encodeFunctionData } from './encodeFunctionData'
 
+export type { EncodeFunctionResultArgs } from './encodeFunctionResult'
 export { encodeFunctionResult } from './encodeFunctionResult'
 
 export { formatAbiItemWithArgs } from './formatAbiItemWithArgs'

src/utils/index.ts

@@ -1,3 +1,16 @@
+export type {
+  DecodeAbiArgs,
+  DecodeErrorResultArgs,
+  DecodeFunctionDataArgs,
+  DecodeFunctionResultArgs,
+  DecodeFunctionResultResponse,
+  EncodeAbiArgs,
+  EncodeDeployDataArgs,
+  EncodeErrorResultArgs,
+  EncodeEventTopicsArgs,
+  EncodeFunctionDataArgs,
+  EncodeFunctionResultArgs,
+} from './abi'
 export {
   decodeAbi,
   decodeErrorResult,