Function encodeEventTopics

src/utils/abi/encodeEventTopics.ts:94–144

(
  parameters: EncodeEventTopicsParameters<abi, eventName>,
)

  | ErrorType

export function encodeEventTopics<
  const abi extends Abi | readonly unknown[],
  eventName extends ContractEventName<abi> | undefined = undefined,
>(
  parameters: EncodeEventTopicsParameters<abi, eventName>,
): EncodeEventTopicsReturnType<abi, eventName> {
  const { abi, eventName, args } = parameters as EncodeEventTopicsParameters

  let abiItem = abi[0]
  if (eventName) {
    const item = getAbiItem({ abi, name: eventName })
    if (!item) throw new AbiEventNotFoundError(eventName, { docsPath })
    abiItem = item
  }

  if (abiItem.type !== 'event')
    throw new AbiEventNotFoundError(undefined, { docsPath })

  let topics: (Hex | Hex[] | null)[] = []
  if (args && 'inputs' in abiItem) {
    const indexedInputs = abiItem.inputs?.filter(
      (param) => 'indexed' in param && param.indexed,
    )
    const args_ = Array.isArray(args)
      ? args
      : Object.values(args).length > 0
        ? (indexedInputs?.map((x: any) => (args as any)[x.name]) ?? [])
        : []

    if (args_.length > 0) {
      topics =
        indexedInputs?.map((param, i) => {
          if (Array.isArray(args_[i]))
            return args_[i].map((_: any, j: number) =>
              encodeArg({ param, value: args_[i][j] }),
            )
          return typeof args_[i] !== 'undefined' && args_[i] !== null
            ? encodeArg({ param, value: args_[i] })
            : null
        }) ?? []
    }
  }
  // Anonymous events are not identified by a signature topic, so the event
  // selector must not be prepended.
  if (abiItem.anonymous)
    return topics as EncodeEventTopicsReturnType<abi, eventName>

  const definition = formatAbiItem(abiItem)
  const signature = toEventSelector(definition as EventDefinition)
  return [signature, ...topics] as EncodeEventTopicsReturnType<abi, eventName>
}

export type EncodeArgErrorType =
  | Keccak256ErrorType