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

package/src/server/index.ts

@@ -0,0 +1,81 @@
+import { ServerAddressResolver } from './addressResolver'
+import { ServerDecoderCaches } from './caches'
+import { decodeTransactionSync } from './decodeTransactionSync'
+import { decodeTransactionsBatch } from './decodeTransactionsBatch'
+import { finishDecoding } from './finishDecoding'
+import type {
+  ServerDecoder,
+  ServerDecoderConfig,
+  ServerDecoderOptions,
+} from './types'
+
+// Import plugins to ensure they are registered
+import '../decoder/plugins'
+
+/**
+ * Create a server-optimized decoder instance
+ */
+export function createServerDecoder(
+  config: ServerDecoderConfig
+): ServerDecoder {
+  // Create caches
+  const caches = new ServerDecoderCaches({
+    transactionCacheSize: config.transactionCacheSize,
+    addressCacheSize: config.addressCacheSize,
+    abiCacheSize: config.abiCacheSize,
+    schemaCacheSize: config.schemaCacheSize,
+  })
+
+  // Create address resolver
+  const addressResolver = new ServerAddressResolver(
+    config.graphqlEndpoint,
+    config.defaultChain,
+    caches
+  )
+
+  // Return server decoder interface
+  return {
+    async decodeTransaction(transaction, options) {
+      const opts: ServerDecoderOptions = {
+        chain: config.defaultChain,
+        timeoutMs: config.defaultTimeout,
+        ...options,
+      }
+      return decodeTransactionSync(transaction, opts, caches)
+    },
+
+    async decodeTransactionsBatch(transactions, options) {
+      const opts: ServerDecoderOptions = {
+        chain: config.defaultChain,
+        timeoutMs: config.defaultTimeout,
+        ...options,
+      }
+      return decodeTransactionsBatch(transactions, opts, caches)
+    },
+
+    async finishDecoding(transaction, options) {
+      const opts: ServerDecoderOptions = {
+        chain: config.defaultChain,
+        timeoutMs: config.defaultTimeout,
+        ...options,
+      }
+      return finishDecoding(transaction, opts, caches)
+    },
+
+    clearCaches() {
+      caches.clear()
+    },
+
+    getCacheStats() {
+      return caches.getStats()
+    },
+
+    async warmAddressCache(addresses) {
+      await addressResolver.warmCache(addresses)
+    },
+
+    async resolveAddresses(addresses, timeoutMs = 3000) {
+      return addressResolver.resolveAddressesWithTimeout(addresses, timeoutMs)
+    },
+  }
+}

package/src/server/lsp23Resolver.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, it } from 'vitest'
+import {
+  decodeDeploymentCalldata,
+  decodeDeploymentOutput,
+} from './lsp23Resolver'
+
+describe('LSP23 Resolver', () => {
+  it('should decode deployERC1167Proxies calldata', () => {
+    // Sample transaction from user's trace
+    const input =
+      '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'
+
+    const decoded = decodeDeploymentCalldata(input)
+
+    expect(decoded).toBeDefined()
+    expect(decoded?.salt).toBe(
+      '0x2835628cabf5153dc5b88df586e3f52fd940693d9634d5d50a353cb1b8077234'
+    )
+    expect(decoded?.primaryImplementation.toLowerCase()).toBe(
+      '0x52c90985af970d4e0dc26cb5d052505278af32a9'
+    )
+    expect(decoded?.secondaryImplementation.toLowerCase()).toBe(
+      '0xa75684d7d048704a2db851d05ba0c3cbe226264c'
+    )
+    expect(decoded?.postDeploymentModule.toLowerCase()).toBe(
+      '0x000000000066093407b6704b89793beffd0d8f00'
+    )
+    expect(decoded?.initializationCalldata).toBeDefined()
+    expect(decoded?.initializationCalldata.length).toBeGreaterThan(0)
+  })
+
+  it('should decode deployERC1167Proxies output', () => {
+    const output =
+      '0x00000000000000000000000002e655f92f01bc7880807ec409f134b91bb28381000000000000000000000000497fdac9e42193f6f79651d2d1caf6ba5789e055'
+
+    const decoded = decodeDeploymentOutput(output)
+
+    expect(decoded).toBeDefined()
+    expect(decoded?.profileAddress.toLowerCase()).toBe(
+      '0x02e655f92f01bc7880807ec409f134b91bb28381'
+    )
+    expect(decoded?.urdAddress.toLowerCase()).toBe(
+      '0x497fdac9e42193f6f79651d2d1caf6ba5789e055'
+    )
+  })
+})

package/src/server/lsp23Resolver.ts

@@ -0,0 +1,419 @@
+import type { Address, Chain } from 'viem'
+import {
+  bytesToHex,
+  decodeAbiParameters,
+  isHex,
+  parseAbiParameters,
+} from 'viem'
+
+/**
+ * LSP23 Factory address (same on all networks)
+ */
+export const LSP23_FACTORY_ADDRESS =
+  '0x2300000a84d25df63081feaa37ba6b62c4c89a30' as const
+
+/**
+ * deployERC1167Proxies function selector
+ */
+export const DEPLOY_ERC1167_PROXIES_SELECTOR = '0x6a66a753' as const
+
+/**
+ * LSP23 deployment data structure
+ */
+export interface LSP23DeploymentData {
+  profileAddress: Address
+  urdAddress: Address
+  deployerAddress: Address // The controller that deployed this profile
+  salt: string
+  primaryImplementation: Address
+  secondaryImplementation: Address
+  postDeploymentModule: Address
+  initializationCalldata: string
+  deploymentCalldata: string // Full calldata to deployERC1167Proxies
+  transactionHash: string
+  blockNumber: bigint
+  blockTimestamp: number // Unix timestamp of the block
+  chainId: number
+}
+
+/**
+ * Contract deployment tuple structures
+ * Primary: (bytes32 salt, uint256 fundingAmount, address implementationContract, bytes initializeCalldata)
+ * Secondary: (uint256 fundingAmount, address implementationContract, bytes addInitializeCalldata, bool addConstructor, bytes constructorParams)
+ */
+
+/**
+ * Decode deployERC1167Proxies calldata
+ *
+ * Function signature:
+ * deployERC1167Proxies(
+ *   (bytes32 salt, uint256 fundingAmount, address implementationContract, bytes initializeCalldata) primaryContractDeployment,
+ *   (uint256 fundingAmount, address implementationContract, bytes addInitializeCalldata, bool addConstructor, bytes constructorParams) secondaryContractDeployment,
+ *   address postDeploymentModule,
+ *   bytes postDeploymentModuleCalldata
+ * )
+ */
+export function decodeDeploymentCalldata(input: string): {
+  salt: string
+  primaryImplementation: Address
+  secondaryImplementation: Address
+  postDeploymentModule: Address
+  initializationCalldata: string
+} | null {
+  try {
+    // Remove function selector (first 4 bytes / 8 hex chars + 0x)
+    const params = `0x${input.slice(10)}` as `0x${string}`
+
+    // Decode the parameters
+    const decoded = decodeAbiParameters(
+      parseAbiParameters(
+        '(bytes32,uint256,address,bytes), (uint256,address,bytes,bool,bytes), address, bytes'
+      ),
+      params
+    )
+
+    const [
+      primaryDeployment,
+      secondaryDeployment,
+      postDeploymentModule,
+      postDeploymentModuleCalldata,
+    ] = decoded
+
+    // Primary deployment tuple: (bytes32 salt, uint256 fundingAmount, address implementationContract, bytes initializeCalldata)
+    const [salt, , primaryImplementation] = primaryDeployment as [
+      string,
+      bigint,
+      Address,
+      string,
+    ]
+
+    // Secondary deployment tuple: (uint256 fundingAmount, address implementationContract, bytes addInitializeCalldata, bool addConstructor, bytes constructorParams)
+    const [, secondaryImplementation] = secondaryDeployment as [
+      bigint,
+      Address,
+      string,
+      boolean,
+      string,
+    ]
+
+    if (!primaryImplementation || !secondaryImplementation) {
+      return null
+    }
+
+    return {
+      salt,
+      primaryImplementation,
+      secondaryImplementation,
+      postDeploymentModule: postDeploymentModule as Address,
+      initializationCalldata: postDeploymentModuleCalldata as string,
+    }
+  } catch (error) {
+    console.error('Failed to decode LSP23 deployment calldata:', error)
+    return null
+  }
+}
+
+/**
+ * Decode deployERC1167Proxies output to get deployed addresses
+ *
+ * Returns: (address primaryContractAddress, address secondaryContractAddress)
+ */
+export function decodeDeploymentOutput(output: string): {
+  profileAddress: Address
+  urdAddress: Address
+} | null {
+  try {
+    const decoded = decodeAbiParameters(
+      parseAbiParameters('address, address'),
+      output as `0x${string}`
+    )
+
+    return {
+      profileAddress: decoded[0],
+      urdAddress: decoded[1],
+    }
+  } catch (error) {
+    console.error('Failed to decode LSP23 deployment output:', error)
+    return null
+  }
+}
+
+/**
+ * Extract controller addresses from initialization calldata
+ *
+ * The initializationCalldata contains a setDataBatch call that sets up controller permissions.
+ * Function: setDataBatch(bytes32[] dataKeys, bytes[] dataValues)
+ *
+ * The dataKeys contain entries like:
+ * - AddressPermissions:Permissions:<controller-address>
+ *
+ * We extract controller addresses from these keys.
+ */
+export function extractControllersFromInitCalldata(
+  initializationCalldata: string
+): Address[] {
+  try {
+    if (!initializationCalldata || initializationCalldata === '0x') {
+      return []
+    }
+
+    // The postDeploymentModuleCalldata is raw ABI-encoded (bytes32[], bytes[])
+    // No function selector - decode directly
+    const decoded = decodeAbiParameters(
+      parseAbiParameters('bytes32[], bytes[]'),
+      initializationCalldata as `0x${string}`
+    )
+
+    const [dataKeys, dataValues] = decoded
+    const controllers: Address[] = []
+
+    // Look for AddressPermissions[] keys
+    // The key is 0xdf30dba06db6a30e65354d9a64c60986 followed by zeros
+    // The controller address is in the corresponding value at the same index (encoded as bytes)
+    const ADDRESS_PERMISSIONS_ARRAY_PREFIX =
+      '0xdf30dba06db6a30e65354d9a64c60986'
+
+    for (let i = 0; i < dataKeys.length; i++) {
+      const keyStr = dataKeys[i].toLowerCase()
+      if (keyStr.startsWith(ADDRESS_PERMISSIONS_ARRAY_PREFIX)) {
+        // The value contains the controller address
+        const value = dataValues[i]
+
+        // Convert to hex if it's not already
+        const valueHex = isHex(value) ? value : bytesToHex(value as Uint8Array)
+
+        // The value should be a 20-byte address (40 hex chars + 0x = 42 total)
+        // or possibly 32 bytes with padding
+        if (valueHex.length === 42) {
+          // Exactly 20 bytes - this is the address
+          const addr = valueHex as Address
+          if (
+            addr !== '0x0000000000000000000000000000000000000000' &&
+            !controllers.some((c) => c.toLowerCase() === addr.toLowerCase())
+          ) {
+            controllers.push(addr)
+          }
+        }
+      }
+    }
+
+    return controllers
+  } catch (error) {
+    console.error('Failed to extract controllers from init calldata:', error)
+    return []
+  }
+}
+
+/**
+ * Hypersync query configuration for LSP23 deployments
+ */
+export interface HypersyncQueryConfig {
+  /**
+   * Controller addresses (derived keys) that deployed profiles
+   * We only want LSP23 data for profiles WE created, not imported
+   */
+  controllerAddresses?: Address[]
+
+  /**
+   * Profile addresses to query deployment data for
+   * More efficient than querying by controllers when we already know the profiles
+   */
+  profileAddresses?: Address[]
+
+  /**
+   * Starting block (0 for genesis)
+   */
+  fromBlock?: number
+
+  /**
+   * Ending block (undefined for latest)
+   */
+  toBlock?: number
+
+  /**
+   * Chain ID to query
+   */
+  chainId: number
+}
+
+/**
+ * Build Hypersync query to find LSP23 deployments
+ *
+ * Strategy 1 (by profileAddresses - RECOMMENDED):
+ * Query CREATE2 traces where the created address matches our profile addresses.
+ * Then filter transactions to LSP23 factory and verify deployer is one of our controllers.
+ * This is more efficient when we already know the profile addresses from GraphQL.
+ *
+ * Strategy 2 (by controllerAddresses - LEGACY):
+ * Query transactions TO the LSP23 factory FROM our controller addresses.
+ * This scans the entire chain history for all deployments by our controllers.
+ */
+export function buildLSP23DeploymentQuery(config: HypersyncQueryConfig) {
+  const {
+    controllerAddresses,
+    profileAddresses,
+    fromBlock = 0,
+    toBlock,
+    chainId,
+  } = config
+
+  // Prefer querying by profile addresses (more efficient)
+  if (profileAddresses && profileAddresses.length > 0) {
+    return {
+      from_block: fromBlock,
+      to_block: toBlock,
+      // Query CREATE2 traces where the created address is one of our profiles
+      traces: [
+        {
+          type: ['create2'],
+          to: profileAddresses.map((addr) => addr.toLowerCase()),
+        },
+      ],
+      // Also get the transactions to verify they're to the LSP23 factory
+      transactions: [
+        {
+          to: [LSP23_FACTORY_ADDRESS.toLowerCase()],
+        },
+      ],
+      field_selection: {
+        transaction: ['hash', 'from', 'to', 'input', 'output', 'block_number'],
+        trace: ['transaction_hash', 'type', 'from', 'to'],
+        block: ['number', 'timestamp'],
+      },
+      include_all_blocks: false,
+    }
+  }
+
+  // Fall back to querying by controller addresses (less efficient)
+  if (controllerAddresses && controllerAddresses.length > 0) {
+    return {
+      from_block: fromBlock,
+      to_block: toBlock,
+      // Query transactions to the LSP23 factory from our controllers
+      transactions: [
+        {
+          from: controllerAddresses.map((addr) => addr.toLowerCase()),
+          to: [LSP23_FACTORY_ADDRESS.toLowerCase()],
+        },
+      ],
+      // Also get traces to see the CREATE2 operations
+      traces: [
+        {
+          type: ['create2'],
+          // No filter on 'to' - we'll match by transaction hash
+        },
+      ],
+      field_selection: {
+        transaction: ['hash', 'from', 'to', 'input', 'output', 'block_number'],
+        trace: ['transaction_hash', 'type', 'from', 'to'],
+        block: ['number', 'timestamp'],
+      },
+      include_all_blocks: false,
+    }
+  }
+
+  throw new Error(
+    'Either profileAddresses or controllerAddresses must be provided'
+  )
+}
+
+/**
+ * Parse Hypersync response to extract LSP23 deployment data
+ * @param response - Hypersync API response
+ * @param chainId - Chain ID
+ * @param controllerAddresses - Optional list of controller addresses to filter by (only return deployments from these deployers)
+ */
+export function parseLSP23DeploymentsFromHypersync(
+  response: any,
+  chainId: number,
+  controllerAddresses?: Address[]
+): LSP23DeploymentData[] {
+  const deployments: LSP23DeploymentData[] = []
+
+  if (!response?.data) {
+    return deployments
+  }
+
+  // Build a map of block number -> timestamp
+  const blockTimestamps = new Map<number, number>()
+  for (const block of response.data.blocks || []) {
+    blockTimestamps.set(block.number, block.timestamp)
+  }
+
+  // Build a map of transaction hash -> transaction data
+  const txMap = new Map<string, any>()
+  for (const tx of response.data.transactions || []) {
+    if (
+      tx.to?.toLowerCase() === LSP23_FACTORY_ADDRESS.toLowerCase() &&
+      tx.input?.startsWith(DEPLOY_ERC1167_PROXIES_SELECTOR)
+    ) {
+      txMap.set(tx.hash.toLowerCase(), tx)
+    }
+  }
+
+  // Process traces to find CREATE2 operations
+  const create2Traces = new Map<string, Address>() // txHash -> created profile address
+
+  for (const trace of response.data.traces || []) {
+    if (trace.type === 'create2' && trace.to) {
+      create2Traces.set(
+        trace.transaction_hash.toLowerCase(),
+        trace.to as Address
+      )
+    }
+  }
+
+  // Create a Set of lowercase controller addresses for efficient filtering
+  const controllerSet = controllerAddresses
+    ? new Set(controllerAddresses.map((addr) => addr.toLowerCase()))
+    : null
+
+  // Match transactions with traces
+  for (const [txHash, profileAddress] of create2Traces) {
+    const tx = txMap.get(txHash)
+    if (!tx) continue
+
+    // If controller filtering is enabled, verify the deployer is one of our controllers
+    if (controllerSet && !controllerSet.has(tx.from.toLowerCase())) {
+      continue
+    }
+
+    // Decode the transaction
+    const decodedInput = decodeDeploymentCalldata(tx.input)
+    const decodedOutput = tx.output ? decodeDeploymentOutput(tx.output) : null
+
+    if (!decodedInput || !decodedOutput) continue
+
+    // Get block timestamp for this transaction
+    const blockTimestamp = blockTimestamps.get(tx.block_number) || 0
+
+    deployments.push({
+      profileAddress: decodedOutput.profileAddress,
+      urdAddress: decodedOutput.urdAddress,
+      deployerAddress: tx.from as Address, // The controller that deployed this profile
+      salt: decodedInput.salt,
+      primaryImplementation: decodedInput.primaryImplementation,
+      secondaryImplementation: decodedInput.secondaryImplementation,
+      postDeploymentModule: decodedInput.postDeploymentModule,
+      initializationCalldata: decodedInput.initializationCalldata,
+      deploymentCalldata: tx.input, // Full calldata to deployERC1167Proxies
+      transactionHash: tx.hash,
+      blockNumber: BigInt(tx.block_number),
+      blockTimestamp, // Unix timestamp of the block
+      chainId,
+    })
+  }
+
+  return deployments
+}
+
+/**
+ * Note: Hypersync querying should be done server-side to protect HYPERSYNC_TOKEN.
+ * Use the wallet-app API endpoint /api/lsp23Deployments instead of calling Hypersync directly.
+ *
+ * This module exports:
+ * - buildLSP23DeploymentQuery() - Build the Hypersync query structure
+ * - parseLSP23DeploymentsFromHypersync() - Parse Hypersync response
+ * - decodeDeploymentCalldata() - Decode LSP23 transaction input
+ * - decodeDeploymentOutput() - Decode LSP23 transaction output
+ */