feat: add new overload for methodSelector to support type only import

Author: boblat

src/application-spy.ts

@@ -112,7 +112,7 @@ export class ApplicationSpy<TContract extends Contract = Contract> {
             ocas = metadata.allowActions?.map((action) => OnCompleteAction[action]) ?? [OnCompleteAction.NoOp]
           }
 
-          const selector = methodSelector(fn, spy.contract)
+          const selector = methodSelector({ method: fn, contract: spy.contract })
           spy.onAbiCall(selector, ocas, callback)
         }
       },

src/impl/c2c.ts

@@ -34,7 +34,7 @@ export function compileArc4<TContract extends Contract>(
     call: new Proxy({} as unknown as TContract, {
       get: (_target, prop) => {
         return (methodArgs: TypedApplicationCallFields<DeliberateAny[]>) => {
-          const selector = methodSelector(prop as string, contract)
+          const selector = methodSelector({ method: prop as string, contract })
           const abiMetadata = getContractMethodAbiMetadata(contract, prop as string)
           const onCompleteActions = abiMetadata?.allowActions?.map((action) => OnCompleteAction[action])
           const itxnContext = ApplicationCallInnerTxnContext.createFromTypedApplicationCallFields(
@@ -95,7 +95,7 @@ export function getApplicationCallInnerTxnContext<TArgs extends DeliberateAny[],
   contract?: Contract | { new (): Contract },
 ) {
   const abiMetadata = contract ? getContractMethodAbiMetadata(contract, method.name) : undefined
-  const selector = methodSelector(method, contract)
+  const selector = methodSelector({ method, contract })
   return ApplicationCallInnerTxnContext.createFromTypedApplicationCallFields<TReturn>(
     {
       ...methodArgs,

src/impl/method-selector.ts

@@ -1,23 +1,65 @@
-import type { arc4, bytes } from '@algorandfoundation/algorand-typescript'
+import type { bytes } from '@algorandfoundation/algorand-typescript'
 import { encodingUtil } from '@algorandfoundation/puya-ts'
-import { getArc4Selector, getContractMethodAbiMetadata } from '../abi-metadata'
-import type { Overloads } from '../typescript-helpers'
+import { getArc4Selector, getContractByName, getContractMethodAbiMetadata } from '../abi-metadata'
+import { CodeError, InternalError } from '../errors'
+import type { InstanceMethod } from '../typescript-helpers'
 import type { Contract } from './contract'
 import { sha512_256 } from './crypto'
 import { Bytes } from './primitives'
 
-/** @internal */
-export const methodSelector = <TContract extends Contract>(
-  methodSignature: Parameters<Overloads<typeof arc4.methodSelector>>[0],
-  contract?: TContract | { new (): TContract },
-): bytes => {
-  if (typeof methodSignature === 'string' && contract === undefined) {
-    return sha512_256(Bytes(encodingUtil.utf8ToUint8Array(methodSignature))).slice(0, 4)
-  } else {
-    const abiMetadata = getContractMethodAbiMetadata(
-      contract!,
-      typeof methodSignature === 'string' ? methodSignature : methodSignature.name,
-    )
+/**
+ * Computes the method selector for an ARC-4 contract method.
+ *
+ * Supports three invocation patterns:
+ * 1. `methodSelector('sink(string,uint8[])void')`:
+ *       Direct method signature string (no contract): Returns SHA-512/256 hash of signature
+ * 2. `methodSelector<typeof SignaturesContract.prototype.sink>()`:
+ *       Contract name as string + method name as string: Looks up registered contract and returns ARC-4 selector
+ * 3. `methodSelector(SignaturesContract.prototype.sink)`:
+ *       Contract class/instance + method instance/name: Returns ARC-4 selector from ABI metadata
+ *
+ * @internal
+ */
+export const methodSelector = <TContract extends Contract>({
+  method,
+  contract,
+}: {
+  method?: string | InstanceMethod<Contract>
+  contract?: string | TContract | { new (): TContract }
+}): bytes => {
+  const isDirectSignature = typeof method === 'string' && contract === undefined
+  const isContractNameLookup = typeof contract === 'string' && typeof method === 'string' && contract && method
+  const isContractMethodLookup = typeof contract !== 'string' && contract && method
+
+  // Pattern 1: Direct method signature string (e.g., "add(uint64,uint64)uint64")
+  if (isDirectSignature) {
+    const signatureBytes = Bytes(encodingUtil.utf8ToUint8Array(method as string))
+    return sha512_256(signatureBytes).slice(0, 4)
+  }
+
+  // Pattern 2: Contract name as string with method name
+  if (isContractNameLookup) {
+    const registeredContract = getContractByName(contract)
+
+    if (registeredContract === undefined || typeof registeredContract !== 'function') {
+      throw new InternalError(`Unknown contract: ${contract}`)
+    }
+
+    if (!Object.hasOwn(registeredContract.prototype, method)) {
+      throw new InternalError(`Unknown method: ${method} in contract: ${contract}`)
+    }
+
+    const abiMetadata = getContractMethodAbiMetadata(registeredContract, method)
     return Bytes(getArc4Selector(abiMetadata))
   }
+
+  // Pattern 3: Contract class/instance with method signature or name
+  if (isContractMethodLookup) {
+    const methodName = typeof method === 'string' ? method : method.name
+
+    const abiMetadata = getContractMethodAbiMetadata(contract, methodName)
+    return Bytes(getArc4Selector(abiMetadata))
+  }
+
+  throw new CodeError('Invalid arguments to methodSelector')
 }

src/test-transformer/node-factory.ts

@@ -121,16 +121,31 @@ export const nodeFactory = {
     return factory.updateCallExpression(node, node.expression, node.typeArguments, [...typeInfoArgs, ...(node.arguments ?? [])])
   },
 
-  callMethodSelectorFunction(node: ts.CallExpression) {
-    if (
+  callMethodSelectorFunction(node: ts.CallExpression, typeParams: ptypes.PType[]) {
+    if (typeParams.length === 1 && typeParams[0] instanceof ptypes.FunctionPType && typeParams[0].declaredIn) {
+      return factory.updateCallExpression(node, node.expression, node.typeArguments, [
+        factory.createObjectLiteralExpression([
+          factory.createPropertyAssignment('method', factory.createStringLiteral(typeParams[0].name)),
+          factory.createPropertyAssignment('contract', factory.createStringLiteral(typeParams[0].declaredIn.fullName)),
+        ]),
+      ])
+    } else if (
       node.arguments.length === 1 &&
       ts.isPropertyAccessExpression(node.arguments[0]) &&
       ts.isPropertyAccessExpression(node.arguments[0].expression)
     ) {
       const contractIdenifier = node.arguments[0].expression.expression
-      return factory.updateCallExpression(node, node.expression, node.typeArguments, [...node.arguments, contractIdenifier])
+      return factory.updateCallExpression(node, node.expression, node.typeArguments, [
+        factory.createObjectLiteralExpression([
+          factory.createPropertyAssignment('method', node.arguments[0]),
+          factory.createPropertyAssignment('contract', contractIdenifier),
+        ]),
+      ])
+    } else {
+      return factory.updateCallExpression(node, node.expression, node.typeArguments, [
+        factory.createObjectLiteralExpression([factory.createPropertyAssignment('method', node.arguments[0])]),
+      ])
     }
-    return node
   },
 
   callAbiCallFunction(node: ts.CallExpression, typeParams: ptypes.PType[]) {

src/test-transformer/visitors.ts

@@ -213,7 +213,8 @@ class ExpressionVisitor {
 
         if (stubbedFunctionName) {
           if (isCallingMethodSelector(stubbedFunctionName)) {
-            updatedNode = nodeFactory.callMethodSelectorFunction(updatedNode)
+            const typeParams = this.helper.resolveTypeParameters(updatedNode)
+            updatedNode = nodeFactory.callMethodSelectorFunction(updatedNode, typeParams)
           } else if (isCallingAbiCall(stubbedFunctionName)) {
             const typeParams = this.helper.resolveTypeParameters(updatedNode)
             updatedNode = nodeFactory.callAbiCallFunction(updatedNode, typeParams)

tests/arc4/method-selector.algo.spec.ts

@@ -49,6 +49,8 @@ describe('methodSelector', async () => {
       .map((_, i) => txn.appArgs(i))
     expect(appArgs).toEqual([appClient.getABIMethod('sink(string,uint8[])void').getSelector(), arg1.bytes, arg2.bytes])
     expect(appArgs[0]).toEqual(arc4.methodSelector(SignaturesContract.prototype.sink))
+    expect(appArgs[0]).toEqual(arc4.methodSelector<typeof SignaturesContract.prototype.sink>())
+    expect(appArgs[0]).toEqual(arc4.methodSelector('sink(string,uint8[])void'))
   })
 
   test('app args is correct with alias', async ({ appClientSignaturesContract: appClient }) => {
@@ -71,6 +73,8 @@ describe('methodSelector', async () => {
       .map((_, i) => txn.appArgs(i))
     expect(appArgs).toEqual([appClient.getABIMethod('alias(string,uint8[])void').getSelector(), arg1.bytes, arg2.bytes])
     expect(appArgs[0]).toEqual(arc4.methodSelector(SignaturesContract.prototype.sink2))
+    expect(appArgs[0]).toEqual(arc4.methodSelector<typeof SignaturesContract.prototype.sink2>())
+    expect(appArgs[0]).toEqual(arc4.methodSelector('alias(string,uint8[])void'))
   })
 
   test('app args is correct with txn', async ({ appClientSignaturesContract: appClient, algorand }) => {
@@ -99,6 +103,8 @@ describe('methodSelector', async () => {
       .map((_, i) => txn.appArgs(i))
     expect(appArgs).toEqual([appClient.getABIMethod('withTxn(string,pay,uint8[])void').getSelector(), arg1.bytes, arg3.bytes])
     expect(appArgs[0]).toEqual(methodSelector(SignaturesContract.prototype.withTxn))
+    expect(appArgs[0]).toEqual(methodSelector<typeof SignaturesContract.prototype.withTxn>())
+    expect(appArgs[0]).toEqual(methodSelector('withTxn(string,pay,uint8[])void'))
   })
 
   test('app args is correct with asset', async ({ appClientSignaturesContract: appClient, algorand }) => {
@@ -133,6 +139,8 @@ describe('methodSelector', async () => {
       arg3.bytes,
     ])
     expect(appArgs[0]).toEqual(methodSelector(SignaturesContract.prototype.withAsset))
+    expect(appArgs[0]).toEqual(methodSelector<typeof SignaturesContract.prototype.withAsset>())
+    expect(appArgs[0]).toEqual(methodSelector('withAsset(string,asset,uint8[])void'))
   })
 
   test('app args is correct with account', async ({ appClientSignaturesContract: appClient, algorand }) => {
@@ -166,6 +174,8 @@ describe('methodSelector', async () => {
       arg3.bytes,
     ])
     expect(appArgs[0]).toEqual(methodSelector(SignaturesContract.prototype.withAcc))
+    expect(appArgs[0]).toEqual(methodSelector<typeof SignaturesContract.prototype.withAcc>())
+    expect(appArgs[0]).toEqual(methodSelector('withAcc(string,account,uint8[])void'))
   })
 
   test('app args is correct with application', async ({ appClientSignaturesContract: appClient, appFactorySignaturesContract }) => {
@@ -201,6 +211,8 @@ describe('methodSelector', async () => {
       arg4.bytes,
     ])
     expect(appArgs[0]).toEqual(methodSelector(SignaturesContract.prototype.withApp))
+    expect(appArgs[0]).toEqual(methodSelector<typeof SignaturesContract.prototype.withApp>())
+    expect(appArgs[0]).toEqual(methodSelector('withApp(string,application,uint64,uint8[])void'))
     expect(appForeignApps.map((a) => a.id)).toEqual([selfApp.id, otherAppId])
   })
 
@@ -246,6 +258,12 @@ describe('methodSelector', async () => {
       five.bytes,
     ])
     expect(appArgs[0]).toEqual(methodSelector(SignaturesContract.prototype.complexSig))
+    expect(appArgs[0]).toEqual(methodSelector<typeof SignaturesContract.prototype.complexSig>())
+    expect(appArgs[0]).toEqual(
+      methodSelector(
+        'complexSig(((uint64,string),(uint64,string),uint128,uint128),pay,account,uint8[])((uint64,string),((uint64,string),(uint64,string),uint128,uint128))',
+      ),
+    )
     expect(result[0].bytes).toEqual(struct.anotherStruct.bytes)
     expect(result[1].bytes).toEqual(struct.bytes)
   })
@@ -296,6 +314,12 @@ describe('methodSelector', async () => {
       Bytes.fromHex('01'),
     ])
     expect(appArgs[0]).toEqual(methodSelector(SignaturesContract.prototype.echoResourceByIndex))
+    expect(appArgs[0]).toEqual(methodSelector<typeof SignaturesContract.prototype.echoResourceByIndex>())
+    expect(appArgs[0]).toEqual(
+      methodSelector(
+        'echoResourceByIndex(asset,application,account)(uint64,uint64,address)',
+      ),
+    )
 
     expect(result).toEqual([asaId, otherAppId, encodeAddress(acc.publicKey)])
   })
@@ -346,6 +370,12 @@ describe('methodSelector', async () => {
       toBytes(account),
     ])
     expect(appArgs[0]).toEqual(methodSelector(SignaturesContract.prototype.echoResourceByValue))
+    expect(appArgs[0]).toEqual(methodSelector<typeof SignaturesContract.prototype.echoResourceByValue>())
+    expect(appArgs[0]).toEqual(
+      methodSelector(
+        'echoResourceByValue(uint64,uint64,address)(uint64,uint64,address)',
+      ),
+    )
 
     expect(result).toEqual([asaId, otherAppId, encodeAddress(acc.publicKey)])
   })
@@ -404,5 +434,11 @@ describe('methodSelector', async () => {
       five.bytes,
     ])
     expect(appArgs[0]).toEqual(methodSelector(SignaturesContract.prototype.complexSig))
+    expect(appArgs[0]).toEqual(methodSelector<typeof SignaturesContract.prototype.complexSig>())
+    expect(appArgs[0]).toEqual(
+      methodSelector(
+        'complexSig(((uint64,string),(uint64,string),uint128,uint128),pay,account,uint8[])((uint64,string),((uint64,string),(uint64,string),uint128,uint128))',
+      ),
+    )
   })
 })