refactor: consistently store abi metadata against contract class

Author: boblat

src/abi-metadata.ts

@@ -1,9 +1,8 @@
-import type { Contract } from '@algorandfoundation/algorand-typescript'
 import type { AbiMethodConfig, BareMethodConfig, CreateOptions, OnCompleteActionStr } from '@algorandfoundation/algorand-typescript/arc4'
 import js_sha512 from 'js-sha512'
 import type { TypeInfo } from './encoders'
+import { Contract } from './impl/contract'
 import { getArc4TypeName as getArc4TypeNameForARC4Encoded } from './impl/encoded-types'
-import type { DeliberateAny } from './typescript-helpers'
 
 export interface AbiMetadata {
   methodName: string
@@ -14,40 +13,15 @@ export interface AbiMetadata {
   onCreate?: CreateOptions
   allowActions?: OnCompleteActionStr[]
 }
-const AbiMetaSymbol = Symbol('AbiMetadata')
-const overwrittenMetadata: Array<readonly [Contract | { new (): Contract }, Record<string, AbiMetadata>]> = []
+export const AbiMetaSymbol = Symbol('AbiMetadata')
 export const isContractProxy = Symbol('isContractProxy')
+const metadataStore: Map<{ new (): Contract }, Record<string, AbiMetadata>> = new Map()
 export const attachAbiMetadata = (contract: { new (): Contract }, methodName: string, metadata: AbiMetadata): void => {
-  const metadatas: Record<string, AbiMetadata> = (AbiMetaSymbol in contract ? contract[AbiMetaSymbol] : {}) as Record<string, AbiMetadata>
-
-  // classes inherited from the same parent shares the same metadata object stored in `AbiMetaSymbol`
-  // to prevent one subclass from overwriting the metadata of another subclass, we store the overwritten metadata in a separate array
-  if (metadatas[methodName]) {
-    let contractMetadatas = overwrittenMetadata.find(([c]) => c === contract)
-    if (!contractMetadatas) {
-      contractMetadatas = [contract, {}]
-      overwrittenMetadata.push(contractMetadatas)
-    }
-    contractMetadatas[1][methodName] = metadata
-  } else {
-    metadatas[methodName] = metadata
-  }
-  if (!(AbiMetaSymbol in contract)) {
-    Object.defineProperty(contract, AbiMetaSymbol, {
-      value: metadatas,
-      writable: true,
-      enumerable: true,
-    })
+  if (!metadataStore.has(contract)) {
+    metadataStore.set(contract, {})
   }
-}
-
-export const copyAbiMetadatas = <T extends Contract>(sourceContract: T, targetContract: T): void => {
-  const metadatas = getContractAbiMetadata(sourceContract)
-  Object.defineProperty(targetContract, AbiMetaSymbol, {
-    value: metadatas,
-    writable: true,
-    enumerable: false,
-  })
+  const metadatas: Record<string, AbiMetadata> = metadataStore.get(contract) as Record<string, AbiMetadata>
+  metadatas[methodName] = metadata
 }
 
 export const captureMethodConfig = <T extends Contract>(
@@ -61,23 +35,33 @@ export const captureMethodConfig = <T extends Contract>(
   metadata.allowActions = ([] as OnCompleteActionStr[]).concat(config?.allowActions ?? 'NoOp')
 }
 
-export const hasAbiMetadata = <T extends Contract>(contract: T): boolean => {
-  const contractClass = contract.constructor as { new (): T }
-  return (
-    Object.getOwnPropertySymbols(contractClass).some((s) => s.toString() === AbiMetaSymbol.toString()) || AbiMetaSymbol in contractClass
-  )
-}
-export const getContractAbiMetadata = <T extends Contract>(contract: T): Record<string, AbiMetadata> => {
-  const overwrittenMetadataEntry = overwrittenMetadata.find(([c]) => c === contract)
-  if ((contract as DeliberateAny)[AbiMetaSymbol]) {
-    return { ...((contract as DeliberateAny)[AbiMetaSymbol] as Record<string, AbiMetadata>), ...overwrittenMetadataEntry?.[1] }
+export const getContractAbiMetadata = <T extends Contract>(contract: T | { new (): T }): Record<string, AbiMetadata> => {
+  // Initialize result object to store merged metadata
+  const result: Record<string, AbiMetadata> = {}
+
+  // Get the contract's class
+  let currentClass = contract instanceof Contract ? (contract.constructor as { new (): T }) : contract
+
+  // Walk up the prototype chain
+  while (currentClass && currentClass.prototype) {
+    // Find metadata for current class
+    const currentMetadata = metadataStore.get(currentClass)
+
+    if (currentMetadata) {
+      // Merge metadata with existing result (don't override existing entries)
+      const classMetadata = currentMetadata
+      for (const [methodName, metadata] of Object.entries(classMetadata)) {
+        if (!(methodName in result)) {
+          result[methodName] = metadata
+        }
+      }
+    }
+
+    // Move up the prototype chain
+    currentClass = Object.getPrototypeOf(currentClass)
   }
-  const contractClass = contract.constructor as { new (): T }
-  const s = Object.getOwnPropertySymbols(contractClass).find((s) => s.toString() === AbiMetaSymbol.toString())
-  const metadatas: Record<string, AbiMetadata> = (
-    s ? (contractClass as DeliberateAny)[s] : AbiMetaSymbol in contractClass ? contractClass[AbiMetaSymbol] : {}
-  ) as Record<string, AbiMetadata>
-  return { ...metadatas, ...overwrittenMetadataEntry?.[1] }
+
+  return result
 }
 
 export const getContractMethodAbiMetadata = <T extends Contract>(contract: T, methodName: string): AbiMetadata => {

src/impl/contract.ts

@@ -1,10 +1,6 @@
-import type { arc4, bytes } from '@algorandfoundation/algorand-typescript'
-import { encodingUtil } from '@algorandfoundation/puya-ts'
-import { getArc4Selector, getContractMethodAbiMetadata } from '../abi-metadata'
+import type { arc4 } from '@algorandfoundation/algorand-typescript'
 import type { DeliberateAny } from '../typescript-helpers'
 import { BaseContract } from './base-contract'
-import { sha512_256 } from './crypto'
-import { Bytes } from './primitives'
 
 export class Contract extends BaseContract {
   static isArc4 = true
@@ -29,15 +25,3 @@ export function baremethod<TContract extends Contract>(_config?: arc4.BareMethod
     return target
   }
 }
-
-export const methodSelector = <TContract extends Contract>(
-  methodSignature: Parameters<typeof arc4.methodSelector>[0],
-  contract?: TContract,
-): bytes => {
-  if (typeof methodSignature === 'string') {
-    return sha512_256(Bytes(encodingUtil.utf8ToUint8Array(methodSignature))).slice(0, 4)
-  } else {
-    const abiMetadata = getContractMethodAbiMetadata(contract!, methodSignature.name)
-    return Bytes(getArc4Selector(abiMetadata))
-  }
-}

src/impl/method-selector.ts

@@ -0,0 +1,18 @@
+import type { arc4, bytes } from '@algorandfoundation/algorand-typescript'
+import { encodingUtil } from '@algorandfoundation/puya-ts'
+import { getArc4Selector, getContractMethodAbiMetadata } from '../abi-metadata'
+import type { Contract } from './contract'
+import { sha512_256 } from './crypto'
+import { Bytes } from './primitives'
+
+export const methodSelector = <TContract extends Contract>(
+  methodSignature: Parameters<typeof arc4.methodSelector>[0],
+  contract?: TContract,
+): bytes => {
+  if (typeof methodSignature === 'string') {
+    return sha512_256(Bytes(encodingUtil.utf8ToUint8Array(methodSignature))).slice(0, 4)
+  } else {
+    const abiMetadata = getContractMethodAbiMetadata(contract!, methodSignature.name)
+    return Bytes(getArc4Selector(abiMetadata))
+  }
+}

src/internal/arc4.ts

@@ -1,2 +1,3 @@
 export * from '@algorandfoundation/algorand-typescript/arc4'
-export { abimethod, baremethod, Contract, methodSelector } from '../impl/contract'
+export { abimethod, baremethod, Contract } from '../impl/contract'
+export { methodSelector } from '../impl/method-selector'

src/subcontexts/contract-context.ts

@@ -1,7 +1,7 @@
 import type { Account, Application, Asset, contract, LocalState } from '@algorandfoundation/algorand-typescript'
 import type { ARC4Encoded } from '@algorandfoundation/algorand-typescript/arc4'
 import type { AbiMetadata } from '../abi-metadata'
-import { copyAbiMetadatas, getArc4Selector, getContractAbiMetadata, getContractMethodAbiMetadata, isContractProxy } from '../abi-metadata'
+import { AbiMetaSymbol, getArc4Selector, getContractAbiMetadata, getContractMethodAbiMetadata, isContractProxy } from '../abi-metadata'
 import { BytesMap } from '../collections/custom-key-map'
 import { checkRoutingConditions } from '../context-helpers/context-util'
 import { lazyContext } from '../context-helpers/internal-context'
@@ -235,8 +235,11 @@ export class ContractContext {
             if (prop === isContractProxy) {
               return true
             }
-            const orig = Reflect.get(target, prop, receiver)
+            if (prop === AbiMetaSymbol) {
+              return isArc4 ? getContractAbiMetadata(target as Contract) : undefined
+            }
             const abiMetadata = isArc4 ? getContractMethodAbiMetadata(target as Contract, prop as string) : undefined
+            const orig = Reflect.get(target, prop, receiver)
             const isProgramMethod = prop === 'approvalProgram' || prop === 'clearStateProgram'
             const isAbiMethod = isArc4 && abiMetadata
             if (isAbiMethod || isProgramMethod) {
@@ -261,10 +264,6 @@ export class ContractContext {
 
         onConstructed(application, instance, getContractOptions(t!))
 
-        if (isArc4) {
-          copyAbiMetadatas(t! as Contract, instance as Contract)
-        }
-
         return instance
       },
     }

src/subcontexts/transaction-context.ts

@@ -1,7 +1,6 @@
 import type { bytes, Contract, uint64 } from '@algorandfoundation/algorand-typescript'
 import { TransactionType } from '@algorandfoundation/algorand-typescript'
-import type { AbiMetadata } from '../abi-metadata'
-import { getContractMethodAbiMetadata } from '../abi-metadata'
+import { AbiMetaSymbol, type AbiMetadata } from '../abi-metadata'
 import { TRANSACTION_GROUP_MAX_SIZE } from '../constants'
 import { checkRoutingConditions } from '../context-helpers/context-util'
 import { lazyContext } from '../context-helpers/internal-context'
@@ -202,7 +201,7 @@ export class TransactionContext {
     ...args: TParams
   ): DeferredAppCall<TParams, TReturn> {
     const appId = lazyContext.ledger.getApplicationForContract(contract)
-    const abiMetadata = getContractMethodAbiMetadata(contract, methodName as string)
+    const abiMetadata = (contract as DeliberateAny)[AbiMetaSymbol]?.[methodName]
     const txns = ContractContext.createMethodCallTxns(contract, abiMetadata, ...args)
     return new DeferredAppCall(appId.id, txns, method, abiMetadata, args)
   }