@chainlink/ccip-sdk 0.0.0 → 0.90.0

package/src/evm/abi/TokenAdminRegistry_1_5.ts

@@ -0,0 +1,332 @@
+export default [
+  // generate:
+  // fetch('https://raw.githubusercontent.com/smartcontractkit/ccip/release/contracts-ccip-1.5.1/core/gethwrappers/ccip/generated/token_admin_registry/token_admin_registry.go')
+  //   .then((res) => res.text())
+  //   .then((body) => body.match(/^\s*ABI: "(.*?)",$/m)?.[1])
+  //   .then((abi) => JSON.parse(abi.replace(/\\"/g, '"')))
+  //   .then((obj) => require('util').inspect(obj, {depth:99}).split('\n').slice(1, -1))
+  {
+    inputs: [{ internalType: 'address', name: 'token', type: 'address' }],
+    name: 'AlreadyRegistered',
+    type: 'error',
+  },
+  {
+    inputs: [{ internalType: 'address', name: 'token', type: 'address' }],
+    name: 'InvalidTokenPoolToken',
+    type: 'error',
+  },
+  {
+    inputs: [
+      { internalType: 'address', name: 'sender', type: 'address' },
+      { internalType: 'address', name: 'token', type: 'address' },
+    ],
+    name: 'OnlyAdministrator',
+    type: 'error',
+  },
+  {
+    inputs: [
+      { internalType: 'address', name: 'sender', type: 'address' },
+      { internalType: 'address', name: 'token', type: 'address' },
+    ],
+    name: 'OnlyPendingAdministrator',
+    type: 'error',
+  },
+  {
+    inputs: [{ internalType: 'address', name: 'sender', type: 'address' }],
+    name: 'OnlyRegistryModuleOrOwner',
+    type: 'error',
+  },
+  { inputs: [], name: 'ZeroAddress', type: 'error' },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'token',
+        type: 'address',
+      },
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'currentAdmin',
+        type: 'address',
+      },
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'newAdmin',
+        type: 'address',
+      },
+    ],
+    name: 'AdministratorTransferRequested',
+    type: 'event',
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'token',
+        type: 'address',
+      },
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'newAdmin',
+        type: 'address',
+      },
+    ],
+    name: 'AdministratorTransferred',
+    type: 'event',
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'from',
+        type: 'address',
+      },
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'to',
+        type: 'address',
+      },
+    ],
+    name: 'OwnershipTransferRequested',
+    type: 'event',
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'from',
+        type: 'address',
+      },
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'to',
+        type: 'address',
+      },
+    ],
+    name: 'OwnershipTransferred',
+    type: 'event',
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'token',
+        type: 'address',
+      },
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'previousPool',
+        type: 'address',
+      },
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'newPool',
+        type: 'address',
+      },
+    ],
+    name: 'PoolSet',
+    type: 'event',
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: 'address',
+        name: 'module',
+        type: 'address',
+      },
+    ],
+    name: 'RegistryModuleAdded',
+    type: 'event',
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'module',
+        type: 'address',
+      },
+    ],
+    name: 'RegistryModuleRemoved',
+    type: 'event',
+  },
+  {
+    inputs: [{ internalType: 'address', name: 'localToken', type: 'address' }],
+    name: 'acceptAdminRole',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [],
+    name: 'acceptOwnership',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [{ internalType: 'address', name: 'module', type: 'address' }],
+    name: 'addRegistryModule',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      { internalType: 'uint64', name: 'startIndex', type: 'uint64' },
+      { internalType: 'uint64', name: 'maxCount', type: 'uint64' },
+    ],
+    name: 'getAllConfiguredTokens',
+    outputs: [{ internalType: 'address[]', name: 'tokens', type: 'address[]' }],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [{ internalType: 'address', name: 'token', type: 'address' }],
+    name: 'getPool',
+    outputs: [{ internalType: 'address', name: '', type: 'address' }],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [{ internalType: 'address[]', name: 'tokens', type: 'address[]' }],
+    name: 'getPools',
+    outputs: [{ internalType: 'address[]', name: '', type: 'address[]' }],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [{ internalType: 'address', name: 'token', type: 'address' }],
+    name: 'getTokenConfig',
+    outputs: [
+      {
+        components: [
+          {
+            internalType: 'address',
+            name: 'administrator',
+            type: 'address',
+          },
+          {
+            internalType: 'address',
+            name: 'pendingAdministrator',
+            type: 'address',
+          },
+          {
+            internalType: 'address',
+            name: 'tokenPool',
+            type: 'address',
+          },
+        ],
+        internalType: 'structTokenAdminRegistry.TokenConfig',
+        name: '',
+        type: 'tuple',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [
+      { internalType: 'address', name: 'localToken', type: 'address' },
+      {
+        internalType: 'address',
+        name: 'administrator',
+        type: 'address',
+      },
+    ],
+    name: 'isAdministrator',
+    outputs: [{ internalType: 'bool', name: '', type: 'bool' }],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [{ internalType: 'address', name: 'module', type: 'address' }],
+    name: 'isRegistryModule',
+    outputs: [{ internalType: 'bool', name: '', type: 'bool' }],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [],
+    name: 'owner',
+    outputs: [{ internalType: 'address', name: '', type: 'address' }],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [
+      { internalType: 'address', name: 'localToken', type: 'address' },
+      {
+        internalType: 'address',
+        name: 'administrator',
+        type: 'address',
+      },
+    ],
+    name: 'proposeAdministrator',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [{ internalType: 'address', name: 'module', type: 'address' }],
+    name: 'removeRegistryModule',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      { internalType: 'address', name: 'localToken', type: 'address' },
+      { internalType: 'address', name: 'pool', type: 'address' },
+    ],
+    name: 'setPool',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      { internalType: 'address', name: 'localToken', type: 'address' },
+      { internalType: 'address', name: 'newAdmin', type: 'address' },
+    ],
+    name: 'transferAdminRole',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [{ internalType: 'address', name: 'to', type: 'address' }],
+    name: 'transferOwnership',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [],
+    name: 'typeAndVersion',
+    outputs: [{ internalType: 'string', name: '', type: 'string' }],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  // generate:end
+] as const

package/src/evm/const.ts

@@ -0,0 +1,69 @@
+import { type EventFragment, AbiCoder, Interface } from 'ethers'
+
+import Token_ABI from './abi/BurnMintERC677Token.ts'
+import CommitStore_1_2_ABI from './abi/CommitStore_1_2.ts'
+import CommitStore_1_5_ABI from './abi/CommitStore_1_5.ts'
+import FeeQuoter_ABI from './abi/FeeQuoter_1_6.ts'
+import TokenPool_1_5_ABI from './abi/LockReleaseTokenPool_1_5.ts'
+import TokenPool_1_5_1_ABI from './abi/LockReleaseTokenPool_1_5_1.ts'
+import TokenPool_1_6_ABI from './abi/LockReleaseTokenPool_1_6_1.ts'
+import EVM2EVMOffRamp_1_2_ABI from './abi/OffRamp_1_2.ts'
+import EVM2EVMOffRamp_1_5_ABI from './abi/OffRamp_1_5.ts'
+import OffRamp_1_6_ABI from './abi/OffRamp_1_6.ts'
+import EVM2EVMOnRamp_1_2_ABI from './abi/OnRamp_1_2.ts'
+import EVM2EVMOnRamp_1_5_ABI from './abi/OnRamp_1_5.ts'
+import OnRamp_1_6_ABI from './abi/OnRamp_1_6.ts'
+import Router_ABI from './abi/Router.ts'
+import TokenAdminRegistry_ABI from './abi/TokenAdminRegistry_1_5.ts'
+
+export const defaultAbiCoder = AbiCoder.defaultAbiCoder()
+
+export const DEFAULT_GAS_LIMIT = 200_000n
+export const DEFAULT_APPROVE_GAS_LIMIT = 120_000n
+
+const customErrors = [
+  'error NoContract()',
+  'error NoGasForCallExactCheck()',
+  'error NotEnoughGasForCall()',
+] as const
+
+export const interfaces = {
+  Router: new Interface(Router_ABI),
+  Token: new Interface(Token_ABI),
+  TokenAdminRegistry: new Interface(TokenAdminRegistry_ABI),
+  FeeQuoter: new Interface(FeeQuoter_ABI),
+  TokenPool_v1_5_1: new Interface(TokenPool_1_5_1_ABI),
+  TokenPool_v1_5: new Interface(TokenPool_1_5_ABI),
+  TokenPool_v1_6: new Interface(TokenPool_1_6_ABI),
+  CommitStore_v1_5: new Interface(CommitStore_1_5_ABI),
+  CommitStore_v1_2: new Interface(CommitStore_1_2_ABI),
+  OffRamp_v1_6: new Interface(OffRamp_1_6_ABI),
+  EVM2EVMOffRamp_v1_5: new Interface(EVM2EVMOffRamp_1_5_ABI),
+  EVM2EVMOffRamp_v1_2: new Interface(EVM2EVMOffRamp_1_2_ABI),
+  OnRamp_v1_6: new Interface(OnRamp_1_6_ABI),
+  EVM2EVMOnRamp_v1_5: new Interface(EVM2EVMOnRamp_1_5_ABI),
+  EVM2EVMOnRamp_v1_2: new Interface(EVM2EVMOnRamp_1_2_ABI),
+  Custom: new Interface(customErrors),
+} as const
+
+export function getAllFragmentsMatchingEvents(
+  events: readonly string[],
+): Record<`0x${string}`, EventFragment> {
+  const fragments: Record<string, EventFragment> = {}
+  for (const iface of Object.values(interfaces)) {
+    for (const event of events) {
+      const fragment = iface.getEvent(event)
+      if (fragment) fragments[fragment.topicHash] ??= fragment
+    }
+  }
+  return fragments
+}
+export const requestsFragments = getAllFragmentsMatchingEvents([
+  'CCIPSendRequested',
+  'CCIPMessageSent',
+])
+export const commitsFragments = getAllFragmentsMatchingEvents([
+  'ReportAccepted',
+  'CommitReportAccepted',
+])
+export const receiptsFragments = getAllFragmentsMatchingEvents(['ExecutionStateChanged'])

package/src/evm/errors.ts

@@ -0,0 +1,212 @@
+import {
+  type BytesLike,
+  type ErrorFragment,
+  type EventFragment,
+  type FunctionFragment,
+  Result,
+  dataLength,
+  dataSlice,
+  hexlify,
+  isBytesLike,
+  isHexString,
+} from 'ethers'
+
+import { defaultAbiCoder, interfaces } from './const.ts'
+import { ChainFamily } from '../chain.ts'
+import { decodeExtraArgs } from '../extra-args.ts'
+
+/**
+ * Get error data from an error object, if possible
+ * @param err - error object
+ * @returns error data if found
+ **/
+export function getErrorData(err: unknown): string | undefined {
+  if (!err || typeof err != 'object') return
+  if ('data' in err && err.data && isHexString(err.data)) return err.data
+  if (
+    !('info' in err) ||
+    !err.info ||
+    typeof err.info != 'object' ||
+    !('error' in err.info) ||
+    !err.info.error ||
+    typeof err.info.error != 'object' ||
+    !('data' in err.info.error) ||
+    typeof err.info.error.data !== 'string' ||
+    !err.info.error.data
+  )
+    return
+  const match = err.info.error.data.match(/\b0x[0-9a-fA-F]+\b/)
+  if (!match) return
+  return match[0]
+}
+
+/**
+ * Try to parse selector and data with any known ABI
+ * selector must be either:
+ * - Error, Function or Event name or signature
+ * - 4-byte for Error or Function selector (first 4B of its keccak256(signature))
+ * - 32-byte for Event topicHash (keccak256(signature))
+ * If data is provided, it will be parsed with the fragment's inputs. For events, only the
+ * non-indexed arguments are parsed.
+ *
+ * @param selector - error, function or event selector
+ * @param data - data to parse as fragment's inputs
+ * @returns Fragment and contract name, if found, and parsed data if possible
+ **/
+export function parseWithFragment(
+  selector: string,
+  data?: BytesLike,
+):
+  | readonly [
+      fragment: ErrorFragment | FunctionFragment | EventFragment,
+      contractName: string,
+      parsed?: Result,
+    ]
+  | undefined {
+  if (!dataLength(data ?? '0x') && isBytesLike(selector)) {
+    const len = dataLength(selector)
+    if (len >= 4 && len !== 32) {
+      data = dataSlice(selector, 4)
+      selector = dataSlice(selector, 0, 4)
+    }
+  }
+  let res: readonly [ErrorFragment | FunctionFragment | EventFragment, string] | undefined
+  for (const [name, iface] of Object.entries(interfaces)) {
+    try {
+      const error = iface.getError(selector)
+      if (error) {
+        res = [error, name] as const
+        break
+      }
+    } catch (_) {
+      // test all abis
+    }
+    try {
+      const func = iface.getFunction(selector)
+      if (func) {
+        res = [func, name] as const
+        break
+      }
+    } catch (_) {
+      // test all abis
+    }
+    try {
+      const event = iface.getEvent(selector)
+      if (event) {
+        res = [event, name] as const
+        break
+      }
+    } catch (_) {
+      // test all abis
+    }
+  }
+  if (res && data) {
+    let parsed
+    const [fragment] = res
+    try {
+      parsed = defaultAbiCoder.decode(
+        fragment.inputs.filter(({ indexed }) => !indexed),
+        data,
+      )
+    } catch (_) {
+      // ignore
+    }
+    if (parsed) return [...res, parsed]
+  }
+  return res
+}
+
+// join truthy property names, separated by a dot
+function j(...args: string[]): string {
+  return args.filter(Boolean).join('.')
+}
+
+/**
+ * Recursively parse error data, returning an array of key/value pairs, where key is the path to
+ * error, and error maybe an error description or format, or the raw data if not parsable.
+ *
+ * @param key - key to use for the error data
+ * @param data - error bytearray data to parse
+ * @returns array of key/value pairs
+ **/
+export function recursiveParseError(
+  key: string,
+  data: unknown,
+): (readonly [key: string, error: unknown])[] {
+  if (data instanceof Result) {
+    if (data.length === 0) return key ? [[key, data.toArray()]] : []
+    let kv: ReturnType<typeof recursiveParseError>
+    try {
+      kv = Object.entries(data.toObject()).map(([k, v]) => [j(key, k), v])
+    } catch (_) {
+      kv = data.toArray().map((v, i) => [j(key, `[${i}]`), v])
+    }
+    return kv.reduce(
+      (acc, [k, v]) => [...acc, ...recursiveParseError(k, v)],
+      [] as ReturnType<typeof recursiveParseError>,
+    )
+  }
+  if (!isBytesLike(data) || [0, 20].includes(dataLength(data))) {
+    return [[key, data]]
+  }
+  try {
+    const parsed = decodeExtraArgs(data, ChainFamily.EVM)
+    if (parsed) {
+      const { _tag, ...rest } = parsed
+      return [[key, _tag], ...Object.entries(rest).map(([k, v]) => [j(key, k), v] as const)]
+    }
+  } catch (_) {
+    // pass
+  }
+  const parsed = parseWithFragment(hexlify(data))
+  if (!parsed) return [[key, data]]
+  const [fragment, _, args] = parsed
+  const desc = fragment.format('full')
+  key = desc.split(' ')[0]
+  const res = [[key, desc.substring(key.length + 1)]] as ReturnType<typeof recursiveParseError>
+  if (!args) return res
+  if (['ReceiverError', 'TokenHandlingError'].includes(fragment.name) && args.err === '0x') {
+    res.push([`${key}.err`, '0x [possibly out-of-gas or abi.decode error]'])
+    return res
+  }
+  res.push(...recursiveParseError('', args))
+  return res
+}
+
+export function parseData(data: unknown): Record<string, unknown> | undefined {
+  if (!data) return
+  if (isHexString(data)) {
+    const parsed = recursiveParseError('', data)
+    if (parsed.length === 1 && parsed[0][1] === data) return
+    return Object.fromEntries(parsed)
+  }
+  if (typeof data !== 'object') return
+  // ethers tx/simulation/call errors
+  const err_ = data as {
+    shortMessage?: string
+    message?: string
+    transaction?: { to: string; data: string }
+  }
+  const shortMessage = err_.shortMessage || err_.message
+  const transaction = err_.transaction
+  if (!shortMessage || !transaction?.data) return
+
+  let method, invocation
+  const invocation_ = (data as { invocation: { method: string; args: Result } | null }).invocation
+  if (invocation_) {
+    ;({ method, ...invocation } = invocation_)
+  } else {
+    method = dataSlice(transaction.data, 0, 4)
+    const func = parseWithFragment(method)?.[0]
+    if (func) method = func.name
+  }
+  let reason
+  const errorData = getErrorData(data)
+  if (errorData) reason = Object.fromEntries(recursiveParseError('revert', errorData))
+  return {
+    method,
+    error: shortMessage,
+    ...reason,
+    call: { ...transaction, ...invocation },
+  }
+}