viem 0.0.0-main.20240103T193024 → 0.0.0-main.20240103T193934

package/utils/abi/encodeFunctionData.ts

@@ -1,13 +1,12 @@
-import type { Abi } from 'abitype'
+import type { Abi, AbiStateMutability, ExtractAbiFunctions } from 'abitype'
 
 import {
   AbiFunctionNotFoundError,
   type AbiFunctionNotFoundErrorType,
 } from '../../errors/abi.js'
 import type {
-  AbiItem,
-  GetFunctionArgs,
-  InferFunctionName,
+  ContractFunctionArgs,
+  ContractFunctionName,
 } from '../../types/contract.js'
 import { type ConcatHexErrorType, concatHex } from '../data/concat.js'
 import {
@@ -16,28 +15,55 @@ import {
 } from '../hash/getFunctionSelector.js'
 
 import type { ErrorType } from '../../errors/utils.js'
+import type { Hex } from '../../types/misc.js'
+import type { IsNarrowable, UnionEvaluate } from '../../types/utils.js'
 import {
   type EncodeAbiParametersErrorType,
   encodeAbiParameters,
 } from './encodeAbiParameters.js'
 import { type FormatAbiItemErrorType, formatAbiItem } from './formatAbiItem.js'
-import {
-  type GetAbiItemErrorType,
-  type GetAbiItemParameters,
-  getAbiItem,
-} from './getAbiItem.js'
+import { type GetAbiItemErrorType, getAbiItem } from './getAbiItem.js'
+
+const docsPath = '/docs/contract/encodeFunctionData'
 
 export type EncodeFunctionDataParameters<
-  TAbi extends Abi | readonly unknown[] = Abi,
-  TFunctionName extends string | undefined = string,
-  _FunctionName = InferFunctionName<TAbi, TFunctionName>,
+  abi extends Abi | readonly unknown[] = Abi,
+  functionName extends
+    | ContractFunctionName<abi>
+    | undefined = ContractFunctionName<abi>,
+  ///
+  hasFunctions = abi extends Abi
+    ? Abi extends abi
+      ? true
+      : [ExtractAbiFunctions<abi>] extends [never]
+        ? false
+        : true
+    : true,
+  allArgs = ContractFunctionArgs<
+    abi,
+    AbiStateMutability,
+    functionName extends ContractFunctionName<abi>
+      ? functionName
+      : ContractFunctionName<abi>
+  >,
+  allFunctionNames = ContractFunctionName<abi>,
 > = {
-  functionName?: _FunctionName
-} & (TFunctionName extends string
-  ? { abi: TAbi } & GetFunctionArgs<TAbi, TFunctionName>
-  : _FunctionName extends string
-    ? { abi: [TAbi[number]] } & GetFunctionArgs<TAbi, _FunctionName>
-    : never)
+  abi: abi
+} & UnionEvaluate<
+  IsNarrowable<abi, Abi> extends true
+    ? abi['length'] extends 1
+      ? { functionName?: functionName | allFunctionNames }
+      : { functionName: functionName | allFunctionNames }
+    : { functionName?: functionName | allFunctionNames }
+> &
+  UnionEvaluate<
+    readonly [] extends allArgs
+      ? { args?: allArgs | undefined }
+      : { args: allArgs }
+  > &
+  (hasFunctions extends true ? unknown : never)
+
+export type EncodeFunctionDataReturnType = Hex
 
 export type EncodeFunctionDataErrorType =
   | AbiFunctionNotFoundErrorType
@@ -49,36 +75,32 @@ export type EncodeFunctionDataErrorType =
   | ErrorType
 
 export function encodeFunctionData<
-  const TAbi extends Abi | readonly unknown[],
-  TFunctionName extends string | undefined = undefined,
->({
-  abi,
-  args,
-  functionName,
-}: EncodeFunctionDataParameters<TAbi, TFunctionName>) {
-  let abiItem = abi[0] as AbiItem
+  const abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi> | undefined = undefined,
+>(
+  parameters: EncodeFunctionDataParameters<abi, functionName>,
+): EncodeFunctionDataReturnType {
+  const { abi, args, functionName } = parameters as EncodeFunctionDataParameters
+
+  let abiItem = abi[0]
   if (functionName) {
-    abiItem = getAbiItem({
+    const item = getAbiItem({
       abi,
       args,
       name: functionName,
-    } as GetAbiItemParameters)
-    if (!abiItem)
-      throw new AbiFunctionNotFoundError(functionName, {
-        docsPath: '/docs/contract/encodeFunctionData',
-      })
+    })
+    if (!item) throw new AbiFunctionNotFoundError(functionName, { docsPath })
+    abiItem = item
   }
 
   if (abiItem.type !== 'function')
-    throw new AbiFunctionNotFoundError(undefined, {
-      docsPath: '/docs/contract/encodeFunctionData',
-    })
+    throw new AbiFunctionNotFoundError(undefined, { docsPath })
 
   const definition = formatAbiItem(abiItem)
   const signature = getFunctionSelector(definition)
   const data =
     'inputs' in abiItem && abiItem.inputs
-      ? encodeAbiParameters(abiItem.inputs, (args ?? []) as readonly unknown[])
+      ? encodeAbiParameters(abiItem.inputs, args ?? [])
       : undefined
   return concatHex([signature, data ?? '0x'])
 }

package/utils/abi/encodeFunctionResult.ts

@@ -1,42 +1,61 @@
-import type { Abi } from 'abitype'
+import type { Abi, AbiStateMutability, ExtractAbiFunctions } from 'abitype'
 
 import {
   AbiFunctionNotFoundError,
   AbiFunctionOutputsNotFoundError,
 } from '../../errors/abi.js'
 import type {
-  AbiItem,
-  ContractFunctionResult,
-  InferFunctionName,
+  ContractFunctionName,
+  ContractFunctionReturnType,
 } from '../../types/contract.js'
 
 import type { ErrorType } from '../../errors/utils.js'
+import type { Hex } from '../../types/misc.js'
+import type { IsNarrowable, UnionEvaluate } from '../../types/utils.js'
 import {
   type EncodeAbiParametersErrorType,
   encodeAbiParameters,
 } from './encodeAbiParameters.js'
-import {
-  type GetAbiItemErrorType,
-  type GetAbiItemParameters,
-  getAbiItem,
-} from './getAbiItem.js'
+import { type GetAbiItemErrorType, getAbiItem } from './getAbiItem.js'
 
 const docsPath = '/docs/contract/encodeFunctionResult'
 
 export type EncodeFunctionResultParameters<
-  TAbi extends Abi | readonly unknown[] = Abi,
-  TFunctionName extends string | undefined = string,
-  _FunctionName = InferFunctionName<TAbi, TFunctionName>,
+  abi extends Abi | readonly unknown[] = Abi,
+  functionName extends
+    | ContractFunctionName<abi>
+    | undefined = ContractFunctionName<abi>,
+  ///
+  hasFunctions = abi extends Abi
+    ? Abi extends abi
+      ? true
+      : [ExtractAbiFunctions<abi>] extends [never]
+        ? false
+        : true
+    : true,
+  allFunctionNames = ContractFunctionName<abi>,
 > = {
-  functionName?: _FunctionName
-} & (TFunctionName extends string
-  ? { abi: TAbi; result?: ContractFunctionResult<TAbi, TFunctionName> }
-  : _FunctionName extends string
-    ? {
-        abi: [TAbi[number]]
-        result?: ContractFunctionResult<TAbi, _FunctionName>
-      }
-    : never)
+  abi: abi
+  result?:
+    | ContractFunctionReturnType<
+        abi,
+        AbiStateMutability,
+        functionName extends ContractFunctionName<abi>
+          ? functionName
+          : ContractFunctionName<abi>,
+        never // allow all args. required for overloads to work.
+      >
+    | undefined
+} & UnionEvaluate<
+  IsNarrowable<abi, Abi> extends true
+    ? abi['length'] extends 1
+      ? { functionName?: functionName | allFunctionNames }
+      : { functionName: functionName | allFunctionNames }
+    : { functionName?: functionName | allFunctionNames }
+> &
+  (hasFunctions extends true ? unknown : never)
+
+export type EncodeFunctionResultReturnType = Hex
 
 export type EncodeFunctionResultErrorType =
   | AbiFunctionOutputsNotFoundError
@@ -46,29 +65,23 @@ export type EncodeFunctionResultErrorType =
   | ErrorType
 
 export function encodeFunctionResult<
-  const TAbi extends Abi | readonly unknown[],
-  TFunctionName extends string | undefined = undefined,
->({
-  abi,
-  functionName,
-  result,
-}: EncodeFunctionResultParameters<TAbi, TFunctionName>) {
-  let abiItem = abi[0] as AbiItem
+  const abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi> | undefined = undefined,
+>(
+  parameters: EncodeFunctionResultParameters<abi, functionName>,
+): EncodeFunctionResultReturnType {
+  const { abi, functionName, result } =
+    parameters as EncodeFunctionResultParameters
+
+  let abiItem = abi[0]
   if (functionName) {
-    abiItem = getAbiItem({
-      abi,
-      name: functionName,
-    } as GetAbiItemParameters)
-    if (!abiItem)
-      throw new AbiFunctionNotFoundError(functionName, {
-        docsPath: '/docs/contract/encodeFunctionResult',
-      })
+    const item = getAbiItem({ abi, name: functionName })
+    if (!item) throw new AbiFunctionNotFoundError(functionName, { docsPath })
+    abiItem = item
   }
 
   if (abiItem.type !== 'function')
-    throw new AbiFunctionNotFoundError(undefined, {
-      docsPath: '/docs/contract/encodeFunctionResult',
-    })
+    throw new AbiFunctionNotFoundError(undefined, { docsPath })
 
   if (!abiItem.outputs)
     throw new AbiFunctionOutputsNotFoundError(abiItem.name, { docsPath })

package/utils/abi/getAbiItem.ts

@@ -4,10 +4,13 @@ import { AbiItemAmbiguityError } from '../../errors/abi.js'
 import type { ErrorType } from '../../errors/utils.js'
 import type {
   AbiItem,
-  GetFunctionArgs,
-  InferItemName,
+  AbiItemArgs,
+  AbiItemName,
+  ExtractAbiItemForArgs,
+  Widen,
 } from '../../types/contract.js'
 import type { Hex } from '../../types/misc.js'
+import type { UnionEvaluate } from '../../types/utils.js'
 import { type IsHexErrorType, isHex } from '../../utils/data/isHex.js'
 import { getEventSelector } from '../../utils/hash/getEventSelector.js'
 import {
@@ -17,21 +20,37 @@ import {
 import { type IsAddressErrorType, isAddress } from '../address/isAddress.js'
 
 export type GetAbiItemParameters<
-  TAbi extends Abi | readonly unknown[] = Abi,
-  TItemName extends string = string,
+  abi extends Abi | readonly unknown[] = Abi,
+  name extends AbiItemName<abi> = AbiItemName<abi>,
+  args extends AbiItemArgs<abi, name> | undefined = AbiItemArgs<abi, name>,
+  ///
+  allArgs = AbiItemArgs<abi, name>,
+  allNames = AbiItemName<abi>,
 > = {
-  abi: TAbi
-  name: InferItemName<TAbi, TItemName> | Hex
-} & Partial<GetFunctionArgs<TAbi, TItemName>>
-
-export type GetAbiItemReturnType<
-  TAbi extends Abi | readonly unknown[] = Abi,
-  TItemName extends string = string,
-> = Extract<
-  TAbi[number],
-  {
-    name: TItemName
-  }
+  abi: abi
+  name:
+    | allNames // show all options
+    | (name extends allNames ? name : never) // infer value
+    | Hex // function selector
+} & UnionEvaluate<
+  readonly [] extends allArgs
+    ? {
+        args?:
+          | allArgs // show all options
+          // infer value, widen inferred value of `args` conditionally to match `allArgs`
+          | (abi extends Abi
+              ? args extends allArgs
+                ? Widen<args>
+                : never
+              : never)
+          | undefined
+      }
+    : {
+        args?:
+          | allArgs // show all options
+          | (Widen<args> & (args extends allArgs ? unknown : never)) // infer value, widen inferred value of `args` match `allArgs` (e.g. avoid union `args: readonly [123n] | readonly [bigint]`)
+          | undefined
+      }
 >
 
 export type GetAbiItemErrorType =
@@ -40,19 +59,30 @@ export type GetAbiItemErrorType =
   | GetFunctionSelectorErrorType
   | ErrorType
 
+export type GetAbiItemReturnType<
+  abi extends Abi | readonly unknown[] = Abi,
+  name extends AbiItemName<abi> = AbiItemName<abi>,
+  args extends AbiItemArgs<abi, name> | undefined = AbiItemArgs<abi, name>,
+> = abi extends Abi
+  ? Abi extends abi
+    ? AbiItem | undefined
+    : ExtractAbiItemForArgs<
+        abi,
+        name,
+        args extends AbiItemArgs<abi, name> ? args : AbiItemArgs<abi, name>
+      >
+  : AbiItem | undefined
+
 export function getAbiItem<
-  const TAbi extends Abi | readonly unknown[],
-  TItemName extends string,
->({
-  abi,
-  args = [],
-  name,
-}: GetAbiItemParameters<TAbi, TItemName>): GetAbiItemReturnType<
-  TAbi,
-  TItemName
-> {
-  const isSelector = isHex(name, { strict: false })
+  const abi extends Abi | readonly unknown[],
+  name extends AbiItemName<abi>,
+  args extends AbiItemArgs<abi, name> | undefined = undefined,
+>(
+  parameters: GetAbiItemParameters<abi, name, args>,
+): GetAbiItemReturnType<abi, name, args> {
+  const { abi, args = [], name } = parameters as unknown as GetAbiItemParameters
 
+  const isSelector = isHex(name, { strict: false })
   const abiItems = (abi as Abi).filter((abiItem) => {
     if (isSelector) {
       if (abiItem.type === 'function')
@@ -63,23 +93,26 @@ export function getAbiItem<
     return 'name' in abiItem && abiItem.name === name
   })
 
-  if (abiItems.length === 0) return undefined as any
-  if (abiItems.length === 1) return abiItems[0] as any
+  if (abiItems.length === 0)
+    return undefined as GetAbiItemReturnType<abi, name, args>
+  if (abiItems.length === 1)
+    return abiItems[0] as GetAbiItemReturnType<abi, name, args>
 
   let matchedAbiItem: AbiItem | undefined = undefined
   for (const abiItem of abiItems) {
     if (!('inputs' in abiItem)) continue
     if (!args || args.length === 0) {
-      if (!abiItem.inputs || abiItem.inputs.length === 0) return abiItem as any
+      if (!abiItem.inputs || abiItem.inputs.length === 0)
+        return abiItem as GetAbiItemReturnType<abi, name, args>
       continue
     }
     if (!abiItem.inputs) continue
     if (abiItem.inputs.length === 0) continue
     if (abiItem.inputs.length !== args.length) continue
-    const matched = (args as readonly unknown[]).every((arg, index) => {
+    const matched = args.every((arg, index) => {
       const abiParameter = 'inputs' in abiItem && abiItem.inputs![index]
       if (!abiParameter) return false
-      return isArgOfType(arg, abiParameter as AbiParameter)
+      return isArgOfType(arg, abiParameter)
     })
     if (matched) {
       // Check for ambiguity against already matched parameters (e.g. `address` vs `bytes20`).
@@ -111,8 +144,8 @@ export function getAbiItem<
   }
 
   if (matchedAbiItem)
-    return matchedAbiItem as GetAbiItemReturnType<TAbi, TItemName>
-  return abiItems[0] as GetAbiItemReturnType<TAbi, TItemName>
+    return matchedAbiItem as GetAbiItemReturnType<abi, name, args>
+  return abiItems[0] as GetAbiItemReturnType<abi, name, args>
 }
 
 export type IsArgOfTypeErrorType = IsAddressErrorType | ErrorType
@@ -177,7 +210,7 @@ export function isArgOfType(arg: unknown, abiParameter: AbiParameter): boolean {
 export function getAmbiguousTypes(
   sourceParameters: readonly AbiParameter[],
   targetParameters: readonly AbiParameter[],
-  args: readonly unknown[],
+  args: AbiItemArgs,
 ): AbiParameter['type'][] | undefined {
   for (const parameterIndex in sourceParameters) {
     const sourceParameter = sourceParameters[parameterIndex]

package/utils/abi/parseEventLogs.ts

@@ -0,0 +1,129 @@
+import type { Abi } from 'abitype'
+import type { ErrorType } from '../../errors/utils.js'
+import {
+  AbiEventSignatureNotFoundError,
+  DecodeLogDataMismatch,
+  DecodeLogTopicsMismatch,
+  type RpcLog,
+} from '../../index.js'
+import type { ContractEventName } from '../../types/contract.js'
+import type { Log } from '../../types/log.js'
+import {
+  type DecodeEventLogErrorType,
+  decodeEventLog,
+} from './decodeEventLog.js'
+
+export type ParseEventLogsParameters<
+  abi extends Abi | readonly unknown[] = Abi,
+  eventName extends
+    | ContractEventName<abi>
+    | ContractEventName<abi>[]
+    | undefined = ContractEventName<abi>,
+  strict extends boolean | undefined = boolean | undefined,
+> = {
+  /** Contract ABI. */
+  abi: abi
+  /** Contract event. */
+  eventName?:
+    | eventName
+    | ContractEventName<abi>
+    | ContractEventName<abi>[]
+    | undefined
+  /** List of logs. */
+  logs: (Log | RpcLog)[]
+  strict?: strict | boolean | undefined
+}
+
+export type ParseEventLogsReturnType<
+  abi extends Abi | readonly unknown[] = Abi,
+  eventName extends
+    | ContractEventName<abi>
+    | ContractEventName<abi>[]
+    | undefined = ContractEventName<abi>,
+  strict extends boolean | undefined = boolean | undefined,
+  ///
+  derivedEventName extends
+    | ContractEventName<abi>
+    | undefined = eventName extends ContractEventName<abi>[]
+    ? eventName[number]
+    : eventName,
+> = Log<bigint, number, false, undefined, strict, abi, derivedEventName>[]
+
+export type ParseEventLogsErrorType = DecodeEventLogErrorType | ErrorType
+
+/**
+ * Extracts & decodes logs matching the provided signature(s) (`abi` + optional `eventName`)
+ * from a set of opaque logs.
+ *
+ * @param parameters - {@link ParseEventLogsParameters}
+ * @returns The logs. {@link ParseEventLogsReturnType}
+ *
+ * @example
+ * import { createClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { parseEventLogs } from 'viem/op-stack'
+ *
+ * const client = createClient({
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ *
+ * const receipt = await getTransactionReceipt(client, {
+ *   hash: '0xec23b2ba4bc59ba61554507c1b1bc91649e6586eb2dd00c728e8ed0db8bb37ea',
+ * })
+ *
+ * const logs = parseEventLogs({ logs: receipt.logs })
+ * // [{ args: { ... }, eventName: 'TransactionDeposited', ... }, ...]
+ */
+export function parseEventLogs<
+  abi extends Abi | readonly unknown[],
+  strict extends boolean | undefined = true,
+  eventName extends
+    | ContractEventName<abi>
+    | ContractEventName<abi>[]
+    | undefined = undefined,
+>({
+  abi,
+  eventName,
+  logs,
+  strict = true,
+}: ParseEventLogsParameters<abi, eventName, strict>): ParseEventLogsReturnType<
+  abi,
+  eventName,
+  strict
+> {
+  return logs
+    .map((log) => {
+      try {
+        const event = decodeEventLog({
+          ...log,
+          abi,
+          strict,
+        })
+        if (eventName && !eventName.includes(event.eventName!)) return null
+        return { ...event, ...log }
+      } catch (err) {
+        let eventName
+        let isUnnamed
+
+        if (err instanceof AbiEventSignatureNotFoundError) return null
+        if (
+          err instanceof DecodeLogDataMismatch ||
+          err instanceof DecodeLogTopicsMismatch
+        ) {
+          // If strict mode is on, and log data/topics do not match event definition, skip.
+          if (strict) return null
+          eventName = err.abiItem.name
+          isUnnamed = err.abiItem.inputs?.some((x) => !('name' in x && x.name))
+        }
+
+        // Set args to empty if there is an error decoding (e.g. indexed/non-indexed params mismatch).
+        return { ...log, args: isUnnamed ? [] : {}, eventName }
+      }
+    })
+    .filter(Boolean) as unknown as ParseEventLogsReturnType<
+    abi,
+    eventName,
+    strict
+  >
+}

package/utils/buildRequest.ts

@@ -51,35 +51,14 @@ import {
   type UserRejectedRequestErrorType,
 } from '../errors/rpc.js'
 import type { ErrorType } from '../errors/utils.js'
+import type {
+  EIP1193RequestFn,
+  EIP1193RequestOptions,
+} from '../types/eip1193.js'
 import type { CreateBatchSchedulerErrorType } from './promise/createBatchScheduler.js'
 import { type WithRetryErrorType, withRetry } from './promise/withRetry.js'
 import type { GetSocketErrorType } from './rpc.js'
 
-export type IsDeterministicErrorType = ErrorType
-
-export const isDeterministicError = (error: Error) => {
-  if ('code' in error)
-    return (
-      error.code !== -1 &&
-      error.code !== -32004 &&
-      error.code !== -32005 &&
-      error.code !== -32042 &&
-      error.code !== -32603
-    )
-  if (error instanceof HttpRequestError && error.status)
-    return (
-      error.status !== 403 &&
-      error.status !== 408 &&
-      error.status !== 413 &&
-      error.status !== 429 &&
-      error.status !== 500 &&
-      error.status !== 502 &&
-      error.status !== 503 &&
-      error.status !== 504
-    )
-  return false
-}
-
 export type RequestErrorType =
   | ChainDisconnectedErrorType
   | CreateBatchSchedulerErrorType
@@ -110,20 +89,16 @@ export type RequestErrorType =
   | WithRetryErrorType
   | ErrorType
 
-export function buildRequest<TRequest extends (args: any) => Promise<any>>(
-  request: TRequest,
-  {
-    retryDelay = 150,
-    retryCount = 3,
-  }: {
-    // The base delay (in ms) between retries.
-    retryDelay?: number
-    // The max number of times to retry.
-    retryCount?: number
-  } = {},
-) {
-  return (async (args: any) =>
-    withRetry(
+export function buildRequest<request extends (args: any) => Promise<any>>(
+  request: request,
+  options: EIP1193RequestOptions = {},
+): EIP1193RequestFn {
+  return async (args, overrideOptions = {}) => {
+    const { retryDelay = 150, retryCount = 3 } = {
+      ...options,
+      ...overrideOptions,
+    }
+    return withRetry(
       async () => {
         try {
           return await request(args)
@@ -208,7 +183,37 @@ export function buildRequest<TRequest extends (args: any) => Promise<any>>(
           return ~~(1 << count) * retryDelay
         },
         retryCount,
-        shouldRetry: ({ error }) => !isDeterministicError(error),
+        shouldRetry: ({ error }) => shouldRetry(error),
       },
-    )) as TRequest
+    )
+  }
+}
+
+export function shouldRetry(error: Error) {
+  if ('code' in error && typeof error.code === 'number') {
+    if (error.code === -1) return true // Unknown error
+    if (error.code === LimitExceededRpcError.code) return true
+    if (error.code === InternalRpcError.code) return true
+    return false
+  }
+  if (error instanceof HttpRequestError && error.status) {
+    // Forbidden
+    if (error.status === 403) return true
+    // Request Timeout
+    if (error.status === 408) return true
+    // Request Entity Too Large
+    if (error.status === 413) return true
+    // Too Many Requests
+    if (error.status === 429) return true
+    // Internal Server Error
+    if (error.status === 500) return true
+    // Bad Gateway
+    if (error.status === 502) return true
+    // Service Unavailable
+    if (error.status === 503) return true
+    // Gateway Timeout
+    if (error.status === 504) return true
+    return false
+  }
+  return true
 }

package/utils/ccip.ts

@@ -10,7 +10,6 @@ import {
 } from '../errors/ccip.js'
 import { HttpRequestError } from '../errors/request.js'
 import type { Chain } from '../types/chain.js'
-import type { GetErrorArgs } from '../types/contract.js'
 import type { Hex } from '../types/misc.js'
 
 import type { Client } from '../clients/createClient.js'
@@ -67,10 +66,7 @@ export async function offchainLookup<TChain extends Chain | undefined>(
   const { args } = decodeErrorResult({
     data,
     abi: [offchainLookupAbiItem],
-  }) as unknown as GetErrorArgs<
-    [typeof offchainLookupAbiItem],
-    'OffchainLookup'
-  >
+  })
   const [sender, urls, callData, callbackSelector, extraData] = args
 
   try {