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

package/src/decoder/plugins/enhanceLSP7DigitalAsset.ts

@@ -0,0 +1,165 @@
+import {
+  lsp7BurnableAbi,
+  lsp7CappedSupplyAbi,
+  lsp7DigitalAssetAbi,
+  lsp7MintableAbi,
+  lsp7VotesAbi,
+} from '@lukso/lsp7-contracts/abi'
+import type { AbiParameter } from 'viem'
+import { CacheKeyPrefix, makeCacheKey } from '../cache'
+import { decodeEvent } from '../events'
+import { pluginRegistry } from '../registry'
+import type {
+  DecodeEventResult,
+  DecoderOptions,
+  DecoderResult,
+  PluginOptions,
+  ResultType,
+} from '../types'
+import { getPublicClient } from '../utils'
+import { standardPlugin } from '.'
+import { enhanceSetData } from './enhanceSetData'
+
+const LSP7 = [
+  ...lsp7DigitalAssetAbi,
+  ...lsp7MintableAbi,
+  ...lsp7BurnableAbi,
+  ...lsp7CappedSupplyAbi,
+  ...lsp7VotesAbi,
+]
+
+export const enhanceLSP7DigitalAssetPlugin = standardPlugin(
+  LSP7,
+  {
+    name: 'lsp7',
+    abiName: 'LSP7DigitalAsset',
+    decoderName: '@lukso/lsp-smart-contracts',
+  },
+  {
+    enhance: async (result, pluginOptions, options) => {
+      const setData = await enhanceSetData(
+        result,
+        { ...pluginOptions, abiName: '', decoderName: '' },
+        options
+      )
+      if (setData) {
+        return setData
+      }
+
+      // Add token metadata for LSP7 contracts for view matching
+      if (options.async) {
+        await enhanceLSP7Metadata(result, options)
+      }
+
+      const follow = await enhanceLSP26FollowerSystem(
+        result,
+        pluginOptions,
+        options
+      )
+      if (follow) {
+        return follow
+      }
+      return result
+    },
+    decodeEvent: async (log: DecodeEventResult, options: DecoderOptions) => {
+      return decodeEvent(options.chain, LSP7, log)
+    },
+  }
+)
+
+/**
+ * Fetch and cache LSP7 contract metadata for view matching.
+ * This function reads LSP4TokenType from the contract to determine if it's a token, NFT, or collection.
+ * Results are cached per contract address to avoid redundant RPC calls for batch operations.
+ *
+ * @param result - The decoder result to enhance with metadata
+ * @param options - Decoder options containing cache and chain client
+ */
+async function enhanceLSP7Metadata(
+  result: DecoderResult,
+  options: DecoderOptions
+): Promise<void> {
+  if (!options.cache || !result.to) return
+
+  const contractAddress = result.to
+  const cacheKey = makeCacheKey(
+    CacheKeyPrefix.CONTRACT_METADATA,
+    contractAddress,
+    'lsp4-token-type'
+  )
+
+  try {
+    // Use cache.getOrSet for automatic deduplication
+    // If 5 transactions hit the same contract, only 1 RPC call is made
+    const metadata = await options.cache.getOrSet(
+      cacheKey,
+      async () => {
+        const client = getPublicClient(options.chain)
+
+        // Read LSP4TokenType from contract
+        // Key: keccak256('LSP4TokenType') = 0xe0261fa95db2eb3b5439bd033cda66d56b96f92f243a8228fd87550ed7bdfdb3
+        const tokenTypeData = await client.readContract({
+          address: contractAddress,
+          abi: LSP7,
+          functionName: 'getData',
+          args: [
+            '0xe0261fa95db2eb3b5439bd033cda66d56b96f92f243a8228fd87550ed7bdfdb3',
+          ],
+        })
+
+        // Parse token type (0 = Token, 1 = NFT, 2 = Collection)
+        const typeValue = tokenTypeData
+          ? Number.parseInt(tokenTypeData as string, 16)
+          : 0
+
+        return {
+          tokenType: typeValue,
+          isToken: typeValue === 0,
+          isNFT: typeValue === 1,
+          isCollection: typeValue === 2,
+        }
+      },
+      {
+        ttl: 1000 * 60 * 60 * 24, // Cache for 24 hours (metadata rarely changes)
+        signal: options.signal,
+      }
+    )
+
+    // Add to result.custom for view matching
+    result.custom = result.custom || {}
+    Object.assign(result.custom, metadata)
+  } catch (error) {
+    console.warn('Failed to fetch LSP7 metadata:', error)
+    // Set defaults on error (assume token)
+    result.custom = result.custom || {}
+    result.custom.tokenType = 0
+    result.custom.isToken = true
+    result.custom.isNFT = false
+    result.custom.isCollection = false
+  }
+}
+
+/**
+ *
+ * @param result enhanced if it's LSP7DigitalAsset
+ * @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 }>
+    }
+  switch (functionName) {
+  }
+  return undefined
+}
+
+export default enhanceLSP7DigitalAssetPlugin

package/src/decoder/plugins/enhanceLSP8IdentifiableDigitalAsset.ts

@@ -0,0 +1,170 @@
+import {
+  lsp8BurnableAbi,
+  lsp8CappedSupplyAbi,
+  lsp8EnumerableAbi,
+  lsp8IdentifiableDigitalAssetAbi,
+  lsp8MintableAbi,
+  lsp8VotesAbi,
+} from '@lukso/lsp8-contracts/abi'
+import type { AbiParameter } from 'viem'
+import { decodeEvent } from '../events'
+import type {
+  DecodeEventResult,
+  DecoderOptions,
+  DecoderResult,
+  PluginOptions,
+  ResultShared,
+  ResultType,
+} from '../types'
+import { createNamedArgs } from '../utils'
+import { decodeKeyValueRaw, standardPlugin } from '.'
+import { enhanceSetData } from './enhanceSetData'
+
+const LSP8 = [
+  ...lsp8IdentifiableDigitalAssetAbi,
+  ...lsp8MintableAbi,
+  ...lsp8BurnableAbi,
+  ...lsp8CappedSupplyAbi,
+  ...lsp8EnumerableAbi,
+  ...lsp8VotesAbi,
+]
+
+export const enhanceLSP8IdentifiableDigitalAssetPlugin = standardPlugin(
+  LSP8,
+  {
+    name: 'lsp8',
+    abiName: 'LSP8IdentifiableDigitalAsset',
+    decoderName: '@lukso/lsp-smart-contracts',
+  },
+  {
+    enhance: async (result, pluginOptions, options) => {
+      const setData = await enhanceSetData(result, pluginOptions, options)
+      if (setData) {
+        return setData
+      }
+      return await enhanceLSP8IdentifiableDigitalAsset(
+        result,
+        pluginOptions,
+        options
+      )
+    },
+    decodeEvent: async (log: DecodeEventResult, options: DecoderOptions) => {
+      const event = decodeEvent(options.chain, LSP8, log)
+      if (event) {
+        const tokenId = event.args.find(({ name }) => name === 'tokenId')?.value
+        if (tokenId) {
+          event.address = `${event.address}:${tokenId}`
+        }
+      }
+      return event
+    },
+  }
+)
+
+/**
+ *
+ * @param result enhanced if it's LSP8
+ * @param pluginOptions
+ * @param options
+ * @returns
+ */
+export async function enhanceLSP8IdentifiableDigitalAsset(
+  result: ResultType & ResultShared & { moduleHint?: string },
+  pluginOptions: PluginOptions,
+  options: DecoderOptions
+) {
+  const setData = await enhanceSetData(
+    result,
+    { ...pluginOptions, abiName: '', decoderName: '' },
+    options
+  )
+  if (setData) {
+    return setData
+  }
+  const { functionName, sig, args, input, blockNumber, to, from, value } =
+    result as ResultType & {
+      sig?: `0x${string}`
+      functionName?: string
+      args: Array<AbiParameter & { value?: unknown }>
+    }
+  switch (functionName) {
+    case 'setDataForTokenId': {
+      // Single setDataForTokenId
+      const [tokenId, _key, _value] = args.map(({ value }) => value) as [
+        `0x${string}`,
+        `0x${string}`,
+        `0x${string}`,
+      ]
+      return {
+        blockNumber,
+        ...result,
+        __decoder: pluginOptions.decoderName,
+        resultType: 'setDataBatch',
+        standard: pluginOptions.abiName,
+        input,
+        children: [
+          {
+            ...result,
+            standard: pluginOptions.abiName,
+            tokenId,
+            to: `${to}:${tokenId}`,
+            from,
+            value,
+            info: await decodeKeyValueRaw(_key, _value, options),
+          },
+        ] as Array<DecoderResult>,
+      } as DecoderResult
+    }
+    case 'setDataBatchForTokenIds': {
+      // Multiple setDataBatchForTokenIds
+      const children: Array<ResultType> = []
+      const [tokenIds, keys, values] = args.map(({ value }) => value) as [
+        `0x${string}`[],
+        `0x${string}`[],
+        `0x${string}`[],
+      ]
+      for (let i = 0; i < tokenIds.length; i++) {
+        const tokenId = tokenIds[i] as `0x${string}`
+        const key = keys[i] as `0x${string}`
+        const _value = values[i] as `0x${string}`
+        children.push({
+          ...result,
+          resultType: 'setData',
+          __decoder: '@lukso/lsp-smart-contracts',
+          standard: key,
+          ...createNamedArgs(
+            [tokenId, key, _value],
+            [
+              { name: 'tokenId', type: 'bytes32' },
+              { name: 'key', type: 'bytes32' },
+              { name: 'value', type: 'bytes' },
+            ]
+          ),
+          tokenId,
+          phase: 'enhanced',
+          to: `${to}:${tokenId}`,
+          from,
+          value,
+          info: await decodeKeyValueRaw(key, _value, options),
+        } as DecoderResult)
+      }
+      return {
+        ...result,
+        __decoder: pluginOptions.decoderName,
+        functionName,
+        sig,
+        input,
+        standard: pluginOptions.abiName,
+        resultType: 'setDataBatch',
+        ...(args ? { args } : {}),
+        to,
+        from,
+        value,
+        children,
+      } as DecoderResult
+    }
+  }
+  return result
+}
+
+export default enhanceLSP8IdentifiableDigitalAssetPlugin

package/src/decoder/plugins/enhanceLSP9Vault.ts

@@ -0,0 +1,57 @@
+import { lsp9VaultAbi as LSP9 } from '@lukso/lsp9-contracts/abi'
+import type { AbiParameter } from 'viem'
+import { decodeEvent } from '../events'
+import type {
+  DecodeEventResult,
+  DecoderOptions,
+  PluginOptions,
+  ResultShared,
+  ResultType,
+} from '../types'
+import { standardPlugin } from '.'
+import { enhanceSetData } from './enhanceSetData'
+
+export const enhanceLSP9VaultPlugin = standardPlugin(
+  LSP9,
+  {
+    name: 'lsp9',
+    abiName: 'LSP9Vault',
+    decoderName: '@lukso/lsp-smart-contracts',
+  },
+  {
+    enhance: async (result, pluginOptions, options) => {
+      const setData = await enhanceSetData(result, pluginOptions, options)
+      if (setData) {
+        return setData
+      }
+      return await enhanceLSP9Vault(result, pluginOptions, options)
+    },
+    decodeEvent: async (log: DecodeEventResult, options: DecoderOptions) => {
+      return decodeEvent(options.chain, LSP9, log)
+    },
+  }
+)
+/**
+ *
+ * @param result enhanced if it's LSP8
+ * @param pluginOptions
+ * @param options
+ * @returns
+ */
+export async function enhanceLSP9Vault(
+  result: ResultType & ResultShared & { moduleHint?: string },
+  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 }>
+    }
+  switch (functionName) {
+  }
+  return undefined
+}
+
+export default enhanceLSP9VaultPlugin

package/src/decoder/plugins/enhanceRetrieveAbi.ts

@@ -0,0 +1,85 @@
+import { abi as LSP9 } from '@lukso/lsp-smart-contracts/artifacts/LSP9Vault.json'
+import type { AbiParameter } from 'viem'
+import { decodeEvent } from '../events'
+import { fetchAbi, getFunctionSignature } from '../functionSignature'
+import type {
+  DecodeEventResult,
+  DecoderOptions,
+  DecoderResult,
+  PluginOptions,
+  ResultShared,
+  ResultType,
+} from '../types'
+import { standardPlugin } from '.'
+
+export const enhanceRetrieveAbiPlugin = standardPlugin(
+  LSP9,
+  {
+    abiName: 'Internal',
+    decoderName: 'explorer',
+    name: 'abiRetrieve',
+    usesAsync: true,
+    priority: 0,
+  },
+  {
+    enhance: async () => {
+      return undefined
+    },
+    overrideEnhance: enhanceRetrieveAbi,
+    decodeEvent: async (log: DecodeEventResult, options: DecoderOptions) => {
+      if (!log) {
+        return undefined
+      }
+      const info = await fetchAbi(options.chain, log.address)
+      // TBD. This will only work with explorer download of abi
+      if (info) {
+        const result = decodeEvent(options.chain, info.abi, log)
+        if (result) {
+          return { ...result, __decoder: info.explorer }
+        }
+      }
+      return undefined
+    },
+  }
+)
+/**
+ *
+ * @param result enhanced if it's LSP8
+ * @param pluginOptions
+ * @param options
+ * @returns
+ */
+export async function enhanceRetrieveAbi(
+  result: ResultType & ResultShared & { moduleHint?: string },
+  _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 }>
+    }
+  try {
+    const decoded = await getFunctionSignature(
+      options.chain,
+      input,
+      (to || undefined) as `0x${string}` | undefined,
+      options.preferError
+    )
+    if (decoded) {
+      return {
+        ...result,
+        ...decoded,
+        resultType: 'execute',
+        to,
+        from,
+        value,
+        input,
+      } as DecoderResult
+    }
+  } catch {}
+  return undefined
+}
+
+export default enhanceRetrieveAbiPlugin

package/src/decoder/plugins/enhanceSetData.ts

@@ -0,0 +1,135 @@
+import type { AbiParameter } from 'viem'
+import type {
+  DecoderOptions,
+  DecoderResult,
+  PluginOptions,
+  ResultSetData,
+  ResultShared,
+  ResultType,
+} from '../types'
+import { createNamedArgs } from '../utils'
+import { decodeKeyValueRaw } from '.'
+
+/**
+ *
+ * @param result decode setData and setDataBatch as either a single or many setData items.
+ * @returns
+ */
+export async function enhanceSetData(
+  result: ResultType & ResultShared & { moduleHint?: string },
+  pluginOptions: PluginOptions,
+  options: DecoderOptions
+): Promise<DecoderResult | undefined> {
+  const { functionName, sig, args, input, blockNumber, to, from, value } =
+    result as ResultType & {
+      sig?: `0x${string}`
+      functionName?: string
+      args: Array<AbiParameter & { value?: unknown }>
+      namedArgs?:
+        | Record<number, AbiParameter & { value?: unknown }>
+        | Record<string, unknown>
+    }
+  switch (functionName) {
+    case 'setData': {
+      const [_key, _value] = args.map(({ value }) => value) as `0x${string}`[]
+      // Single setData
+      return {
+        ...result,
+        resultType: 'setDataBatch',
+        functionName,
+        standard: result.standard || pluginOptions.abiName || 'LSPContract',
+        __decoder:
+          result.__decoder ||
+          pluginOptions.decoderName ||
+          '@lukso/lsp-smart-contracts',
+        input,
+        blockNumber,
+        sig,
+        args,
+        children: [
+          {
+            ...result,
+            info: await decodeKeyValueRaw(_key, _value, options),
+            standard: result.standard || pluginOptions.abiName || 'LSPContract',
+            __decoder:
+              result.__decoder ||
+              pluginOptions.decoderName ||
+              '@lukso/lsp-smart-contracts',
+            phase: 'enhanced',
+            to,
+            from,
+            value,
+            ...(args
+              ? {
+                  ...createNamedArgs(
+                    [_key, _value],
+                    [
+                      { name: 'key', type: 'bytes32' },
+                      { name: 'value', type: 'bytes' },
+                    ]
+                  ),
+                }
+              : {}),
+          },
+        ] as unknown as Array<ResultSetData>,
+        to,
+        from,
+        value,
+      } as DecoderResult
+    }
+    case 'setDataBatch': {
+      // Multiple setDataBatch
+      const children: Array<ResultType> = []
+      const [keys, values] = args.map(({ value }) => value) as [
+        `0x${string}`[],
+        `0x${string}`[],
+      ]
+      for (let i = 0; i < keys.length; i++) {
+        const key = keys[i] as `0x${string}`
+        const _value = values[i] as `0x${string}`
+        children.push({
+          ...result,
+          resultType: 'setData',
+          standard: result.standard || pluginOptions.abiName || 'LSPContract',
+          __decoder:
+            result.__decoder ||
+            pluginOptions.decoderName ||
+            '@lukso/lsp-smart-contracts',
+          phase: 'enhanced',
+          to,
+          from,
+          value,
+          ...createNamedArgs(
+            [key, _value],
+            [
+              { name: 'key', type: 'bytes32' },
+              { name: 'value', type: 'bytes' },
+            ]
+          ),
+          info: await decodeKeyValueRaw(key, _value, options),
+        } as DecoderResult)
+      }
+      const setDataBatchResult = {
+        ...result,
+        resultType: 'setDataBatch',
+        functionName,
+        sig,
+        input,
+        ...(args ? { args } : {}),
+        standard: result.standard || pluginOptions.abiName || 'LSPContract',
+        __decoder:
+          result.__decoder ||
+          pluginOptions.decoderName ||
+          '@lukso/lsp-smart-contracts',
+        to,
+        from,
+        value,
+        children,
+      } as DecoderResult
+      return setDataBatchResult
+    }
+  }
+  return undefined
+}
+
+export default enhanceSetData

package/src/decoder/plugins/index.ts

@@ -0,0 +1,99 @@
+// Re-export standardPlugin and helpers from the new file
+export {
+  createAggregationKey,
+  standardPlugin,
+  standardSchemaPlugin,
+} from './standardPlugin'
+
+import burntPix from './enhanceBurntPix'
+// Import plugins - now standardPlugin is available from ./standardPlugin
+import graffiti from './enhanceGraffiti'
+import profile from './enhanceLSP0ERC725Account'
+import keyManager from './enhanceLSP6KeyManager'
+import lsp7 from './enhanceLSP7DigitalAsset'
+import lsp8 from './enhanceLSP8IdentifiableDigitalAsset'
+import lsp9 from './enhanceLSP9Vault'
+import lsp26 from './enhanceLSP26FollowerSystem'
+import abiRetrieve from './enhanceRetrieveAbi'
+import schemaDefaultPlugin from './schemaDefault'
+
+// Force evaluation of plugins to ensure they register (prevent tree-shaking)
+// These plugins self-register via standardPlugin when imported
+;[profile, keyManager, lsp7, lsp8, lsp9, lsp26, burntPix].forEach((p) => p)
+
+import type { Hex } from 'viem'
+import type {
+  DecoderOptions,
+  DecoderPlugin,
+  Info,
+  ResultSetData,
+  SchemaPlugin,
+} from '../types'
+import { getArgByName } from '../utils'
+
+export const defaultPlugins: ReadonlyArray<DecoderPlugin> = Object.freeze([
+  graffiti,
+  keyManager,
+  profile,
+  lsp7,
+  lsp8,
+  lsp9,
+  lsp26,
+  abiRetrieve,
+  burntPix,
+])
+
+export const defaultSchemaPlugins: ReadonlyArray<SchemaPlugin> = Object.freeze([
+  schemaDefaultPlugin,
+])
+
+export default defaultPlugins
+
+export async function decodeKeyValue(
+  result: ResultSetData,
+  options: DecoderOptions
+): Promise<Info | undefined> {
+  const key: Hex = (getArgByName(result.args, 'key') as Hex) ?? '0x'
+  const value: Hex = (getArgByName(result.args, 'value') as Hex) ?? '0x'
+  return await decodeKeyValueRaw(key, value, options)
+}
+
+export async function decodeKeyValueRaw(
+  key: Hex,
+  value: Hex,
+  options: DecoderOptions
+): Promise<Info | undefined> {
+  for (const schemaPlugin of options.schemaPlugins) {
+    try {
+      const output = await schemaPlugin(key, value)
+      if (output) {
+        return output
+      }
+    } catch {}
+  }
+  return undefined
+}
+
+// Import registry and register default plugins when this module loads
+import { pluginRegistry } from '../registry'
+
+// Register graffiti manually since it doesn't use standardPlugin
+pluginRegistry.register('graffiti', graffiti, {
+  priority: 100,
+  required: false,
+})
+
+// Register abiRetrieve manually with async flag
+pluginRegistry.register('abiRetrieve', abiRetrieve, {
+  priority: 1,
+  required: false,
+  usesAsync: true,
+})
+
+// Register default schema plugin
+pluginRegistry.registerSchema('default-schema', schemaDefaultPlugin, {
+  priority: 100,
+  required: false,
+})
+
+// Note: Other plugins using standardPlugin will auto-register when imported