@lukso/transaction-decoder 1.0.1-dev.0f1bea5

package/src/decoder/plugins/enhanceGraffiti.ts

@@ -0,0 +1,70 @@
+import {
+  type AbiParameter,
+  bytesToString,
+  type Hex,
+  hexToBytes,
+  size,
+  slice,
+} from 'viem'
+import type {
+  DecodeEventResult,
+  DecoderOptions,
+  DecoderPlugin,
+  DecoderResult,
+  PluginOptions,
+  ResultType,
+} from '../types'
+
+// Since this plugin doesn't use an abi, we need to short circuit with "as DecoderResult"
+export const enhanceGraffitiPlugin: DecoderPlugin = Object.freeze({
+  enhance: async (result: DecoderResult, options: DecoderOptions) =>
+    enhanceGraffiti(
+      result,
+      { abiName: 'graffiti', decoderName: 'graffiti' },
+      options
+    ),
+  decodeEvent: async (log: DecodeEventResult, options: DecoderOptions) =>
+    undefined,
+  required: true,
+  priority: 1000,
+  name: 'graffiti',
+})
+
+export async function enhanceGraffiti(
+  result: DecoderResult,
+  _pluginOptions: PluginOptions,
+  _options: DecoderOptions
+) {
+  const { functionName, sig, args, input } = result as ResultType & {
+    sig?: `0x${string}`
+    functionName?: string
+    args: Array<AbiParameter & { value?: unknown }>
+    namedArgs?:
+      | Record<number, AbiParameter & { value?: unknown }>
+      | Record<string, unknown>
+  }
+  if (
+    input &&
+    size(input || '0x') >= 4 &&
+    slice(input || '0x', 0, 4) === '0x00000000'
+  ) {
+    let graffiti: string = slice(input, 4)
+    try {
+      graffiti = bytesToString(hexToBytes(graffiti as Hex))
+    } catch {
+      // Ignore
+    }
+    return {
+      ...result,
+      resultType: 'grafitti',
+      sig: '0x',
+      functionName: '',
+      input,
+      graffiti,
+      __decoder: 'grafitti',
+    } as DecoderResult
+  }
+  return undefined
+}
+
+export default enhanceGraffitiPlugin

package/src/decoder/plugins/enhanceLSP0ERC725Account.ts

@@ -0,0 +1,179 @@
+import { universalProfileAbi as UniversalProfile } from '@lukso/universalprofile-contracts/abi'
+import type { Address } from 'viem'
+import { decodeEvent } from '../events'
+import { decodeTransaction } from '../transaction'
+import type {
+  ArrayArgs,
+  DecodeEventResult,
+  DecoderOptions,
+  DecoderResult,
+  PluginOptions,
+  ResultExecute,
+  ResultShared,
+  ResultType,
+} from '../types'
+import { createNamedArgs } from '../utils'
+import { standardPlugin } from '.'
+import { enhanceSetData } from './enhanceSetData'
+
+export const enhanceLSP0ERC725AccountPlugin = standardPlugin(
+  UniversalProfile,
+  {
+    name: 'profile',
+    abiName: 'LSP0ERC725Account',
+    decoderName: '@lukso/lsp-smart-contracts',
+  },
+  {
+    enhance: enhanceLSP0ERC725Account,
+    decodeEvent: async (log: DecodeEventResult, options: DecoderOptions) => {
+      return decodeEvent(options.chain, UniversalProfile, log)
+    },
+  }
+)
+
+export async function enhanceLSP0ERC725Account(
+  result: DecoderResult,
+  pluginOptions: PluginOptions,
+  options: DecoderOptions
+): Promise<DecoderResult | undefined> {
+  const setData = await enhanceSetData(
+    result,
+    { ...pluginOptions, abiName: '', decoderName: '' },
+    options
+  )
+  if (setData) {
+    return setData
+  }
+  const {
+    functionName,
+    sig,
+    args,
+    input,
+    blockNumber,
+    to: _to,
+    from: _from,
+    value,
+  } = result as ResultType & {
+    sig?: `0x${string}`
+    functionName?: string
+    args: ArrayArgs
+  }
+  let to = _to
+  let from = _from
+  switch (functionName) {
+    case 'executeBatch': {
+      // executeBatch
+      const children: Array<ResultType> = []
+      const [executeTypes, targets, values, inputs] = args.map(
+        ({ value }) => value
+      ) as [bigint[], Address[], bigint[], `0x${string}`[]]
+      const {
+        functionName: _functionName,
+        sig: _sig,
+        args: _args,
+        resultType: _resultType,
+        ...plainResult
+      } = result as ResultExecute & ResultShared
+      for (let i = 0; i < values.length; i++) {
+        const _data = inputs[i] as `0x${string}`
+        const _value = BigInt(values[i])
+        const _to = targets[i]
+        const decoded = await decodeTransaction(
+          {
+            input: _data,
+            to: _to,
+            from: from,
+            value: _value,
+          } as DecoderResult,
+          options
+        )
+        children.push(
+          executeTypes[i] === 1n
+            ? ({
+                ...plainResult,
+                ...decoded,
+                resultType: 'create',
+              } as DecoderResult)
+            : ({ ...plainResult, ...decoded } as DecoderResult)
+        )
+      }
+      options.wrappers.splice(0, 0, {
+        ...result,
+        resultType: 'wrapper',
+        functionName,
+        sig,
+        standard: pluginOptions.abiName,
+        args,
+        to,
+        from,
+        value,
+        input,
+        __decoder: pluginOptions.decoderName,
+      } as DecoderResult)
+      const execute: ResultType = {
+        ...result,
+        resultType: 'executeBatch',
+        standard: pluginOptions.abiName,
+        __decoder: pluginOptions.decoderName,
+        children,
+        to,
+        from,
+        value,
+      } as unknown as ResultType
+      return {
+        blockNumber,
+        ...execute,
+      } as unknown as DecoderResult
+    }
+    case 'execute': {
+      // LSP0 execute
+      const [executeType, target, value, _data] = args.map(
+        ({ value }) => value
+      ) as [bigint, Address, bigint, `0x${string}`]
+      // const _target = await getKMTarget(chain, to)
+      const decoded = await decodeTransaction(
+        {
+          input: _data,
+          to: target,
+          from: to || from, // This should be decoded to the profile address if it's a controller.
+          value,
+        } as DecoderResult,
+        options
+      )
+      from = to || from
+      to = target || to
+      options.wrappers?.splice(0, 0, {
+        ...result,
+        resultType: 'wrapper',
+        functionName,
+        sig,
+        input,
+        __decoder: pluginOptions.decoderName,
+        to,
+        from,
+        value,
+        standard: pluginOptions.abiName,
+        ...createNamedArgs(
+          [executeType, target, value, _data],
+          [
+            { name: 'executeType', type: 'uint256' },
+            { name: 'target', type: 'address' },
+            { name: 'value', type: 'uint256' },
+            { name: 'data', type: 'bytes' },
+          ]
+        ),
+      } as DecoderResult)
+      return {
+        ...result,
+        functionName,
+        sig,
+        standard: pluginOptions.abiName,
+        __decoder: pluginOptions.decoderName,
+        ...decoded,
+        resultType: executeType === 1n ? 'create' : 'execute',
+      } as unknown as DecoderResult
+    }
+  }
+}
+
+export default enhanceLSP0ERC725AccountPlugin

package/src/decoder/plugins/enhanceLSP26FollowerSystem.ts

@@ -0,0 +1,88 @@
+import { lsp26FollowerSystemAbi as LSP26 } from '@lukso/lsp26-contracts/abi'
+import type { AbiParameter, Address } from 'viem'
+import { decodeEvent } from '../events'
+import type {
+  DecodeEventResult,
+  DecoderOptions,
+  DecoderResult,
+  PluginOptions,
+  ResultExecute,
+  ResultType,
+} from '../types'
+import { standardPlugin } from '.'
+import { enhanceSetData } from './enhanceSetData'
+
+export const enhanceLSP26FollowerSystemPlugin = standardPlugin(
+  LSP26,
+  {
+    name: 'lsp26',
+    abiName: 'LSP26FollowerSystem',
+    decoderName: '@lukso/lsp-smart-contracts',
+  },
+  {
+    enhance: async (result, pluginOptions, options) => {
+      const setData = await enhanceSetData(result, pluginOptions, options)
+      if (setData) {
+        return setData
+      }
+      return await enhanceLSP26FollowerSystem(result, pluginOptions, options)
+    },
+    decodeEvent: async (log: DecodeEventResult, options: DecoderOptions) => {
+      return decodeEvent(options.chain, LSP26, log)
+    },
+  }
+)
+/**
+ *
+ * @param result enhanced if it's LSP8
+ * @param pluginOptions
+ * @param options
+ * @returns
+ */
+export async function enhanceLSP26FollowerSystem(
+  result: DecoderResult,
+  _pluginOptions: PluginOptions,
+  _options: DecoderOptions
+) {
+  const { functionName, sig, args, input, blockNumber, to, from, value } =
+    result as ResultType & {
+      sig?: `0x${string}`
+      functionName?: string
+      args: Array<AbiParameter & { value?: unknown }>
+    }
+  const { args: _args, ...partialResult } = result as ResultExecute
+  switch (functionName) {
+    case 'follow':
+    case 'unfollow':
+      return {
+        ...result,
+        children: [
+          {
+            ...partialResult,
+            resultType: 'followProfile',
+            phase: 'enhanced',
+            address: args[0]?.value as Address,
+          } as DecoderResult,
+        ],
+      } as DecoderResult
+      break
+    case 'followBatch':
+    case 'unfollowBatch':
+      return {
+        ...result,
+        children: (result.resultType === 'execute'
+          ? (result.args?.[0]?.value as Array<Address>) || []
+          : []
+        ).map((address: Address) => ({
+          ...partialResult,
+          phase: 'enhanced',
+          resultType: 'followProfile',
+          address,
+        })),
+      } as DecoderResult
+      break
+  }
+  return undefined
+}
+
+export default enhanceLSP26FollowerSystemPlugin

package/src/decoder/plugins/enhanceLSP6KeyManager.ts

@@ -0,0 +1,231 @@
+import { lsp6KeyManagerAbi as KeyManager } from '@lukso/lsp6-contracts/abi'
+import type { AbiParameter } from 'viem'
+import { decodeEvent } from '../events'
+import { getKMTarget } from '../interfaces'
+import { decodeTransaction } from '../transaction'
+import type {
+  DecodeEventResult,
+  DecoderOptions,
+  DecoderResult,
+  PluginOptions,
+  ResultExecute,
+  ResultShared,
+  ResultType,
+} from '../types'
+import { standardPlugin } from '.'
+import { enhanceSetData } from './enhanceSetData'
+
+export const enhanceLSP6KeyManagerPlugin = standardPlugin(
+  KeyManager,
+  {
+    name: 'keyManager',
+    abiName: 'LSP6KeyManager',
+    decoderName: '@lukso/lsp-smart-contracts',
+  },
+  {
+    enhance: async (result, pluginOptions, options) => {
+      const setData = await enhanceSetData(result, pluginOptions, options)
+      if (setData) {
+        return setData
+      }
+      return enhanceKeyManager(result, pluginOptions, options)
+    },
+    decodeEvent: async (log: DecodeEventResult, options: DecoderOptions) => {
+      return decodeEvent(options.chain, KeyManager, log)
+    },
+  }
+)
+
+export async function enhanceKeyManager(
+  result: ResultType & ResultShared & { moduleHint?: string },
+  pluginOptions: PluginOptions,
+  options: DecoderOptions
+): Promise<DecoderResult | undefined> {
+  const {
+    functionName,
+    sig,
+    args,
+    input,
+    blockNumber,
+    to: _to,
+    from: _from,
+    value,
+  } = result as ResultType & {
+    sig?: `0x${string}`
+    functionName?: string
+    args: Array<AbiParameter & { value?: unknown }>
+  }
+
+  let to = _to
+  let from = _from
+
+  switch (functionName) {
+    case 'execute': {
+      // LSP6 execute
+      const decoded = await decodeTransaction(
+        {
+          input: args?.[0]?.value as `0x${string}` | undefined,
+          to,
+          from,
+          value,
+        } as DecoderResult,
+        options
+      )
+      options.wrappers?.splice(0, 0, {
+        ...result,
+        resultType: 'wrapper',
+        __decoder: pluginOptions.decoderName,
+        functionName,
+        sig,
+        input,
+        standard: pluginOptions.abiName,
+        args,
+      } as DecoderResult)
+      const execute: ResultType = {
+        ...result,
+        ...decoded,
+        to,
+        from,
+        value,
+      } as unknown as ResultType
+      return {
+        ...execute,
+      } as unknown as DecoderResult
+    }
+    case 'executeBatch': {
+      // LSP6 executeBatch
+      const children: Array<ResultType> = []
+      const [values, inputs] = args.map(({ value }) => value) as [
+        `0x${string}`[],
+        `0x${string}`[],
+      ]
+      const {
+        functionName: _functionName,
+        sig: _sig,
+        args: _args,
+        resultType: _resultType,
+        ...plainResult
+      } = result as ResultExecute & ResultShared
+
+      for (let i = 0; i < values.length; i++) {
+        const _data = inputs[i] as `0x${string}`
+        const _value = BigInt(values[i])
+        const decoded = await decodeTransaction(
+          {
+            input: _data,
+            to,
+            from,
+            value: _value,
+          } as DecoderResult,
+          options
+        )
+        children.push({ ...plainResult, ...decoded } as DecoderResult)
+      }
+      options.wrappers?.splice(0, 0, {
+        ...result,
+        resultType: 'wrapper',
+        functionName,
+        sig,
+        __decoder: pluginOptions.decoderName,
+        standard: pluginOptions.abiName,
+        args,
+        input,
+      } as DecoderResult)
+      return {
+        ...result,
+        resultType: 'executeBatch',
+        __decoder: '@lukso/lsp-smart-contracts',
+        standard: pluginOptions.abiName,
+        children,
+        to,
+        from,
+        value,
+      } as unknown as DecoderResult
+    }
+    case 'executeRelayerCallBatch': {
+      // executeRelayerCallBatch
+      const [signatures, nonces, validityTimestamps, values, payloads] =
+        args.map(({ value }) => value) as [
+          `0x${string}`[],
+          bigint[],
+          bigint[],
+          bigint[],
+          `0x${string}`[],
+        ]
+      const children: Array<ResultType> = []
+      for (let i = 0; i < values.length; i++) {
+        const _data = payloads[i] as `0x${string}`
+        const _value = BigInt(values[i])
+        const _signature = signatures[i] as `0x${string}`
+        const _nonce = nonces[i]
+        const _validityTimestamp = validityTimestamps[i]
+        const decoded = await decodeTransaction(
+          {
+            input: _data,
+            to,
+            from,
+            value: _value,
+          } as DecoderResult,
+          options
+        )
+        children.push({ ...result, ...decoded } as DecoderResult)
+      }
+      options.wrappers?.splice(0, 0, {
+        ...result,
+        resultType: 'wrapper',
+        __decoder: pluginOptions.decoderName,
+        functionName,
+        sig,
+        input,
+        standard: pluginOptions.abiName,
+        args,
+      } as DecoderResult)
+      return {
+        ...result,
+        resultType: 'executeBatch',
+        __decoder: pluginOptions.decoderName,
+        standard: pluginOptions.abiName,
+        children,
+        to,
+        from,
+        value,
+      } as unknown as DecoderResult
+    }
+    // -> executeRelayCall
+    case 'executeRelayCall': {
+      const [_signature, _nonce, _validityTimestamps, _input] = args.map(
+        ({ value }) => value
+      ) as [`0x${string}`, bigint, bigint, `0x${string}`]
+      const _target = await getKMTarget(options.chain, to)
+      const decoded = await decodeTransaction(
+        {
+          input: _input,
+          to: _target ?? to,
+          from,
+          value,
+        } as DecoderResult,
+        options
+      )
+      from = to || from
+      to = _target || to
+      options.wrappers?.splice(0, 0, {
+        ...result,
+        resultType: 'wrapper',
+        __decoder: pluginOptions.decoderName,
+        functionName,
+        sig,
+        input,
+        standard: pluginOptions.abiName,
+        to,
+        from,
+        value,
+        args,
+      } as DecoderResult)
+      return {
+        ...decoded,
+      } as unknown as DecoderResult
+    }
+  }
+}
+
+export default enhanceLSP6KeyManagerPlugin