refactor: simplify capturing of decorator config by storing it directly with the function

Author: boblat

package-lock.json

@@ -72,7 +72,7 @@
   },
   "dependencies": {
     "@algorandfoundation/algorand-typescript": "^1.0.0-beta.20",
-    "@algorandfoundation/puya-ts": "^1.0.0-beta.28",
+    "@algorandfoundation/puya-ts": "^1.0.0-beta.30",
     "elliptic": "^6.5.7",
     "js-sha256": "^0.11.0",
     "js-sha3": "^0.9.3",

package.json

@@ -1,8 +1,9 @@
-import type { AbiMethodConfig, BareMethodConfig, CreateOptions, OnCompleteActionStr } from '@algorandfoundation/algorand-typescript/arc4'
+import type { CreateOptions, OnCompleteActionStr } from '@algorandfoundation/algorand-typescript/arc4'
 import js_sha512 from 'js-sha512'
 import type { TypeInfo } from './encoders'
-import { Contract } from './impl/contract'
+import { Arc4MethodConfigSymbol, Contract } from './impl/contract'
 import { getArc4TypeName as getArc4TypeNameForARC4Encoded } from './impl/encoded-types'
+import type { DeliberateAny } from './typescript-helpers'
 
 export interface AbiMetadata {
   methodName: string
@@ -13,9 +14,8 @@ export interface AbiMetadata {
   onCreate?: CreateOptions
   allowActions?: OnCompleteActionStr[]
 }
-export const AbiMetaSymbol = Symbol('AbiMetadata')
-export const isContractProxy = Symbol('isContractProxy')
-const metadataStore: Map<{ new (): Contract }, Record<string, AbiMetadata>> = new Map()
+
+const metadataStore: WeakMap<{ new (): Contract }, Record<string, AbiMetadata>> = new WeakMap()
 export const attachAbiMetadata = (contract: { new (): Contract }, methodName: string, metadata: AbiMetadata): void => {
   if (!metadataStore.has(contract)) {
     metadataStore.set(contract, {})
@@ -24,17 +24,6 @@ export const attachAbiMetadata = (contract: { new (): Contract }, methodName: st
   metadatas[methodName] = metadata
 }
 
-export const captureMethodConfig = <T extends Contract>(
-  contract: T,
-  methodName: string,
-  config?: AbiMethodConfig<T> | BareMethodConfig,
-): void => {
-  const metadata = getContractMethodAbiMetadata(contract, methodName)
-  metadata.name = (config as AbiMethodConfig<T>)?.name ?? methodName
-  metadata.onCreate = config?.onCreate ?? 'disallow'
-  metadata.allowActions = ([] as OnCompleteActionStr[]).concat(config?.allowActions ?? 'NoOp')
-}
-
 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> = {}
@@ -52,7 +41,10 @@ export const getContractAbiMetadata = <T extends Contract>(contract: T | { new (
       const classMetadata = currentMetadata
       for (const [methodName, metadata] of Object.entries(classMetadata)) {
         if (!(methodName in result)) {
-          result[methodName] = metadata
+          result[methodName] = {
+            ...metadata,
+            ...(currentClass.prototype as DeliberateAny)?.[methodName]?.[Arc4MethodConfigSymbol],
+          }
         }
       }
     }

src/abi-metadata.ts

@@ -1,4 +1,5 @@
 import type { arc4 } from '@algorandfoundation/algorand-typescript'
+import type { OnCompleteActionStr } from '@algorandfoundation/algorand-typescript/arc4'
 import type { DeliberateAny } from '../typescript-helpers'
 import { BaseContract } from './base-contract'
 
@@ -10,18 +11,29 @@ export class Contract extends BaseContract {
   }
 }
 
-export function abimethod<TContract extends Contract>(_config?: arc4.AbiMethodConfig<TContract>) {
+export const Arc4MethodConfigSymbol = Symbol('Arc4MethodConfig')
+export function abimethod<TContract extends Contract>(config?: arc4.AbiMethodConfig<TContract>) {
   return function <TArgs extends DeliberateAny[], TReturn>(
     target: (this: TContract, ...args: TArgs) => TReturn,
   ): (this: TContract, ...args: TArgs) => TReturn {
+    ;(target as DeliberateAny)[Arc4MethodConfigSymbol] = {
+      ...config,
+      onCreate: config?.onCreate ?? 'disallow',
+      allowActions: ([] as OnCompleteActionStr[]).concat(config?.allowActions ?? 'NoOp'),
+    }
     return target
   }
 }
 
-export function baremethod<TContract extends Contract>(_config?: arc4.BareMethodConfig) {
+export function baremethod<TContract extends Contract>(config?: arc4.BareMethodConfig) {
   return function <TArgs extends DeliberateAny[], TReturn>(
     target: (this: TContract, ...args: TArgs) => TReturn,
   ): (this: TContract, ...args: TArgs) => TReturn {
+    ;(target as DeliberateAny)[Arc4MethodConfigSymbol] = {
+      ...config,
+      onCreate: config?.onCreate ?? 'disallow',
+      allowActions: ([] as OnCompleteActionStr[]).concat(config?.allowActions ?? 'NoOp'),
+    }
     return target
   }
 }

src/impl/contract.ts

@@ -9,7 +9,7 @@ import { AccountCls } from './impl/reference'
 import type { DeliberateAny } from './typescript-helpers'
 import { nameOfType } from './util'
 
-export { attachAbiMetadata, captureMethodConfig } from './abi-metadata'
+export { attachAbiMetadata } from './abi-metadata'
 export { emitImpl } from './impl/emit'
 export * from './impl/encoded-types'
 export { decodeArc4Impl, encodeArc4Impl } from './impl/encoded-types'

src/runtime-helpers.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 { AbiMetaSymbol, getArc4Selector, getContractAbiMetadata, getContractMethodAbiMetadata, isContractProxy } from '../abi-metadata'
+import { getArc4Selector, getContractAbiMetadata, getContractMethodAbiMetadata } from '../abi-metadata'
 import { BytesMap } from '../collections/custom-key-map'
 import { checkRoutingConditions } from '../context-helpers/context-util'
 import { lazyContext } from '../context-helpers/internal-context'
@@ -232,14 +232,9 @@ export class ContractContext {
         appData.isCreating = isArc4 && hasCreateMethods(t! as Contract)
         const instance = new Proxy(t!, {
           get(target, prop, receiver) {
-            if (prop === isContractProxy) {
-              return true
-            }
-            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 abiMetadata =
+              isArc4 && typeof orig === 'function' ? getContractMethodAbiMetadata(target as Contract, orig.name) : undefined
             const isProgramMethod = prop === 'approvalProgram' || prop === 'clearStateProgram'
             const isAbiMethod = isArc4 && abiMetadata
             if (isAbiMethod || isProgramMethod) {

src/subcontexts/contract-context.ts

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

src/subcontexts/transaction-context.ts

@@ -73,17 +73,6 @@ export const nodeFactory = {
     )
   },
 
-  captureMethodConfig(classIdentifier: ts.Identifier, method: ts.MethodDeclaration, callExpression: ts.CallExpression) {
-    const methodName = getPropertyNameAsString(method.name)
-    return factory.createExpressionStatement(
-      factory.createCallExpression(
-        factory.createPropertyAccessExpression(factory.createIdentifier('runtimeHelpers'), factory.createIdentifier('captureMethodConfig')),
-        undefined,
-        [classIdentifier, methodName, ...callExpression.arguments],
-      ),
-    )
-  },
-
   captureGenericTypeInfo(x: ts.Expression, info: string) {
     return factory.createCallExpression(
       factory.createPropertyAccessExpression(
@@ -130,8 +119,4 @@ export const nodeFactory = {
     }
     return node
   },
-
-  callDecoratorMethod(node: ts.CallExpression, className: ts.Identifier) {
-    return factory.updateCallExpression(node, node.expression, node.typeArguments, [className, ...node.arguments])
-  },
 } satisfies Record<string, (...args: DeliberateAny[]) => ts.Node>

src/test-transformer/node-factory.ts

@@ -131,8 +131,6 @@ class ExpressionVisitor {
     private helper: VisitorHelper,
     private expressionNode: ts.Expression,
     private stubbedFunctionName?: string,
-    private className?: ts.Identifier,
-    private methodNode?: ts.MethodDeclaration,
   ) {}
 
   public result(): ts.Expression {
@@ -168,16 +166,12 @@ class ExpressionVisitor {
           const targetType = ptypes.ptypeToArc4EncodedType(type, this.helper.sourceLocation(node))
           const targetTypeInfo = getGenericTypeInfo(targetType)
           infoArg = targetTypeInfo
-        } else if (isCallingDecoratorMethod(stubbedFunctionName)) {
-          this.helper.additionalStatements.push(nodeFactory.captureMethodConfig(this.className!, this.methodNode!, updatedNode))
         }
 
         updatedNode = stubbedFunctionName
           ? isCallingMethodSelector(stubbedFunctionName)
             ? nodeFactory.callMethodSelectorFunction(updatedNode)
-            : isCallingDecoratorMethod(stubbedFunctionName)
-              ? updatedNode
-              : nodeFactory.callStubbedFunction(stubbedFunctionName, updatedNode, infoArg)
+            : nodeFactory.callStubbedFunction(stubbedFunctionName, updatedNode, infoArg)
           : updatedNode
       }
       return needsToCaptureTypeInfo
@@ -214,8 +208,6 @@ class FunctionOrMethodVisitor {
   constructor(
     protected context: ts.TransformationContext,
     protected helper: VisitorHelper,
-    protected className?: ts.Identifier,
-    protected methodNode?: ts.MethodDeclaration,
   ) {}
   protected visit = (node: ts.Node): ts.Node => {
     return ts.visitEachChild(this.updateNode(node), this.visit, this.context)
@@ -276,7 +268,7 @@ class FunctionOrMethodVisitor {
     if (ts.isCallExpression(node)) {
       const stubbedFunctionName = tryGetStubbedFunctionName(node, this.helper)
       if (stubbedFunctionName) {
-        return new ExpressionVisitor(this.context, this.helper, node, stubbedFunctionName, this.className, this.methodNode).result()
+        return new ExpressionVisitor(this.context, this.helper, node, stubbedFunctionName).result()
       }
     }
 
@@ -301,10 +293,9 @@ class MethodDecVisitor extends FunctionOrMethodVisitor {
   constructor(
     context: ts.TransformationContext,
     helper: VisitorHelper,
-    methodNode: ts.MethodDeclaration,
-    className: ts.Identifier | undefined,
+    private methodNode: ts.MethodDeclaration,
   ) {
-    super(context, helper, className, methodNode)
+    super(context, helper)
   }
 
   public result(): ts.MethodDeclaration {
@@ -338,7 +329,7 @@ class ClassVisitor {
         }
       }
 
-      return new MethodDecVisitor(this.context, this.helper, node, this.classDec.name).result()
+      return new MethodDecVisitor(this.context, this.helper, node).result()
     }
 
     if (ts.isCallExpression(node)) {
@@ -429,11 +420,10 @@ const tryGetStubbedFunctionName = (node: ts.CallExpression, helper: VisitorHelpe
     if (sourceFileName && !algotsModulePaths.some((s) => sourceFileName.includes(s))) return undefined
   }
   const functionName = functionSymbol?.getName() ?? identityExpression.text
-  const stubbedFunctionNames = ['interpretAsArc4', 'decodeArc4', 'encodeArc4', 'emit', 'methodSelector', 'abimethod', 'baremethod']
+  const stubbedFunctionNames = ['interpretAsArc4', 'decodeArc4', 'encodeArc4', 'emit', 'methodSelector']
   return stubbedFunctionNames.includes(functionName) ? functionName : undefined
 }
 
 const isCallingDecodeArc4 = (functionName: string | undefined): boolean => ['decodeArc4', 'encodeArc4'].includes(functionName ?? '')
 const isCallingEmit = (functionName: string | undefined): boolean => 'emit' === (functionName ?? '')
 const isCallingMethodSelector = (functionName: string | undefined): boolean => 'methodSelector' === (functionName ?? '')
-const isCallingDecoratorMethod = (functionName: string | undefined): boolean => ['abimethod', 'baremethod'].includes(functionName ?? '')