feat: implement method signatures and method selectors

Author: boblat

src/abi-metadata.ts

@@ -1,10 +1,13 @@
 import { BaseContract, Contract } from '@algorandfoundation/algorand-typescript'
 import { AbiMethodConfig, BareMethodConfig, CreateOptions, OnCompleteActionStr } from '@algorandfoundation/algorand-typescript/arc4'
+import { ABIMethod } from 'algosdk'
+import { TypeInfo } from './encoders'
+import { getArc4TypeName as getArc4TypeNameForARC4Encoded } from './impl/encoded-types'
 import { DeliberateAny } from './typescript-helpers'
 
 export interface AbiMetadata {
   methodName: string
-  methodSelector: string
+  methodSignature: string | undefined
   argTypes: string[]
   returnType: string
   onCreate?: CreateOptions
@@ -28,21 +31,11 @@ export const captureMethodConfig = <T extends Contract>(
   methodName: string,
   config?: AbiMethodConfig<T> | BareMethodConfig,
 ): void => {
-  const metadata = ensureMetadata(contract, methodName)
+  const metadata = getAbiMetadata(contract, methodName)
   metadata.onCreate = config?.onCreate ?? 'disallow'
   metadata.allowActions = ([] as OnCompleteActionStr[]).concat(config?.allowActions ?? 'NoOp')
 }
 
-const ensureMetadata = <T extends Contract>(contract: T, methodName: string): AbiMetadata => {
-  if (!hasAbiMetadata(contract)) {
-    const contractClass = contract.constructor as { new (): T }
-    Object.getOwnPropertyNames(Object.getPrototypeOf(contract)).forEach((name) => {
-      attachAbiMetadata(contractClass, name, { methodName: name, methodSelector: name, argTypes: [], returnType: '' })
-    })
-  }
-  return getAbiMetadata(contract, methodName)
-}
-
 export const hasAbiMetadata = <T extends Contract>(contract: T): boolean => {
   const contractClass = contract.constructor as { new (): T }
   return (
@@ -58,3 +51,48 @@ export const getAbiMetadata = <T extends BaseContract>(contract: T, methodName:
   ) as Record<string, AbiMetadata>
   return metadatas[methodName]
 }
+
+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)
+    const method = new ABIMethod({ name: metadata.methodName, args: argTypes.map((t) => ({ type: t })), returns: { type: returnType } })
+    metadata.methodSignature = method.getSignature()
+  }
+  return metadata.methodSignature
+}
+
+const getArc4TypeName = (t: TypeInfo): string => {
+  const map: Record<string, string | ((t: TypeInfo) => string)> = {
+    void: 'void',
+    account: 'account',
+    application: 'application',
+    asset: 'asset',
+    boolean: 'bool',
+    biguint: 'uint512',
+    bytes: 'byte[]',
+    string: 'string',
+    uint64: 'uint64',
+    OnCompleteAction: 'uint64',
+    TransactionType: 'uint64',
+    Transaction: 'txn',
+    PaymentTxn: 'pay',
+    KeyRegistrationTxn: 'keyreg',
+    AssetConfigTxn: 'acfg',
+    AssetTransferTxn: 'axfer',
+    AssetFreezeTxn: 'afrz',
+    ApplicationTxn: 'appl',
+    'Tuple<.*>': (t) =>
+      `(${Object.values(t.genericArgs as Record<string, TypeInfo>)
+        .map(getArc4TypeName)
+        .join(',')})`,
+  }
+  const entry = Object.entries(map).find(([k, _]) => new RegExp(`^${k}$`, 'i').test(t.name))?.[1]
+  if (entry === undefined) {
+    return getArc4TypeNameForARC4Encoded(t) ?? t.name
+  }
+  if (entry instanceof Function) {
+    return entry(t)
+  }
+  return entry
+}

src/impl/encoded-types.ts

@@ -81,6 +81,10 @@ export class UintNImpl<N extends BitSize> extends UintN<N> {
   static getMaxBitsLength(typeInfo: TypeInfo): BitSize {
     return parseInt((typeInfo.genericArgs as TypeInfo[])![0].name, 10) as BitSize
   }
+
+  static getArc4TypeName = (t: TypeInfo): string => {
+    return `uint${this.getMaxBitsLength(t)}`
+  }
 }
 
 const regExpNxM = (maxPrecision: number) => new RegExp(`^\\d*\\.?\\d{0,${maxPrecision}}$`)
@@ -144,6 +148,11 @@ export class UFixedNxMImpl<N extends BitSize, M extends number> extends UFixedNx
     const genericArgs = typeInfo.genericArgs as uFixedNxMGenericArgs
     return parseInt(genericArgs.n.name, 10) as BitSize
   }
+
+  static getArc4TypeName = (t: TypeInfo): string => {
+    const genericArgs = t.genericArgs as uFixedNxMGenericArgs
+    return `ufixed${genericArgs.n.name}x${genericArgs.m.name}`
+  }
 }
 
 export class ByteImpl extends Byte {
@@ -403,6 +412,11 @@ export class StaticArrayImpl<TItem extends ARC4Encoded, TLength extends number>
     }
     return size
   }
+
+  static getArc4TypeName = (t: TypeInfo): string => {
+    const genericArgs = t.genericArgs as StaticArrayGenericArgs
+    return `${getArc4TypeName(genericArgs.elementType)}[${genericArgs.size.name}]`
+  }
 }
 
 export class AddressImpl extends Address {
@@ -562,6 +576,11 @@ export class DynamicArrayImpl<TItem extends ARC4Encoded> extends DynamicArray<TI
     return result
   }
 
+  static getArc4TypeName = (t: TypeInfo): string => {
+    const genericArgs = t.genericArgs as DynamicArrayGenericArgs
+    return `${getArc4TypeName(genericArgs.elementType)}[]`
+  }
+
   private encodeWithLength(items: TItem[]) {
     return conactUint8Arrays(encodeLength(items.length).asUint8Array(), encode(items))
   }
@@ -657,6 +676,11 @@ export class TupleImpl<TTuple extends [ARC4Encoded, ...ARC4Encoded[]]> extends T
     }
     return size
   }
+
+  static getArc4TypeName = (t: TypeInfo): string => {
+    const genericArgs = Object.values(t.genericArgs as Record<string, TypeInfo>)
+    return `(${genericArgs.map(getArc4TypeName).join(',')})`
+  }
 }
 
 type StructConstraint = Record<string, ARC4Encoded>
@@ -732,6 +756,11 @@ export class StructImpl<T extends StructConstraint> extends (Struct<StructConstr
     result.uint8ArrayValue = asUint8Array(bytesValue)
     return result
   }
+
+  static getArc4TypeName = (t: TypeInfo): string => {
+    const genericArgs = Object.values(t.genericArgs as Record<string, TypeInfo>)
+    return `(${genericArgs.map(getArc4TypeName).join(',')})`
+  }
 }
 
 export class DynamicBytesImpl extends DynamicBytes {
@@ -783,6 +812,10 @@ export class DynamicBytesImpl extends DynamicBytes {
     result.value = dynamicArrayValue
     return result
   }
+
+  static getArc4TypeName = (_t: TypeInfo): string => {
+    return 'byte[]'
+  }
 }
 
 export class StaticBytesImpl extends StaticBytes {
@@ -838,6 +871,11 @@ export class StaticBytesImpl extends StaticBytes {
   static getMaxBytesLength(typeInfo: TypeInfo): number {
     return StaticArrayImpl.getMaxBytesLength(typeInfo)
   }
+
+  static getArc4TypeName = (t: TypeInfo): string => {
+    const genericArgs = t.genericArgs as StaticArrayGenericArgs
+    return `byte[${genericArgs.size.name}]`
+  }
 }
 
 const decode = (value: Uint8Array, childTypes: TypeInfo[]) => {
@@ -1097,3 +1135,24 @@ export const getArc4Encoder = <T>(typeInfo: TypeInfo, encoders?: Record<string,
   }
   return encoder as fromBytes<T>
 }
+
+export const getArc4TypeName = (typeInfo: TypeInfo): string | undefined => {
+  const map = {
+    Address: 'address',
+    Bool: 'bool',
+    Byte: 'byte',
+    Str: 'string',
+    'UintN<.*>': UintNImpl.getArc4TypeName,
+    'UFixedNxM<.*>': UFixedNxMImpl.getArc4TypeName,
+    'StaticArray<.*>': StaticArrayImpl.getArc4TypeName,
+    'DynamicArray<.*>': DynamicArrayImpl.getArc4TypeName,
+    Tuple: TupleImpl.getArc4TypeName,
+    Struct: StructImpl.getArc4TypeName,
+    DynamicBytes: DynamicBytesImpl.getArc4TypeName,
+    'StaticBytes<.*>': StaticBytesImpl.getArc4TypeName,
+  }
+  const name = Object.entries(map).find(([k, _]) => new RegExp(`^${k}$`, 'i').test(typeInfo.name))?.[1]
+  if (typeof name === 'string') return name
+  else if (typeof name === 'function') return name(typeInfo)
+  return undefined
+}

src/subcontexts/contract-context.ts

@@ -1,5 +1,6 @@
 import { Account, Application, Asset, BaseContract, Bytes, bytes, Contract, LocalState } from '@algorandfoundation/algorand-typescript'
-import { getAbiMetadata } from '../abi-metadata'
+import { ABIMethod } from 'algosdk'
+import { AbiMetadata, getAbiMetadata, getArc4Signature } from '../abi-metadata'
 import { BytesMap } from '../collections/custom-key-map'
 import { lazyContext } from '../context-helpers/internal-context'
 import type { TypeInfo } from '../encoders'
@@ -69,7 +70,7 @@ const extractStates = (contract: BaseContract): States => {
   return states
 }
 
-const extractArraysFromArgs = (app: Application, args: DeliberateAny[]) => {
+const extractArraysFromArgs = (app: Application, methodSelector: Uint8Array, args: DeliberateAny[]) => {
   const transactions: Transaction[] = []
   const accounts: Account[] = []
   const apps: Application[] = [app]
@@ -90,9 +91,7 @@ const extractArraysFromArgs = (app: Application, args: DeliberateAny[]) => {
       assets.push(arg as Asset)
     }
   }
-
-  // TODO: use actual method selector in appArgs
-  return { accounts, apps, assets, transactions, appArgs: [Bytes('method_selector'), ...appArgs] }
+  return { accounts, apps, assets, transactions, appArgs: [Bytes(methodSelector), ...appArgs] }
 }
 
 function isTransaction(obj: unknown): obj is Transaction {
@@ -112,14 +111,14 @@ export class ContractContext {
     return new proxy(...args)
   }
 
-  static createMethodCallTxns<TParams extends unknown[], TReturn>(
+  static createMethodCallTxns<TParams extends unknown[]>(
     contract: BaseContract,
-    method: (...args: TParams) => TReturn,
+    abiMetadata: AbiMetadata | undefined,
     ...args: TParams
   ): Transaction[] {
-    const abiMetadata = getAbiMetadata(contract, method.name)
     const app = lazyContext.ledger.getApplicationForContract(contract)
-    const { transactions, ...appCallArgs } = extractArraysFromArgs(app, args)
+    const methodSelector = abiMetadata ? ABIMethod.fromSignature(getArc4Signature(abiMetadata)).getSelector() : new Uint8Array()
+    const { transactions, ...appCallArgs } = extractArraysFromArgs(app, methodSelector, args)
     const appTxn = lazyContext.any.txn.applicationCall({
       appId: app,
       ...appCallArgs,
@@ -171,7 +170,7 @@ export class ContractContext {
             const isAbiMethod = isArc4 && abiMetadata
             if (isAbiMethod || isProgramMethod) {
               return (...args: DeliberateAny[]): DeliberateAny => {
-                const txns = ContractContext.createMethodCallTxns(receiver, orig as DeliberateAny, ...args)
+                const txns = ContractContext.createMethodCallTxns(receiver, abiMetadata, ...args)
                 return lazyContext.txn.ensureScope(txns).execute(() => {
                   const returnValue = (orig as DeliberateAny).apply(target, args)
                   if (!isProgramMethod && isAbiMethod && returnValue !== undefined) {

src/subcontexts/transaction-context.ts

@@ -1,5 +1,6 @@
 import { bytes, Contract, internal, TransactionType, uint64 } from '@algorandfoundation/algorand-typescript'
 import algosdk from 'algosdk'
+import { getAbiMetadata } from '../abi-metadata'
 import { lazyContext } from '../context-helpers/internal-context'
 import { DecodedLogs, decodeLogs, LogDecoding } from '../decode-logs'
 import { testInvariant } from '../errors'
@@ -130,7 +131,8 @@ export class TransactionContext {
     ...args: TParams
   ): DeferredAppCall<TParams, TReturn> {
     const appId = lazyContext.ledger.getApplicationForContract(contract)
-    const txns = ContractContext.createMethodCallTxns(contract, method, ...args)
+    const abiMetadata = getAbiMetadata(contract, method.name)
+    const txns = ContractContext.createMethodCallTxns(contract, abiMetadata, ...args)
     return new DeferredAppCall(appId.id, txns, method, args)
   }
 

src/test-transformer/node-factory.ts

@@ -48,16 +48,21 @@ export const nodeFactory = {
     )
   },
 
-  attachMetaData(classIdentifier: ts.Identifier, method: ts.MethodDeclaration, functionType: ptypes.FunctionPType) {
+  attachMetaData(
+    classIdentifier: ts.Identifier,
+    method: ts.MethodDeclaration,
+    functionType: ptypes.FunctionPType,
+    argTypes: string[],
+    returnType: string,
+  ) {
     const methodName = getPropertyNameAsString(method.name)
     const metadata = factory.createObjectLiteralExpression([
       factory.createPropertyAssignment('methodName', methodName),
-      factory.createPropertyAssignment('methodSelector', methodName),
       factory.createPropertyAssignment(
         'argTypes',
-        factory.createArrayLiteralExpression(functionType.parameters.map((p) => factory.createStringLiteral(p[1].fullName))),
+        factory.createArrayLiteralExpression(argTypes.map((p) => factory.createStringLiteral(p))),
       ),
-      factory.createPropertyAssignment('returnType', factory.createStringLiteral(functionType.returnType.fullName)),
+      factory.createPropertyAssignment('returnType', factory.createStringLiteral(returnType)),
     ])
     return factory.createExpressionStatement(
       factory.createCallExpression(

src/test-transformer/visitors.ts

@@ -249,7 +249,9 @@ class ClassVisitor {
       if (this.classDec.name && this.isArc4) {
         const methodType = this.helper.resolveType(node)
         if (methodType instanceof ptypes.FunctionPType) {
-          this.helper.additionalStatements.push(nodeFactory.attachMetaData(this.classDec.name, node, methodType))
+          const argTypes = methodType.parameters.map((p) => JSON.stringify(getGenericTypeInfo(p[1])))
+          const returnType = JSON.stringify(getGenericTypeInfo(methodType.returnType))
+          this.helper.additionalStatements.push(nodeFactory.attachMetaData(this.classDec.name, node, methodType, argTypes, returnType))
         }
       }
 
@@ -318,7 +320,7 @@ const getGenericTypeInfo = (type: ptypes.PType): TypeInfo => {
         .map(([key, value]) => [key, getGenericTypeInfo(value)])
         .filter((x) => !!x),
     )
-  } else if (type instanceof ptypes.ARC4TupleType) {
+  } else if (type instanceof ptypes.ARC4TupleType || type instanceof ptypes.TuplePType) {
     genericArgs.push(...type.items.map(getGenericTypeInfo))
   }
 

tests/artifacts/created-app-asset/contract.algo.ts

@@ -1,4 +1,5 @@
-import { arc4, assert, Bytes, gtxn, op, uint64 } from '@algorandfoundation/algorand-typescript'
+import { arc4, assert, Global, gtxn, op, uint64 } from '@algorandfoundation/algorand-typescript'
+import { interpretAsArc4, methodSelector, UintN64 } from '@algorandfoundation/algorand-typescript/arc4'
 
 export class AppExpectingEffects extends arc4.Contract {
   @arc4.abimethod()
@@ -13,16 +14,8 @@ export class AppExpectingEffects extends arc4.Contract {
 
   @arc4.abimethod()
   public log_group(appCall: gtxn.ApplicationTxn): void {
-    assert(appCall.appArgs(0) === Bytes('some_value()uint64'), 'expected correct method called')
+    assert(appCall.appArgs(0) === methodSelector('some_value()uint64'), 'expected correct method called')
     assert(appCall.numLogs === 1, 'expected logs')
-    assert(appCall.lastLog === Bytes('this is a log statement'))
+    assert(interpretAsArc4<UintN64>(appCall.lastLog, 'log').native === (appCall.groupIndex + 1) * Global.groupSize)
   }
-
-  // TODO: uncomment when arc4 stubs are implemented
-  // @arc4.abimethod()
-  // public log_group(appCall: gtxn.ApplicationTxn): void {
-  //   assert(appCall.appArgs(0) === arc4.arc4Signature("some_value()uint64"), "expected correct method called")
-  //   assert(appCall.numLogs === 1, "expected logs")
-  //   assert(arc4.UInt64.from_log(appCall.lastLog) === (appCall.groupIndex + 1) * Global.groupSize)
-  // }
 }

tests/state-op-codes.spec.ts

@@ -2,10 +2,10 @@ import { AlgoAmount } from '@algorandfoundation/algokit-utils/types/amount'
 import { ApplicationClient } from '@algorandfoundation/algokit-utils/types/app-client'
 import { AppSpec } from '@algorandfoundation/algokit-utils/types/app-spec'
 import { Account, arc4, bytes, Bytes, internal, op, TransactionType, uint64, Uint64 } from '@algorandfoundation/algorand-typescript'
-import { DynamicBytes } from '@algorandfoundation/algorand-typescript/arc4'
+import { DynamicBytes, UintN64 } from '@algorandfoundation/algorand-typescript/arc4'
 import { afterEach, describe, expect, it, test } from 'vitest'
 import { TestExecutionContext } from '../src'
-import { MIN_TXN_FEE, ZERO_ADDRESS } from '../src/constants'
+import { ABI_RETURN_VALUE_LOG_PREFIX, MIN_TXN_FEE, ZERO_ADDRESS } from '../src/constants'
 import { testInvariant } from '../src/errors'
 import { Block, gloadBytes, gloadUint64 } from '../src/impl'
 import { AccountCls } from '../src/impl/account'
@@ -285,22 +285,12 @@ describe('State op codes', async () => {
 
     it('should be able to pass app call txn as app arg', async () => {
       const appCallTxn = ctx.any.txn.applicationCall({
-        appArgs: [Bytes('some_value()uint64')],
-        appLogs: [Bytes('this is a log statement')],
+        appArgs: [arc4.methodSelector('some_value()uint64')],
+        appLogs: [ABI_RETURN_VALUE_LOG_PREFIX.concat(new UintN64(2).bytes)],
       })
       const contract = ctx.contract.create(AppExpectingEffects)
       contract.log_group(appCallTxn)
     })
-
-    // TODO: uncomment when arc4 stubs are implemented
-    // it('should be able to pass app call txn as app arg', async () => {
-    //   const appCallTxn = ctx.any.txn.applicationCall({
-    //     appArgs: [arc4.arc4Signature("some_value()uint64")],
-    //     logs: [arc4Prefix.concat(arc4.Uint64(2).bytes)]
-    //   })
-    //   const contract = ctx.contract.create(AppExpectingEffects)
-    //   contract.log_group(appCallTxn)
-    // })
   })
 
   describe('itxn', async () => {