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

package/src/core/dataModel.ts

@@ -0,0 +1,888 @@
+// Core data model implementation
+import { batch, effect, type Signal, signal } from '@preact/signals-core'
+import type { Address, Hex } from 'viem'
+import { hexToBigInt, isHex, size, slice } from 'viem'
+import type {
+  AddressState,
+  DataKey,
+  DataModelOptions,
+  DecoderResult,
+  EnhancedInfo,
+  IDataModel,
+  IDataModelConsumer,
+  TransactionState,
+} from '../types'
+import { collectDataKeys } from './addressCollector'
+
+// Helper type for deep freezing - kept internal to this module
+type DeepReadonly<T> = T extends (infer R)[]
+  ? DeepReadonlyArray<R>
+  : T extends (...args: unknown[]) => unknown
+    ? T
+    : T extends object
+      ? DeepReadonlyObject<T>
+      : T
+
+interface DeepReadonlyArray<T> extends ReadonlyArray<DeepReadonly<T>> {}
+
+type DeepReadonlyObject<T> = {
+  readonly [P in keyof T]: DeepReadonly<T[P]>
+}
+
+/**
+ * Deep freeze an object to prevent any modifications
+ * Returns the same object if it's already frozen
+ */
+export function deepFreeze<T>(obj: T): T {
+  // Primitives and already frozen objects don't need processing
+  if (obj === null || typeof obj !== 'object' || Object.isFrozen(obj)) {
+    return obj
+  }
+
+  // Freeze the object itself
+  Object.freeze(obj)
+
+  // Recursively freeze all properties
+  for (const prop of Object.getOwnPropertyNames(obj)) {
+    const value = (obj as Record<string, unknown>)[prop]
+    if (value !== null && typeof value === 'object') {
+      deepFreeze(value)
+    }
+  }
+
+  return obj
+}
+
+export interface TransactionKey {
+  hash: Hex
+  decoderIndex?: number // For batch transactions
+}
+
+export class DataModel implements IDataModel {
+  // Nested map structure: Address -> (TokenId | null) -> Signal
+  private dataSignals = new Map<Address, Signal<AddressState>>()
+
+  // Transaction signals: Hash -> (DecoderIndex | null) -> Signal
+  private transactionSignals = new Map<
+    Hex,
+    Map<number | null, Signal<TransactionState>>
+  >()
+
+  // Keep track of unique transaction hashes in order
+  private transactionOrder: Array<Hex> = []
+
+  private options: DataModelOptions
+
+  // Track pending resolved data updates
+  private pendingResolvedUpdate = false
+
+  constructor(options: DataModelOptions = {}) {
+    this.options = options
+  }
+
+  /**
+   * Extract a 20-byte address from a potentially 32-byte hex value
+   * If the input is 32 bytes, validates it's zero-padded and takes the rightmost 20 bytes
+   * If the input is 20 bytes, returns it as-is
+   */
+  private extractAddress(hex: Hex): Address {
+    if (!isHex(hex)) {
+      throw new Error(`Invalid hex value: ${hex}`)
+    }
+
+    const bytes = size(hex)
+
+    if (bytes === 32) {
+      // Check if the first 12 bytes are zeros (valid padding)
+      const first12Bytes = slice(hex, 0, 12)
+      if (hexToBigInt(first12Bytes) !== 0n) {
+        throw new Error(
+          `Invalid 32-byte address: first 12 bytes must be zero for a padded address, got ${first12Bytes}`
+        )
+      }
+      // 32 bytes with valid padding - extract the rightmost 20 bytes
+      return slice(hex, 12, 32) as Address
+    }
+    if (bytes === 20) {
+      // 20 bytes - already a proper address
+      return hex as Address
+    }
+    throw new Error(`Invalid address length: ${bytes} bytes`)
+  }
+
+  /**
+   * Get or create a signal for a specific key
+   */
+  private getOrCreateSignal(key: DataKey): Signal<AddressState> {
+    let sig = this.dataSignals.get(key)
+    if (!sig) {
+      sig = signal<AddressState>({
+        loading: false,
+        data: undefined,
+        error: undefined,
+        lastUpdated: undefined,
+      })
+
+      this.dataSignals.set(key, sig)
+
+      // Notify about missing keys (for external fetching)
+      if (this.options.onMissingKeys) {
+        // Debounce notifications
+        setTimeout(() => {
+          const missing = this.getMissingKeys()
+          if (missing.length > 0) {
+            this.options.onMissingKeys?.(missing)
+          }
+        }, 0)
+      }
+    }
+
+    return sig
+  }
+
+  /**
+   * Extract transaction key from transaction JSON
+   */
+  private getTransactionKey(transaction: unknown): TransactionKey {
+    if (!transaction || typeof transaction !== 'object') {
+      throw new Error('Transaction must be an object')
+    }
+
+    const tx = transaction as Record<string, unknown>
+    if (!tx.hash && !tx.transactionHash) {
+      throw new Error('Transaction must have hash or transactionHash')
+    }
+
+    return {
+      hash: (tx.hash || tx.transactionHash) as Hex,
+      decoderIndex: tx.decoderIndex ? (tx.decoderIndex as number) : undefined,
+    }
+  }
+
+  /**
+   * Get or create the inner map for a transaction hash
+   */
+  private getOrCreateTransactionMap(
+    hash: Hex
+  ): Map<number | null, Signal<TransactionState>> {
+    const normalizedHash = hash.toLowerCase() as Hex
+    let map = this.transactionSignals.get(normalizedHash)
+    if (!map) {
+      map = new Map()
+      this.transactionSignals.set(normalizedHash, map)
+    }
+    return map
+  }
+
+  /**
+   * Add one or more transactions to the model
+   * Collects all addresses from all transactions and marks them as loading
+   */
+  addTransactions<T extends unknown | unknown[]>(
+    jsonTransactions: T
+  ): T extends unknown[]
+    ? Array<Signal<TransactionState>>
+    : Signal<TransactionState> {
+    // Normalize input to array
+    const transactions = Array.isArray(jsonTransactions)
+      ? jsonTransactions
+      : [jsonTransactions]
+    const isSingle = !Array.isArray(jsonTransactions)
+    // First, collect all addresses from all transactions
+    const allAddresses = new Set<string>()
+    const transactionAddresses: DataKey[][] = []
+
+    for (const tx of transactions) {
+      const addresses = collectDataKeys(tx)
+      transactionAddresses.push(addresses)
+
+      // Add to set for deduplication
+      for (const addr of addresses) {
+        allAddresses.add(addr)
+      }
+    }
+
+    // Convert back to DataKey array
+    const uniqueAddresses = Array.from(allAddresses) as DataKey[]
+
+    // Mark all addresses as loading at once
+    if (uniqueAddresses.length > 0) {
+      this.setLoading(uniqueAddresses)
+    }
+
+    // Now add each transaction
+    const results = transactions.map((tx, index) => {
+      const key = this.getTransactionKey(tx)
+      const normalizedHash = key.hash.toLowerCase() as Hex
+      const decoderIndex = key.decoderIndex || null
+
+      const isNewHash = !this.transactionSignals.has(normalizedHash)
+      const txMap = this.getOrCreateTransactionMap(normalizedHash)
+
+      if (txMap.has(decoderIndex)) {
+        throw new Error(
+          `Transaction already exists: ${normalizedHash}:${decoderIndex || 0}`
+        )
+      }
+
+      // Create frozen data once
+      const frozenData = deepFreeze(
+        structuredClone(tx)
+      ) as unknown as DeepReadonly<DecoderResult>
+
+      // Create reactive transaction with frozen data
+      const sig = signal<TransactionState>({
+        data: frozenData,
+        loading: false,
+        addresses: Object.freeze([...transactionAddresses[index]]) as DataKey[],
+        error: undefined,
+        lastUpdated: Date.now(),
+        resolvedData: frozenData, // Start with the same frozen data
+        addressesResolved: false,
+      })
+
+      txMap.set(decoderIndex, sig)
+
+      // Track transaction order (only for new hashes)
+      if (isNewHash) {
+        this.transactionOrder.push(normalizedHash)
+      }
+
+      // Notify about new transaction
+      if (this.options.onNewTransaction) {
+        this.options.onNewTransaction(tx)
+      }
+
+      return sig
+    })
+
+    // Return single signal if input was single, otherwise return array
+    return (isSingle ? results[0] : results) as T extends unknown[]
+      ? Array<Signal<TransactionState>>
+      : Signal<TransactionState>
+  }
+
+  /**
+   * Get an existing transaction signal (returns undefined if not found)
+   */
+  getTransaction(
+    jsonTransaction: unknown
+  ): Signal<TransactionState> | undefined {
+    const key = this.getTransactionKey(jsonTransaction)
+    const normalizedHash = key.hash.toLowerCase() as Hex
+    const decoderIndex = key.decoderIndex || null
+
+    const txMap = this.transactionSignals.get(normalizedHash)
+    if (!txMap) {
+      return undefined
+    }
+
+    return txMap.get(decoderIndex)
+  }
+
+  /**
+   * Get transaction by hash and decoder index
+   */
+  getTransactionByKey(
+    hash: Hex,
+    decoderIndex?: number
+  ): Signal<TransactionState> | undefined {
+    const normalizedHash = hash.toLowerCase() as Hex
+    const txMap = this.transactionSignals.get(normalizedHash)
+    if (!txMap) {
+      return undefined
+    }
+
+    return txMap.get(decoderIndex || null)
+  }
+
+  /**
+   * Update a transaction's data and re-collect addresses
+   * Useful after async decoding completes
+   */
+  updateTransactionData(
+    hash: Hex,
+    newData: DecoderResult,
+    decoderIndex?: number
+  ): void {
+    const normalizedHash = hash.toLowerCase() as Hex
+    const txMap = this.transactionSignals.get(normalizedHash)
+    if (!txMap) return
+
+    const sig = txMap.get(decoderIndex ?? null)
+    if (!sig) return
+
+    // Re-collect addresses with the new decoded data
+    const newAddresses = collectDataKeys(newData, true, [
+      ...sig.value.addresses,
+    ])
+
+    // Create frozen data once
+    const frozenData = deepFreeze(structuredClone(newData))
+
+    // Update the signal with frozen data
+    sig.value = {
+      ...sig.value,
+      data: frozenData,
+      addresses: Object.freeze([...newAddresses]) as DataKey[],
+      lastUpdated: Date.now(),
+      // Start with the current data, will be enhanced when addresses load
+      resolvedData: frozenData,
+      addressesResolved: false,
+    }
+
+    // Mark any new addresses as loading
+    this.setLoading(newAddresses)
+
+    // Check if we can create resolved data immediately
+    queueMicrotask(() => {
+      this.updateResolvedTransactionData()
+    })
+  }
+
+  /**
+   * Get all decoded transactions for a hash by index (insertion order)
+   */
+  getTransactionsByIndex(
+    index: number
+  ): Map<number | null, Signal<TransactionState>> | undefined {
+    if (index < 0 || index >= this.transactionOrder.length) {
+      return undefined
+    }
+
+    const hash = this.transactionOrder[index]
+    return this.transactionSignals.get(hash)
+  }
+
+  /**
+   * Get transaction hash by index
+   */
+  getTransactionHashByIndex(index: number): Hex | undefined {
+    return this.transactionOrder[index]
+  }
+
+  /**
+   * Get number of unique transaction hashes
+   */
+  getTransactionCount(): number {
+    return this.transactionOrder.length
+  }
+
+  /**
+   * Get number of decoded transactions for a specific hash
+   */
+  getDecodedCount(hash: Hex): number {
+    const normalizedHash = hash.toLowerCase() as Hex
+    const txMap = this.transactionSignals.get(normalizedHash)
+    return txMap ? txMap.size : 0
+  }
+
+  /**
+   * Get all decoded transactions for a specific hash
+   */
+  getDecodedTransactions(hash: Hex): Array<Signal<TransactionState>> {
+    const normalizedHash = hash.toLowerCase() as Hex
+    const txMap = this.transactionSignals.get(normalizedHash)
+    return txMap ? Array.from(txMap.values()) : []
+  }
+
+  /**
+   * Get address signal (alias for getSignal for clearer API)
+   */
+  getAddress(address: DataKey): Signal<AddressState> {
+    return this.getSignal(address)
+  }
+
+  /**
+   * Inject data into the model
+   * Can be called multiple times to progressively add/update data
+   */
+  injectData(dataList: EnhancedInfo[]): void {
+    batch(() => {
+      for (const data of dataList) {
+        const key: DataKey = data.tokenId
+          ? `${data.address as Hex}:${data.tokenId}`
+          : (data.address as Hex)
+
+        const sig = this.getOrCreateSignal(key)
+
+        // Update the signal with frozen data
+        sig.value = {
+          loading: false,
+          data: deepFreeze(structuredClone(data)),
+          error: undefined,
+          lastUpdated: Date.now(),
+        }
+      }
+    })
+
+    // After the batch, check if any transactions need their resolved data updated
+    this.updateResolvedTransactionData()
+  }
+
+  /**
+   * Update a single item
+   */
+  updateData(data: EnhancedInfo): void {
+    const key: DataKey = data.tokenId
+      ? `${data.address as Hex}:${data.tokenId}`
+      : (data.address as Hex)
+
+    const sig = this.getOrCreateSignal(key)
+
+    sig.value = {
+      loading: false,
+      data: deepFreeze(structuredClone(data)),
+      error: undefined,
+      lastUpdated: Date.now(),
+    }
+
+    // Debounce the resolved data update using a microtask
+    if (!this.pendingResolvedUpdate) {
+      this.pendingResolvedUpdate = true
+      queueMicrotask(() => {
+        this.pendingResolvedUpdate = false
+        this.updateResolvedTransactionData()
+      })
+    }
+  }
+
+  /**
+   * Mark keys as loading
+   */
+  setLoading(keys: DataKey[]): void {
+    batch(() => {
+      for (const key of keys) {
+        const sig = this.getOrCreateSignal(key)
+        sig.value = { ...sig.value, loading: true }
+      }
+    })
+  }
+
+  /**
+   * Mark a key as errored
+   */
+  setError(key: DataKey, error: string): void {
+    const sig = this.getOrCreateSignal(key)
+    sig.value = {
+      loading: false,
+      data: undefined,
+      error,
+      lastUpdated: Date.now(),
+    }
+  }
+
+  /**
+   * Get signal for a key (creates one if doesn't exist)
+   */
+  getSignal(key: DataKey): Signal<AddressState> {
+    return this.getOrCreateSignal(key)
+  }
+
+  /**
+   * Subscribe to key updates
+   */
+  subscribe(key: DataKey, callback: (state: AddressState) => void): () => void {
+    const sig = this.getSignal(key)
+    return effect(() => callback(sig.value))
+  }
+
+  /**
+   * Get current state of a key
+   */
+  getState(key: DataKey): AddressState {
+    return this.getSignal(key).value
+  }
+
+  /**
+   * Get all keys that have no data
+   */
+  getMissingKeys(): DataKey[] {
+    const missingKeys: DataKey[] = []
+
+    for (const [key] of this.dataSignals) {
+      missingKeys.push(key as Hex)
+    }
+
+    return missingKeys
+  }
+
+  /**
+   * Get all keys currently loading
+   */
+  getLoadingKeys(): DataKey[] {
+    const loadingKeys: DataKey[] = []
+
+    for (const [key, sig] of this.dataSignals) {
+      if (sig.value.loading) {
+        loadingKeys.push(key as Hex)
+      }
+    }
+
+    return loadingKeys
+  }
+
+  /**
+   * Check if we have data for a key
+   */
+  hasData(key: DataKey): boolean {
+    const sig = this.dataSignals.get(key)
+    return sig ? sig.value.data !== undefined : false
+  }
+
+  /**
+   * Clear all data
+   */
+  clear(): void {
+    batch(() => {
+      // Clear address data
+      for (const sig of this.dataSignals.values()) {
+        sig.value = {
+          loading: false,
+          data: undefined,
+          error: undefined,
+          lastUpdated: undefined,
+        }
+      }
+
+      // Clear transaction data
+      for (const txMap of this.transactionSignals.values()) {
+        for (const sig of txMap.values()) {
+          sig.value = {
+            ...sig.value,
+            loading: false,
+            error: undefined,
+          }
+        }
+      }
+    })
+  }
+
+  /**
+   * Remove specific keys from cache
+   */
+  remove(keys: DataKey[]): void {
+    for (const key of keys) {
+      this.dataSignals.delete(key)
+    }
+  }
+
+  /**
+   * Get all cached keys
+   */
+  getAllKeys(): ReadonlyArray<DataKey> {
+    const keys: DataKey[] = []
+
+    for (const [key] of this.dataSignals) {
+      keys.push(key as Hex)
+    }
+
+    return Object.freeze(keys)
+  }
+
+  /**
+   * Get all data as a plain object (for debugging/serialization)
+   */
+  getAllData(): Readonly<Record<string, AddressState>> {
+    const result: Record<string, AddressState> = {}
+
+    for (const [key, sig] of this.dataSignals) {
+      result[key] = sig.value
+    }
+
+    return Object.freeze(result)
+  }
+
+  /**
+   * Get all transaction data (for debugging)
+   */
+  getAllTransactions(): Readonly<Record<string, TransactionState>> {
+    const result: Record<string, TransactionState> = {}
+
+    for (const [hash, txMap] of this.transactionSignals) {
+      for (const [decoderIndex, sig] of txMap) {
+        const key = decoderIndex === null ? hash : `${hash}:${decoderIndex}`
+        result[key] = sig.value
+      }
+    }
+
+    return Object.freeze(result)
+  }
+
+  /**
+   * Get all transactions in order (returns all decoded transactions grouped by hash)
+   */
+  getTransactionsInOrder(): Array<{
+    hash: Hex
+    transactions: Array<Signal<TransactionState>>
+  }> {
+    const result: Array<{
+      hash: Hex
+      transactions: Array<Signal<TransactionState>>
+    }> = []
+
+    for (const hash of this.transactionOrder) {
+      const txMap = this.transactionSignals.get(hash)
+      if (txMap) {
+        result.push({
+          hash,
+          transactions: Array.from(txMap.values()),
+        })
+      }
+    }
+
+    return result
+  }
+
+  /**
+   * Create a resolved version of transaction data with all addresses populated
+   */
+  createResolvedTransactionData(
+    transactionData: DecoderResult,
+    addresses: ReadonlyArray<DataKey>
+  ): DecoderResult {
+    // Clone the transaction data to avoid modifying the original
+    const resolved = structuredClone(transactionData)
+
+    // Create a map of address data for quick lookup
+    const addressMap = new Map<string, EnhancedInfo>()
+
+    for (const key of addresses) {
+      const addressData = this.getData(key)
+      if (addressData) {
+        addressMap.set(key.toLowerCase(), addressData)
+      }
+    }
+
+    // Use the path-based approach to replace addresses
+    this.replaceAddressesWithPaths(resolved, addressMap)
+
+    // Deep freeze the result
+    return deepFreeze(resolved)
+  }
+
+  /**
+   * Replace addresses using path information (similar to collectAddressesWithPaths)
+   */
+  private replaceAddressesWithPaths(
+    data: unknown,
+    addressMap: Map<string, EnhancedInfo>
+  ): void {
+    function traverse(
+      obj: unknown,
+      path: Array<string | number> = [],
+      parent?: Record<string, unknown> | unknown[]
+    ): void {
+      // Handle string case first
+      if (typeof obj === 'string' && obj.startsWith('0x')) {
+        // Use regex to detect zero-padded addresses
+        const isPaddedAddress = /^0x0*([a-fA-F0-9]{40})$/.test(obj)
+
+        if (isPaddedAddress || (isHex(obj) && size(obj as Hex) === 20)) {
+          // Extract the actual address (remove padding if needed)
+          const address = isPaddedAddress
+            ? (obj.replace(/^0x0*([a-fA-F0-9]{40})$/, '0x$1') as Address)
+            : obj
+
+          // Skip if too many zeros (likely not an address)
+          if (
+            address
+              .slice(2)
+              .split('')
+              .filter((c: string) => c === '0').length > 10
+          ) {
+            return
+          }
+
+          // Check for tokenId in parent
+          const currentKey = path[path.length - 1]
+          const tokenId =
+            parent &&
+            !Array.isArray(parent) &&
+            'tokenId' in parent &&
+            parent.tokenId
+              ? (parent.tokenId as Hex)
+              : undefined
+
+          // Look up the address data
+          let addressData: EnhancedInfo | undefined
+          if (tokenId) {
+            const compositeKey = `${address.toLowerCase()}_${tokenId.toLowerCase()}`
+            addressData = addressMap.get(compositeKey)
+          } else {
+            addressData = addressMap.get(address.toLowerCase())
+          }
+
+          // Replace the address with the data if found
+          if (addressData && parent) {
+            if (Array.isArray(parent) && typeof currentKey === 'number') {
+              parent[currentKey] = addressData
+            } else if (
+              !Array.isArray(parent) &&
+              typeof currentKey === 'string'
+            ) {
+              parent[currentKey] = addressData
+            }
+          }
+        }
+        return
+      }
+
+      if (!obj || typeof obj !== 'object') return
+
+      if (Array.isArray(obj)) {
+        for (let index = 0; index < obj.length; index++) {
+          traverse(obj[index], path.concat([index]), obj)
+        }
+      } else {
+        const record = obj as Record<string, unknown>
+        for (const [key, value] of Object.entries(record)) {
+          traverse(value, path.concat([key]), record)
+        }
+      }
+    }
+
+    traverse(data)
+  }
+
+  /**
+   * Update resolved transaction data for all transactions where addresses are loaded
+   */
+  private updateResolvedTransactionData(): void {
+    // Go through all transactions
+    for (const [_hash, txMap] of this.transactionSignals) {
+      for (const [_decoderIndex, signal] of txMap) {
+        const currentState = signal.value
+
+        // Skip if already resolved or if no addresses
+        if (
+          currentState.addressesResolved ||
+          currentState.addresses.length === 0
+        ) {
+          continue
+        }
+
+        // Check if all addresses are loaded
+        let allAddressesLoaded = true
+        for (const addressKey of currentState.addresses) {
+          const addressState = this.getState(addressKey)
+          if (addressState.loading || !addressState.data) {
+            allAddressesLoaded = false
+            break
+          }
+        }
+
+        // If all addresses are loaded, create resolved data
+        if (allAddressesLoaded) {
+          const resolvedData = this.createResolvedTransactionData(
+            currentState.data as DecoderResult,
+            currentState.addresses
+          )
+
+          // Update the transaction state
+          signal.value = {
+            ...currentState,
+            resolvedData: resolvedData as DeepReadonly<DecoderResult>,
+            addressesResolved: true,
+            lastUpdated: Date.now(),
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Get data by key - convenience method that handles both 20 and 32 byte addresses
+   */
+  getData(key: DataKey): DeepReadonly<EnhancedInfo> | undefined {
+    return this.getState(key).data
+  }
+
+  /**
+   * Check if a key is loading
+   */
+  isLoading(key: DataKey): boolean {
+    return this.getState(key).loading
+  }
+
+  /**
+   * Get error for a key
+   */
+  getError(key: DataKey): string | undefined {
+    return this.getState(key).error
+  }
+}
+
+/**
+ * Create a read-only consumer proxy that only exposes safe read methods
+ */
+export function createConsumerProxy(model: DataModel): IDataModelConsumer {
+  const consumerMethods = [
+    // Transaction read methods
+    'getTransaction',
+    'getTransactionByKey',
+    'getTransactionsByIndex',
+    'getTransactionHashByIndex',
+    'getTransactionCount',
+    'getDecodedCount',
+    'getDecodedTransactions',
+    'getTransactionsInOrder',
+    // Address read methods
+    'getAddress',
+    'getSignal',
+    'subscribe',
+    'getState',
+    'hasData',
+    'getData',
+    'isLoading',
+    'getError',
+    // Collection read methods
+    'getAllKeys',
+    'getAllData',
+    'getAllTransactions',
+  ]
+
+  const proxy = new Proxy(model, {
+    get(target, prop, receiver) {
+      if (typeof prop === 'string' && consumerMethods.includes(prop)) {
+        const value = Reflect.get(target, prop, receiver)
+        if (typeof value === 'function') {
+          return value.bind(target)
+        }
+        return value
+      }
+      // Block access to all other properties and methods
+      return undefined
+    },
+    set() {
+      return false // Prevent modifications
+    },
+    deleteProperty() {
+      return false
+    },
+    defineProperty() {
+      return false
+    },
+    setPrototypeOf() {
+      return false
+    },
+  }) as IDataModelConsumer
+
+  return proxy
+}
+
+/**
+ * Create a secure DataModel instance
+ * Freezes the prototype to prevent prototype pollution attacks
+ */
+export function createDataModel(options?: DataModelOptions): IDataModel {
+  const model = new DataModel(options)
+
+  // Freeze the prototype to prevent modification
+  Object.freeze(DataModel.prototype)
+
+  // Freeze the constructor
+  Object.freeze(DataModel)
+
+  return model
+}