- fix: capture method config at the earlier stage instead of on instantiation

as the contract might not be instantiated in the case of contract method
being passed as a parameter to `methodSelector` function; e.g.
`methodSelector(HelloWorld.prototype.greet)`
- fix: prevent sub classes of the same parent from overwritting the config
of other siblings

Author: boblat

examples/precompiled/contract.algo.ts

@@ -6,7 +6,6 @@ import { Hello, HelloTemplate, HelloTemplateCustomPrefix, LargeProgram, Terrible
 export class HelloFactory extends Contract {
   test_compile_contract() {
     const compiled = compile(Hello)
-
     const helloApp = itxn
       .applicationCall({
         appArgs: [methodSelector(Hello.prototype.create), encodeArc4('hello')],

package-lock.json

@@ -71,8 +71,8 @@
     "tslib": "^2.6.2"
   },
   "dependencies": {
-    "@algorandfoundation/algorand-typescript": "^1.0.0-beta.18",
-    "@algorandfoundation/puya-ts": "^1.0.0-beta.25",
+    "@algorandfoundation/algorand-typescript": "^1.0.0-beta.19",
+    "@algorandfoundation/puya-ts": "^1.0.0-beta.26",
     "elliptic": "^6.5.7",
     "js-sha256": "^0.11.0",
     "js-sha3": "^0.9.3",

package.json

@@ -1,4 +1,4 @@
-import type { BaseContract, Contract } from '@algorandfoundation/algorand-typescript'
+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'
@@ -7,28 +7,41 @@ import type { DeliberateAny } from './typescript-helpers'
 
 export interface AbiMetadata {
   methodName: string
-  methodNameOverride?: string
+  name?: string
   methodSignature: string | undefined
   argTypes: string[]
   returnType: string
   onCreate?: CreateOptions
   allowActions?: OnCompleteActionStr[]
 }
 const AbiMetaSymbol = Symbol('AbiMetadata')
+const overwrittenMetadata: Array<readonly [Contract | { new (): Contract }, Record<string, AbiMetadata>]> = []
 export const isContractProxy = Symbol('isContractProxy')
 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>
-  metadatas[methodName] = metadata
+
+  // 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: false,
+      enumerable: true,
     })
   }
 }
 
-export const copyAbiMetadatas = <T extends BaseContract>(sourceContract: T, targetContract: T): void => {
+export const copyAbiMetadatas = <T extends Contract>(sourceContract: T, targetContract: T): void => {
   const metadatas = getContractAbiMetadata(sourceContract)
   Object.defineProperty(targetContract, AbiMetaSymbol, {
     value: metadatas,
@@ -43,8 +56,7 @@ export const captureMethodConfig = <T extends Contract>(
   config?: AbiMethodConfig<T> | BareMethodConfig,
 ): void => {
   const metadata = getContractMethodAbiMetadata(contract, methodName)
-
-  metadata.methodNameOverride = config && 'name' in config ? config.name : undefined
+  metadata.name = (config as AbiMethodConfig<T>)?.name ?? methodName
   metadata.onCreate = config?.onCreate ?? 'disallow'
   metadata.allowActions = ([] as OnCompleteActionStr[]).concat(config?.allowActions ?? 'NoOp')
 }
@@ -55,19 +67,20 @@ export const hasAbiMetadata = <T extends Contract>(contract: T): boolean => {
     Object.getOwnPropertySymbols(contractClass).some((s) => s.toString() === AbiMetaSymbol.toString()) || AbiMetaSymbol in contractClass
   )
 }
-export const getContractAbiMetadata = <T extends BaseContract>(contract: T): Record<string, AbiMetadata> => {
+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>
+    return { ...((contract as DeliberateAny)[AbiMetaSymbol] as Record<string, AbiMetadata>), ...overwrittenMetadataEntry?.[1] }
   }
   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
+  return { ...metadatas, ...overwrittenMetadataEntry?.[1] }
 }
 
-export const getContractMethodAbiMetadata = <T extends BaseContract>(contract: T, methodName: string): AbiMetadata => {
+export const getContractMethodAbiMetadata = <T extends Contract>(contract: T, methodName: string): AbiMetadata => {
   const metadatas = getContractAbiMetadata(contract)
   return metadatas[methodName]
 }
@@ -76,7 +89,7 @@ export const getArc4Signature = (metadata: AbiMetadata): string => {
   if (metadata.methodSignature === undefined) {
     const argTypes = metadata.argTypes.map((t) => JSON.parse(t) as TypeInfo).map(getArc4TypeName)
     const returnType = getArc4TypeName(JSON.parse(metadata.returnType) as TypeInfo)
-    metadata.methodSignature = `${metadata.methodNameOverride ?? metadata.methodName}(${argTypes.join(',')})${returnType}`
+    metadata.methodSignature = `${metadata.name ?? metadata.methodName}(${argTypes.join(',')})${returnType}`
   }
   return metadata.methodSignature
 }

src/abi-metadata.ts

@@ -1,6 +1,6 @@
 import type { arc4, bytes } from '@algorandfoundation/algorand-typescript'
 import { encodingUtil } from '@algorandfoundation/puya-ts'
-import { captureMethodConfig, getArc4Selector, getContractMethodAbiMetadata } from '../abi-metadata'
+import { getArc4Selector, getContractMethodAbiMetadata } from '../abi-metadata'
 import type { DeliberateAny } from '../typescript-helpers'
 import { BaseContract } from './base-contract'
 import { sha512_256 } from './crypto'
@@ -14,35 +14,30 @@ export class Contract extends BaseContract {
   }
 }
 
-export function abimethod<TContract extends Contract>(config?: arc4.AbiMethodConfig<TContract>) {
+export function abimethod<TContract extends Contract>(_config?: arc4.AbiMethodConfig<TContract>) {
   return function <TArgs extends DeliberateAny[], TReturn>(
     target: (this: TContract, ...args: TArgs) => TReturn,
-    ctx: ClassMethodDecoratorContext<TContract>,
   ): (this: TContract, ...args: TArgs) => TReturn {
-    ctx.addInitializer(function () {
-      captureMethodConfig(this, target.name, config)
-    })
     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,
-    ctx: ClassMethodDecoratorContext<TContract>,
   ): (this: TContract, ...args: TArgs) => TReturn {
-    ctx.addInitializer(function () {
-      captureMethodConfig(this, target.name, config)
-    })
     return target
   }
 }
 
-export const methodSelector = (methodSignature: Parameters<typeof arc4.methodSelector>[0], contract?: DeliberateAny): bytes => {
+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)
+    const abiMetadata = getContractMethodAbiMetadata(contract!, methodSignature.name)
     return Bytes(getArc4Selector(abiMetadata))
   }
 }

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 } from './abi-metadata'
+export { attachAbiMetadata, captureMethodConfig } from './abi-metadata'
 export { emitImpl } from './impl/emit'
 export * from './impl/encoded-types'
 export { decodeArc4Impl, encodeArc4Impl } from './impl/encoded-types'

src/runtime-helpers.ts

@@ -213,14 +213,14 @@ export class ContractContext {
         lazyContext.txn.ensureScope([txn]).execute(() => {
           t = new target(...args)
         })
-        appData.isCreating = hasCreateMethods(t!)
+        appData.isCreating = isArc4 && hasCreateMethods(t! as Contract)
         const instance = new Proxy(t!, {
           get(target, prop, receiver) {
             if (prop === isContractProxy) {
               return true
             }
             const orig = Reflect.get(target, prop, receiver)
-            const abiMetadata = getContractMethodAbiMetadata(target, prop as string)
+            const abiMetadata = isArc4 ? getContractMethodAbiMetadata(target as Contract, prop as string) : undefined
             const isProgramMethod = prop === 'approvalProgram' || prop === 'clearStateProgram'
             const isAbiMethod = isArc4 && abiMetadata
             if (isAbiMethod || isProgramMethod) {
@@ -245,7 +245,9 @@ export class ContractContext {
 
         onConstructed(application, instance, getContractOptions(t!))
 
-        copyAbiMetadatas(t!, instance)
+        if (isArc4) {
+          copyAbiMetadatas(t! as Contract, instance as Contract)
+        }
 
         return instance
       },
@@ -258,7 +260,7 @@ const getContractOptions = (contract: BaseContract): ContractOptionsParameter |
   return contractClass[ContractOptionsSymbol] as ContractOptionsParameter
 }
 
-const hasCreateMethods = (contract: BaseContract) => {
+const hasCreateMethods = (contract: Contract) => {
   const metadatas = getContractAbiMetadata(contract)
   return Object.values(metadatas).some((metadata) => (metadata.onCreate ?? 'disallow') !== 'disallow')
 }

src/subcontexts/contract-context.ts

@@ -73,6 +73,17 @@ 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(
@@ -119,4 +130,8 @@ 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,6 +131,8 @@ class ExpressionVisitor {
     private helper: VisitorHelper,
     private expressionNode: ts.Expression,
     private stubbedFunctionName?: string,
+    private className?: ts.Identifier,
+    private methodNode?: ts.MethodDeclaration,
   ) {}
 
   public result(): ts.Expression {
@@ -162,16 +164,20 @@ class ExpressionVisitor {
         let infoArg = info
         if (isCallingEmit(stubbedFunctionName)) {
           infoArg = this.helper.resolveTypeParameters(updatedNode).map(getGenericTypeInfo)[0]
-        }
-        if (isCallingDecodeArc4(stubbedFunctionName)) {
+        } else if (isCallingDecodeArc4(stubbedFunctionName)) {
           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)
-            : nodeFactory.callStubbedFunction(stubbedFunctionName, updatedNode, infoArg)
+            : isCallingDecoratorMethod(stubbedFunctionName)
+              ? updatedNode
+              : nodeFactory.callStubbedFunction(stubbedFunctionName, updatedNode, infoArg)
           : updatedNode
       }
       return needsToCaptureTypeInfo
@@ -208,7 +214,8 @@ class FunctionOrMethodVisitor {
   constructor(
     protected context: ts.TransformationContext,
     protected helper: VisitorHelper,
-    private isFunction?: boolean,
+    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)
@@ -269,7 +276,7 @@ class FunctionOrMethodVisitor {
     if (ts.isCallExpression(node)) {
       const stubbedFunctionName = tryGetStubbedFunctionName(node, this.helper)
       if (stubbedFunctionName) {
-        return new ExpressionVisitor(this.context, this.helper, node, stubbedFunctionName).result()
+        return new ExpressionVisitor(this.context, this.helper, node, stubbedFunctionName, this.className, this.methodNode).result()
       }
     }
 
@@ -283,7 +290,7 @@ class FunctionLikeDecVisitor extends FunctionOrMethodVisitor {
     helper: VisitorHelper,
     private funcNode: ts.SignatureDeclaration,
   ) {
-    super(context, helper, true)
+    super(context, helper)
   }
 
   public result(): ts.SignatureDeclaration {
@@ -294,9 +301,10 @@ class MethodDecVisitor extends FunctionOrMethodVisitor {
   constructor(
     context: ts.TransformationContext,
     helper: VisitorHelper,
-    private methodNode: ts.MethodDeclaration,
+    methodNode: ts.MethodDeclaration,
+    className: ts.Identifier | undefined,
   ) {
-    super(context, helper)
+    super(context, helper, className, methodNode)
   }
 
   public result(): ts.MethodDeclaration {
@@ -330,7 +338,7 @@ class ClassVisitor {
         }
       }
 
-      return new MethodDecVisitor(this.context, this.helper, node).result()
+      return new MethodDecVisitor(this.context, this.helper, node, this.classDec.name).result()
     }
 
     if (ts.isCallExpression(node)) {
@@ -421,10 +429,11 @@ 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']
+  const stubbedFunctionNames = ['interpretAsArc4', 'decodeArc4', 'encodeArc4', 'emit', 'methodSelector', 'abimethod', 'baremethod']
   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 ?? '')