@algorandfoundation/puya-ts 1.2.0-beta.37 → 1.2.0-beta.39

package/index.mjs

@@ -1,8 +1,8 @@
-import { o as ABICompatibleInstanceType, q as ALL_OP_ENUMS, r as AccountFunction, s as AnyPType, t as ApplicationFunctionType, u as ApplicationTxnFunction, w as ApprovalProgram, x as ArrayGeneric, y as ArrayLiteralPType, z as ArrayPType, B as AssetConfigTxnFunction, D as AssetFreezeTxnFunction, E as AssetFunction, F as AssetTransferTxnFunction, G as BaseContractClassType, H as BigIntLiteralPType, J as BigIntPType, K as BigUintFunction, M as BooleanFunction, N as BoxGeneric, Q as BoxMapGeneric, R as BoxMapPType, S as BoxPType, T as BytesFunction, U as BytesGeneric, V as BytesPType, W as ClassMethodDecoratorContext, X as ClearStateProgram, Y as ClusteredContractClassType, Z as ClusteredPrototype, _ as ContractClassPType, $ as FixedArrayGeneric, a0 as FixedArrayPType, a1 as FunctionPType, a2 as GeneratorGeneric, a3 as GeneratorType, a4 as GenericPType, a5 as GlobalMapGeneric, a6 as GlobalMapType, a7 as GlobalStateGeneric, a8 as GlobalStateType, a9 as GroupTransactionPType, aa as ImmutableObjectPType, ab as InnerTransactionPType, ac as InstanceType, ad as InternalType, ae as IntersectionPType, af as IntrinsicEnumType, ag as IntrinsicFunctionGroupType, ah as IntrinsicFunctionGroupTypeType, ai as IntrinsicFunctionType, aj as IntrinsicFunctionTypeType, ak as IterableIteratorGeneric, al as IterableIteratorType, am as ItxnParamsPType, an as KeyRegistrationTxnFunction, ao as LibClassType, ap as LibFunctionType, aq as LibObjType, ar as LocalMapGeneric, as as LocalMapType, at as LocalStateGeneric, au as LocalStateType, av as LogicSigPType, aw as MutableObjectPType, ax as MutableTuplePType, ay as NamespacePType, az as NumberPType, aA as NumericLiteralPType, aB as ObjectLiteralPType, aC as ObjectWithOptionalFieldsType, aD as PType, aE as PaymentTxnFunction, aF as PolytypeClassMethodHelper, aG as PromiseGeneric, aH as PromiseType, aI as ReadonlyArrayGeneric, aJ as ReadonlyArrayPType, aK as ReadonlyGeneric, aL as ReadonlyTuplePType, aM as ReferenceArrayGeneric, aN as ReferenceArrayType, aO as StringFunction, aP as SuperPrototypeSelector, aQ as SuperPrototypeSelectorGeneric, aR as TemplateVarFunction, aS as TransactionFunction, aT as TransactionFunctionType, aU as TransientType, aV as TypeParameterType, aW as Uint64EnumMemberLiteralType, aX as Uint64EnumMemberType, aY as Uint64EnumType, aZ as Uint64Function, a_ as UnionPType, a$ as UnsupportedType, e as accountPType, h as anyGtxnType, b0 as anyItxnParamsType, b1 as anyItxnType, b2 as anyPType, n as applicationCallGtxnType, b3 as applicationCallItxnFn, b4 as applicationCallItxnParamsType, b5 as applicationItxnType, f as applicationPType, b6 as arc28EmitFunction, b7 as arc4AbiMethodDecorator, b8 as arc4BareMethodDecorator, b9 as arc4BaseContractType, ba as assertFunction, bb as assertMatchFunction, i as assetConfigGtxnType, bc as assetConfigItxnFn, bd as assetConfigItxnParamsType, be as assetConfigItxnType, m as assetFreezeGtxnType, bf as assetFreezeItxnFn, bg as assetFreezeItxnParamsType, bh as assetFreezeItxnType, g as assetPType, j as assetTransferGtxnType, bi as assetTransferItxnFn, bj as assetTransferItxnParamsType, bk as assetTransferItxnType, bl as base64PType, bm as baseContractType, bn as bigIntPType, bo as biguintPType, bp as boolPType, bq as bytesPType, br as bzeroFunction, bs as cloneFunctionPType, bt as compileFunctionType, bu as compiledContractType, bv as compiledLogicSigType, bw as contractOptionsDecorator, bx as ecPType, by as ecdsaPType, bz as ensureBudgetFunction, bA as errFunction, bB as esSymbol, bC as inputOnlyObjects, bD as isArrayType, bE as isObjectType, bF as isTupleLike, bG as itoaMethod, bH as itxnComposePType, k as keyRegistrationGtxnType, bI as keyRegistrationItxnFn, bJ as keyRegistrationItxnParamsType, bK as keyRegistrationItxnType, bL as logFunction, bM as loggedAssertFunction, bN as loggedErrFunction, bO as logicSigBaseType, bP as logicSigOptionsDecorator, bQ as matchFunction, bR as mimcConfigurationsPType, bS as neverPType, bT as nullPType, bU as numberPType, bV as onCompleteActionType, bW as opUpFeeSourceType, p as paymentGtxnType, bX as paymentItxnFn, bY as paymentItxnParamsType, bZ as paymentItxnType, b_ as readonlyDecorator, b$ as stringPType, c0 as submitGroupItxnFunction, c1 as transactionTypeType, c2 as uint64PType, c3 as undefinedPType, c4 as unknownPType, c5 as urangeFunction, c6 as validateEncodingFunctionPType, v as voidPType, c7 as vrfVerifyPType, c8 as uint8ArrayToBigInt, c9 as uint8ArrayToBase64, ca as uint8ArrayToBase32, cb as uint8ArrayToUtf8, cc as base64ToUint8Array, cd as base32ToUint8Array, ce as bigIntToUint8Array, cf as utf8ToUint8Array } from './contract-class-model-BZeEDGw0.js';
-export { A as AbsolutePath, L as LogLevel, cg as LogSource, a as LoggingContext, ch as SourceLocation } from './contract-class-model-BZeEDGw0.js';
-import { A as ARC4ArrayType, a as ARC4BoolClass, b as ARC4EncodedType, c as ARC4InstanceType, d as ARC4StrClass, e as ARC4StructClass, f as ARC4StructType, g as ARC4TupleType, h as AddressClass, i as Arc4TupleGeneric, B as ByteClass, C as ContractProxyGeneric, j as ContractProxyType, D as DynamicArrayGeneric, k as DynamicArrayType, l as DynamicBytesConstructor, m as DynamicBytesType, S as StaticArrayGeneric, n as StaticArrayType, o as StaticBytesGeneric, p as StaticBytesType, T as TypedApplicationCallResponseGeneric, q as TypedApplicationCallResponseType, U as UFixedNxMGeneric, r as UFixedNxMType, s as UintN128Class, t as UintN16Class, u as UintN256Class, v as UintN32Class, w as UintN64Class, x as UintN8Class, y as UintNGeneric, z as UintNType, E as abiCallFunction, F as arc4AddressAlias, G as arc4BooleanType, H as arc4ByteAlias, I as arc4StringType, J as arc4StructBaseType, K as compileArc4Function, L as convertBytesFunction, M as decodeArc4Function, N as encodeArc4Function, O as methodSelectorFunction, P as sizeOfFunction, Q as uint8ArrayToHex, R as hexToUint8Array } from './options-DD9MApH4.js';
-export { V as CompileOptions, W as TypeResolver, X as processInputPaths, Y as registerPTypes, Z as typeRegistry } from './options-DD9MApH4.js';
-export { c as compile } from './compile-ycpMcgmJ.js';
+import { o as ABICompatibleInstanceType, q as ALL_OP_ENUMS, r as AccountFunction, s as AnyPType, t as ApplicationCallTxnFunction, u as ApplicationFunction, w as ApprovalProgram, x as ArrayGeneric, y as ArrayLiteralPType, z as ArrayPType, B as AssetConfigTxnFunction, D as AssetFreezeTxnFunction, E as AssetFunction, F as AssetTransferTxnFunction, G as BaseContractClassType, H as BigIntLiteralPType, J as BigIntPType, K as BigUintFunction, M as BooleanFunction, N as BoxGeneric, Q as BoxMapGeneric, R as BoxMapPType, S as BoxPType, T as BytesFunction, U as BytesGeneric, V as BytesPType, W as ClassMethodDecoratorContext, X as ClearStateProgram, Y as ClusteredContractClassType, Z as ClusteredPrototype, _ as ContractClassPType, $ as FixedArrayGeneric, a0 as FixedArrayPType, a1 as FunctionPType, a2 as GeneratorGeneric, a3 as GeneratorType, a4 as GenericPType, a5 as GlobalMapGeneric, a6 as GlobalMapType, a7 as GlobalStateGeneric, a8 as GlobalStateType, a9 as GroupTransactionPType, aa as ImmutableObjectPType, ab as InnerTransactionPType, ac as InstanceType, ad as InternalType, ae as IntersectionPType, af as IntrinsicEnumType, ag as IntrinsicFunctionGroupType, ah as IntrinsicFunctionGroupTypeType, ai as IntrinsicFunctionType, aj as IntrinsicFunctionTypeType, ak as IterableIteratorGeneric, al as IterableIteratorType, am as ItxnParamsPType, an as KeyRegistrationTxnFunction, ao as LibClassType, ap as LibFunctionType, aq as LibObjType, ar as LocalMapGeneric, as as LocalMapType, at as LocalStateGeneric, au as LocalStateType, av as LogicSigPType, aw as MutableObjectPType, ax as MutableTuplePType, ay as NamespacePType, az as NumberPType, aA as NumericLiteralPType, aB as ObjectLiteralPType, aC as ObjectWithOptionalFieldsType, aD as PType, aE as PaymentTxnFunction, aF as PolytypeClassMethodHelper, aG as PromiseGeneric, aH as PromiseType, aI as ReadonlyArrayGeneric, aJ as ReadonlyArrayPType, aK as ReadonlyGeneric, aL as ReadonlyTuplePType, aM as ReferenceArrayGeneric, aN as ReferenceArrayType, aO as StringFunction, aP as SuperPrototypeSelector, aQ as SuperPrototypeSelectorGeneric, aR as TemplateVarFunction, aS as TransactionFunction, aT as TransactionFunctionType, aU as TransientType, aV as TypeParameterType, aW as Uint64EnumMemberLiteralType, aX as Uint64EnumMemberType, aY as Uint64EnumType, aZ as Uint64Function, a_ as UnionPType, a$ as UnsupportedType, e as accountPType, h as anyGtxnType, b0 as anyItxnParamsType, b1 as anyItxnType, b2 as anyPType, n as applicationCallGtxnType, b3 as applicationCallItxnFunction, b4 as applicationCallItxnParamsType, b5 as applicationCallItxnType, f as applicationPType, b6 as arc28EmitFunction, b7 as arc4AbiMethodDecorator, b8 as arc4BareMethodDecorator, b9 as arc4BaseContractType, ba as assertFunction, bb as assertMatchFunction, i as assetConfigGtxnType, bc as assetConfigItxnFunction, bd as assetConfigItxnParamsType, be as assetConfigItxnType, m as assetFreezeGtxnType, bf as assetFreezeItxnFunction, bg as assetFreezeItxnParamsType, bh as assetFreezeItxnType, g as assetPType, j as assetTransferGtxnType, bi as assetTransferItxnFunction, bj as assetTransferItxnParamsType, bk as assetTransferItxnType, bl as base64PType, bm as baseContractType, bn as bigIntPType, bo as biguintPType, bp as boolPType, bq as bytesPType, br as bzeroFunction, bs as cloneFunction, bt as compileFunction, bu as compiledContractType, bv as compiledLogicSigType, bw as contractOptionsDecorator, bx as ecPType, by as ecdsaPType, bz as ensureBudgetFunction, bA as errFunction, bB as esSymbol, bC as inputOnlyObjects, bD as isArrayType, bE as isObjectType, bF as isTupleLike, bG as itoaMethod, bH as itxnComposePType, k as keyRegistrationGtxnType, bI as keyRegistrationItxnFunction, bJ as keyRegistrationItxnParamsType, bK as keyRegistrationItxnType, bL as logFunction, bM as loggedAssertFunction, bN as loggedErrFunction, bO as logicSigBaseType, bP as logicSigOptionsDecorator, bQ as matchFunction, bR as mimcConfigurationsPType, bS as neverPType, bT as nullPType, bU as numberPType, bV as onCompleteActionType, bW as opUpFeeSourceType, p as paymentGtxnType, bX as paymentItxnFunction, bY as paymentItxnParamsType, bZ as paymentItxnType, b_ as readonlyDecorator, b$ as stringPType, c0 as submitGroupItxnFunction, c1 as transactionTypeType, c2 as uint64PType, c3 as undefinedPType, c4 as unknownPType, c5 as urangeFunction, c6 as validateEncodingFunction, v as voidPType, c7 as vrfVerifyPType, c8 as uint8ArrayToBigInt, c9 as uint8ArrayToBase64, ca as uint8ArrayToBase32, cb as uint8ArrayToUtf8, cc as base64ToUint8Array, cd as base32ToUint8Array, ce as bigIntToUint8Array, cf as utf8ToUint8Array } from './contract-class-model-D-NUE8Zg.js';
+export { A as AbsolutePath, L as LogLevel, cg as LogSource, a as LoggingContext, ch as SourceLocation } from './contract-class-model-D-NUE8Zg.js';
+import { A as ARC4ArrayType, a as ARC4BoolClass, b as ARC4EncodedType, c as ARC4InstanceType, d as ARC4StrClass, e as ARC4StructClass, f as ARC4StructType, g as ARC4TupleGeneric, h as ARC4TupleType, i as AddressClass, B as ByteClass, C as ContractProxyGeneric, j as ContractProxyType, D as DynamicArrayGeneric, k as DynamicArrayType, l as DynamicBytesClass, S as StaticArrayGeneric, m as StaticArrayType, n as StaticBytesGeneric, o as StaticBytesType, T as TypedApplicationCallResponseGeneric, p as TypedApplicationCallResponseType, U as UFixedNxMGeneric, q as UFixedNxMType, r as UintN128Class, s as UintN16Class, t as UintN256Class, u as UintN32Class, v as UintN64Class, w as UintN8Class, x as UintNGeneric, y as UintNType, z as abiCallFunction, E as arc4AddressAlias, F as arc4BooleanType, G as arc4ByteAlias, H as arc4StringType, I as arc4StructBaseType, J as compileArc4Function, K as convertBytesFunction, L as decodeArc4Function, M as dynamicBytesType, N as encodeArc4Function, O as methodSelectorFunction, P as sizeOfFunction, Q as uint8ArrayToHex, R as hexToUint8Array } from './options-DLmtdJgF.js';
+export { V as CompileOptions, W as TypeResolver, X as processInputPaths, Y as registerPTypes, Z as typeRegistry } from './options-DLmtdJgF.js';
+export { c as compile } from './compile-DnShUPv7.js';
 import 'typescript';
 import 'node:fs';
 import 'node:util';
@@ -22,13 +22,13 @@ import 'net';
 import 'change-case';
 import 'glob';
 import 'minimatch';
-import './arc4-clientgen-qBTlCOIm.js';
+import './arc4-clientgen-7yQnFyxH.js';
 import '@algorandfoundation/algokit-utils/abi';
 import 'fs';
 import 'fs/promises';
-import './semver-B0p_0XuH.js';
+import './semver-DPkkKoZb.js';
 import 'node:url';
-import './resolve-puya-path-Ba54kz9o.js';
+import './resolve-puya-path-CzSo6yHU.js';
 import 'signal-exit';
 import 'tar';
 import 'node:zlib';
@@ -46,14 +46,14 @@ var forExport = /*#__PURE__*/Object.freeze({
     ARC4StrClass: ARC4StrClass,
     ARC4StructClass: ARC4StructClass,
     ARC4StructType: ARC4StructType,
+    ARC4TupleGeneric: ARC4TupleGeneric,
     ARC4TupleType: ARC4TupleType,
     AccountFunction: AccountFunction,
     AddressClass: AddressClass,
     AnyPType: AnyPType,
-    ApplicationFunctionType: ApplicationFunctionType,
-    ApplicationTxnFunction: ApplicationTxnFunction,
+    ApplicationCallTxnFunction: ApplicationCallTxnFunction,
+    ApplicationFunction: ApplicationFunction,
     ApprovalProgram: ApprovalProgram,
-    Arc4TupleGeneric: Arc4TupleGeneric,
     ArrayGeneric: ArrayGeneric,
     ArrayLiteralPType: ArrayLiteralPType,
     ArrayPType: ArrayPType,
@@ -83,8 +83,7 @@ var forExport = /*#__PURE__*/Object.freeze({
     ContractProxyType: ContractProxyType,
     DynamicArrayGeneric: DynamicArrayGeneric,
     DynamicArrayType: DynamicArrayType,
-    DynamicBytesConstructor: DynamicBytesConstructor,
-    DynamicBytesType: DynamicBytesType,
+    DynamicBytesClass: DynamicBytesClass,
     FixedArrayGeneric: FixedArrayGeneric,
     FixedArrayPType: FixedArrayPType,
     FunctionPType: FunctionPType,
@@ -173,9 +172,9 @@ var forExport = /*#__PURE__*/Object.freeze({
     anyItxnType: anyItxnType,
     anyPType: anyPType,
     applicationCallGtxnType: applicationCallGtxnType,
-    applicationCallItxnFn: applicationCallItxnFn,
+    applicationCallItxnFunction: applicationCallItxnFunction,
     applicationCallItxnParamsType: applicationCallItxnParamsType,
-    applicationItxnType: applicationItxnType,
+    applicationCallItxnType: applicationCallItxnType,
     applicationPType: applicationPType,
     arc28EmitFunction: arc28EmitFunction,
     arc4AbiMethodDecorator: arc4AbiMethodDecorator,
@@ -189,16 +188,16 @@ var forExport = /*#__PURE__*/Object.freeze({
     assertFunction: assertFunction,
     assertMatchFunction: assertMatchFunction,
     assetConfigGtxnType: assetConfigGtxnType,
-    assetConfigItxnFn: assetConfigItxnFn,
+    assetConfigItxnFunction: assetConfigItxnFunction,
     assetConfigItxnParamsType: assetConfigItxnParamsType,
     assetConfigItxnType: assetConfigItxnType,
     assetFreezeGtxnType: assetFreezeGtxnType,
-    assetFreezeItxnFn: assetFreezeItxnFn,
+    assetFreezeItxnFunction: assetFreezeItxnFunction,
     assetFreezeItxnParamsType: assetFreezeItxnParamsType,
     assetFreezeItxnType: assetFreezeItxnType,
     assetPType: assetPType,
     assetTransferGtxnType: assetTransferGtxnType,
-    assetTransferItxnFn: assetTransferItxnFn,
+    assetTransferItxnFunction: assetTransferItxnFunction,
     assetTransferItxnParamsType: assetTransferItxnParamsType,
     assetTransferItxnType: assetTransferItxnType,
     base64PType: base64PType,
@@ -208,14 +207,15 @@ var forExport = /*#__PURE__*/Object.freeze({
     boolPType: boolPType,
     bytesPType: bytesPType,
     bzeroFunction: bzeroFunction,
-    cloneFunctionPType: cloneFunctionPType,
+    cloneFunction: cloneFunction,
     compileArc4Function: compileArc4Function,
-    compileFunctionType: compileFunctionType,
+    compileFunction: compileFunction,
     compiledContractType: compiledContractType,
     compiledLogicSigType: compiledLogicSigType,
     contractOptionsDecorator: contractOptionsDecorator,
     convertBytesFunction: convertBytesFunction,
     decodeArc4Function: decodeArc4Function,
+    dynamicBytesType: dynamicBytesType,
     ecPType: ecPType,
     ecdsaPType: ecdsaPType,
     encodeArc4Function: encodeArc4Function,
@@ -229,7 +229,7 @@ var forExport = /*#__PURE__*/Object.freeze({
     itoaMethod: itoaMethod,
     itxnComposePType: itxnComposePType,
     keyRegistrationGtxnType: keyRegistrationGtxnType,
-    keyRegistrationItxnFn: keyRegistrationItxnFn,
+    keyRegistrationItxnFunction: keyRegistrationItxnFunction,
     keyRegistrationItxnParamsType: keyRegistrationItxnParamsType,
     keyRegistrationItxnType: keyRegistrationItxnType,
     logFunction: logFunction,
@@ -246,7 +246,7 @@ var forExport = /*#__PURE__*/Object.freeze({
     onCompleteActionType: onCompleteActionType,
     opUpFeeSourceType: opUpFeeSourceType,
     paymentGtxnType: paymentGtxnType,
-    paymentItxnFn: paymentItxnFn,
+    paymentItxnFunction: paymentItxnFunction,
     paymentItxnParamsType: paymentItxnParamsType,
     paymentItxnType: paymentItxnType,
     readonlyDecorator: readonlyDecorator,
@@ -258,7 +258,7 @@ var forExport = /*#__PURE__*/Object.freeze({
     undefinedPType: undefinedPType,
     unknownPType: unknownPType,
     urangeFunction: urangeFunction,
-    validateEncodingFunctionPType: validateEncodingFunctionPType,
+    validateEncodingFunction: validateEncodingFunction,
     voidPType: voidPType,
     vrfVerifyPType: vrfVerifyPType
 });

package/{options-DD9MApH4.js → options-DLmtdJgF.js}

@@ -1,4 +1,4 @@
-import { ao as LibClassType, d as Constants, bp as boolPType, co as wtypes, b$ as stringPType, a4 as GenericPType, cp as codeInvariant, aL as ReadonlyTuplePType, ax as MutableTuplePType, aD as PType, aA as NumericLiteralPType, c2 as uint64PType, bo as biguintPType, z as ArrayPType, aJ as ReadonlyArrayPType, e as accountPType, bq as bytesPType, ap as LibFunctionType, cq as invariant, _ as ContractClassPType, bu as compiledContractType, aa as ImmutableObjectPType, b5 as applicationItxnType, v as voidPType, aw as MutableObjectPType, I as InternalError, c as CodeError, cr as throwError, cs as StringConstant, ct as BytesConstant, cu as IntegerConstant, cv as BoolConstant, cw as AddressConstant, cx as MethodConstant, cy as DecimalConstant, cz as TemplateVar, cg as LogSource, L as LogLevel, cA as instanceOfAny, cB as SingleEvaluation, cC as VarExpression, cD as nodeFactory, cE as NotSupported, l as logger, cF as TupleItemExpression, cG as FieldExpression, cH as IndexExpression, cI as TupleExpression, cJ as AppStateExpression, cK as AppAccountStateExpression, cL as BoxValueExpression, cM as StateGetEx, cN as StateGet, aU as TransientType, bU as numberPType, bn as bigIntPType, b6 as arc28EmitFunction, y as ArrayLiteralPType, H as BigIntLiteralPType, cO as hasFlags, cP as BinaryBooleanOperator, ay as NamespacePType, bm as baseContractType, b9 as arc4BaseContractType, cQ as SymbolName, a_ as UnionPType, a9 as GroupTransactionPType, h as anyGtxnType, aX as Uint64EnumMemberType, aV as TypeParameterType, bB as esSymbol, c4 as unknownPType, bS as neverPType, b2 as anyPType, bT as nullPType, c3 as undefinedPType, Z as ClusteredPrototype, ae as IntersectionPType, bO as logicSigBaseType, av as LogicSigPType, aY as Uint64EnumType, a1 as FunctionPType, w as ApprovalProgram, X as ClearStateProgram, cn as isIn, R as BoxMapPType, S as BoxPType, as as LocalMapType, au as LocalStateType, a6 as GlobalMapType, a8 as GlobalStateType, aP as SuperPrototypeSelector, Y as ClusteredContractClassType, ch as SourceLocation, cR as intersectsFlags, cS as extractModuleName, cT as toSubScript, A as AbsolutePath, cU as CompilationSet, cV as ARC4ABIMethodConfig, C as ContractReference, V as BytesPType, cW as EqualityComparison, aB as ObjectLiteralPType, bE as isObjectType$1, b_ as readonlyDecorator, b7 as arc4AbiMethodDecorator, b8 as arc4BareMethodDecorator, cX as ARC4CreateOption, cY as NewArray, O as OnCompletionAction, cZ as BytesEncoding, ce as bigIntToUint8Array, c_ as FixableCodeError, c$ as UInt64BinaryOperator, d0 as tryConvertEnum, d1 as NumericComparison, d2 as UInt64UnaryOperator, bG as itoaMethod, aZ as Uint64Function, d3 as UInt64PostfixUnaryOperator, a0 as FixedArrayPType, al as IterableIteratorType, ak as IterableIteratorGeneric, f as applicationPType, g as assetPType, bV as onCompleteActionType, d4 as wrapInCodeError, cd as base32ToUint8Array, c1 as transactionTypeType, d5 as TransactionKind, bt as compileFunctionType, bv as compiledLogicSigType, d6 as LogicSigReference, ab as InnerTransactionPType, aT as TransactionFunctionType, c0 as submitGroupItxnFunction, am as ItxnParamsPType, d7 as getInnerTransactionType, d8 as getItxnParamsType, d9 as CompiledContract, da as ARC4BareMethodConfig, db as MethodSignature, cj as enumFromValue, x as ArrayGeneric, $ as FixedArrayGeneric, cm as zipStrict, bD as isArrayType, bF as isTupleLike, bQ as matchFunction, bb as assertMatchFunction, dc as BigUIntBinaryOperator, K as BigUintFunction, dd as BigUIntPostfixUnaryOperator, cf as utf8ToUint8Array, de as BytesBinaryOperator, df as IntrinsicCall, cb as uint8ArrayToUtf8, T as BytesFunction, U as BytesGeneric, cc as base64ToUint8Array, dg as enumKeyFromValue, dh as BytesUnaryOperator, bs as cloneFunctionPType, bw as contractOptionsDecorator, bz as ensureBudgetFunction, di as PuyaLibFunction, bW as opUpFeeSourceType, af as IntrinsicEnumType, bP as logicSigOptionsDecorator, ac as InstanceType, aC as ObjectWithOptionalFieldsType, c7 as vrfVerifyPType, bR as mimcConfigurationsPType, by as ecdsaPType, bx as ecPType, bl as base64PType, ag as IntrinsicFunctionGroupType, dj as Expression, ai as IntrinsicFunctionType, aM as ReferenceArrayGeneric, aN as ReferenceArrayType, dk as AppStorageKind, a$ as UnsupportedType, dl as transientTypeErrors, a7 as GlobalStateGeneric, aR as TemplateVarFunction, dm as getGroupTransactionType, bH as itxnComposePType, aW as Uint64EnumMemberLiteralType, b0 as anyItxnParamsType, c6 as validateEncodingFunctionPType, M as BooleanFunction, aO as StringFunction, aI as ReadonlyArrayGeneric, aK as ReadonlyGeneric, a2 as GeneratorGeneric, a3 as GeneratorType, aG as PromiseGeneric, aH as PromiseType, W as ClassMethodDecoratorContext, aQ as SuperPrototypeSelectorGeneric, aF as PolytypeClassMethodHelper, bL as logFunction, ba as assertFunction, bA as errFunction, bM as loggedAssertFunction, bN as loggedErrFunction, c5 as urangeFunction, br as bzeroFunction, aj as IntrinsicFunctionTypeType, q as ALL_OP_ENUMS, ah as IntrinsicFunctionGroupTypeType, a5 as GlobalMapGeneric, at as LocalStateGeneric, ar as LocalMapGeneric, N as BoxGeneric, Q as BoxMapGeneric, t as ApplicationFunctionType, r as AccountFunction, E as AssetFunction, p as paymentGtxnType, aE as PaymentTxnFunction, k as keyRegistrationGtxnType, an as KeyRegistrationTxnFunction, i as assetConfigGtxnType, B as AssetConfigTxnFunction, j as assetTransferGtxnType, F as AssetTransferTxnFunction, m as assetFreezeGtxnType, D as AssetFreezeTxnFunction, n as applicationCallGtxnType, u as ApplicationTxnFunction, aS as TransactionFunction, bX as paymentItxnFn, bI as keyRegistrationItxnFn, bc as assetConfigItxnFn, bi as assetTransferItxnFn, bf as assetFreezeItxnFn, b3 as applicationCallItxnFn, bZ as paymentItxnType, bK as keyRegistrationItxnType, be as assetConfigItxnType, bk as assetTransferItxnType, bh as assetFreezeItxnType, bY as paymentItxnParamsType, bJ as keyRegistrationItxnParamsType, bd as assetConfigItxnParamsType, bj as assetTransferItxnParamsType, bg as assetFreezeItxnParamsType, b4 as applicationCallItxnParamsType, bC as inputOnlyObjects, dn as Contract, dp as InstanceSuperMethodTarget, dq as ExpressionStatement, dr as AssertExpression, ds as VoidConstant, dt as ArrayConcat, du as ArrayPop, dv as ArrayReplace, dw as ArrayLength, dx as SizeOf, dy as UpdateInnerTransaction, dz as CheckedMaybe, dA as StageInnerTransactions, dB as SubmitInnerTransaction, dC as AssignmentExpression, dD as CommaExpression, dE as NumericComparisonExpression, dF as BytesComparisonExpression, dG as PuyaLibCall, dH as UInt64UnaryOperation, dI as UInt64PostfixUnaryOperation, dJ as BigUIntPostfixUnaryOperation, dK as BytesUnaryOperation, dL as UInt64BinaryOperation, dM as BigUIntBinaryOperation, dN as BooleanBinaryOperation, dO as Not, dP as Emit, dQ as Range, dR as Enumeration, dS as Reversed, dT as StateExists, dU as ARC4Router, dV as MethodSignatureString, dW as SubroutineID, dX as ContractMethodTarget, dY as InstanceMethodTarget, ca as uint8ArrayToBase32, ck as mkDirIfNotExists, dZ as patchErrorLocation, d_ as Goto, d$ as ReturnStatement, e0 as ContractMethod, e1 as sameSets, b as ContractClassModel, e2 as Subroutine, e3 as LogicSigClassModel, e4 as ptypeIn, e5 as expandMaybeArray, a as LoggingContext, P as PuyaError } from './contract-class-model-BZeEDGw0.js';
+import { ao as LibClassType, d as Constants, bp as boolPType, co as wtypes, b$ as stringPType, a4 as GenericPType, cp as codeInvariant, aL as ReadonlyTuplePType, ax as MutableTuplePType, aD as PType, aA as NumericLiteralPType, c2 as uint64PType, bo as biguintPType, z as ArrayPType, aJ as ReadonlyArrayPType, e as accountPType, bq as bytesPType, ap as LibFunctionType, _ as ContractClassPType, bu as compiledContractType, aa as ImmutableObjectPType, b5 as applicationCallItxnType, v as voidPType, aw as MutableObjectPType, I as InternalError, c as CodeError, cq as throwError, cr as StringConstant, cs as BytesConstant, ct as IntegerConstant, cu as BoolConstant, cv as AddressConstant, cw as MethodConstant, cx as DecimalConstant, cy as TemplateVar, cg as LogSource, L as LogLevel, cz as instanceOfAny, cA as SingleEvaluation, cB as VarExpression, cC as nodeFactory, cD as NotSupported, l as logger, cE as TupleItemExpression, cF as FieldExpression, cG as IndexExpression, cH as TupleExpression, cI as AppStateExpression, cJ as AppAccountStateExpression, cK as BoxValueExpression, cL as StateGetEx, cM as StateGet, aU as TransientType, bU as numberPType, bn as bigIntPType, b6 as arc28EmitFunction, y as ArrayLiteralPType, H as BigIntLiteralPType, cN as hasFlags, cO as invariant, cP as BinaryBooleanOperator, ay as NamespacePType, bm as baseContractType, b9 as arc4BaseContractType, cQ as SymbolName, a_ as UnionPType, a9 as GroupTransactionPType, h as anyGtxnType, aX as Uint64EnumMemberType, aV as TypeParameterType, bB as esSymbol, c4 as unknownPType, bS as neverPType, b2 as anyPType, bT as nullPType, c3 as undefinedPType, Z as ClusteredPrototype, ae as IntersectionPType, bO as logicSigBaseType, av as LogicSigPType, aY as Uint64EnumType, a1 as FunctionPType, w as ApprovalProgram, X as ClearStateProgram, cn as isIn, R as BoxMapPType, S as BoxPType, as as LocalMapType, au as LocalStateType, a6 as GlobalMapType, a8 as GlobalStateType, aP as SuperPrototypeSelector, Y as ClusteredContractClassType, ch as SourceLocation, cR as intersectsFlags, cS as extractModuleName, cT as toSubScript, A as AbsolutePath, cU as CompilationSet, cV as ARC4ABIMethodConfig, C as ContractReference, V as BytesPType, cW as EqualityComparison, aB as ObjectLiteralPType, bE as isObjectType$1, b_ as readonlyDecorator, b7 as arc4AbiMethodDecorator, b8 as arc4BareMethodDecorator, cX as ARC4CreateOption, cY as NewArray, O as OnCompletionAction, cZ as BytesEncoding, ce as bigIntToUint8Array, c_ as FixableCodeError, c$ as UInt64BinaryOperator, d0 as tryConvertEnum, d1 as NumericComparison, d2 as UInt64UnaryOperator, bG as itoaMethod, aZ as Uint64Function, d3 as UInt64PostfixUnaryOperator, a0 as FixedArrayPType, al as IterableIteratorType, ak as IterableIteratorGeneric, f as applicationPType, g as assetPType, bV as onCompleteActionType, d4 as wrapInCodeError, cd as base32ToUint8Array, c1 as transactionTypeType, d5 as TransactionKind, bt as compileFunction, bv as compiledLogicSigType, d6 as LogicSigReference, ab as InnerTransactionPType, aT as TransactionFunctionType, c0 as submitGroupItxnFunction, am as ItxnParamsPType, d7 as getInnerTransactionType, d8 as getItxnParamsType, d9 as CompiledContract, da as ARC4BareMethodConfig, db as MethodSignature, cj as enumFromValue, x as ArrayGeneric, $ as FixedArrayGeneric, cm as zipStrict, bD as isArrayType, bF as isTupleLike, bQ as matchFunction, bb as assertMatchFunction, dc as BigUIntBinaryOperator, K as BigUintFunction, dd as BigUIntPostfixUnaryOperator, cf as utf8ToUint8Array, de as BytesBinaryOperator, df as IntrinsicCall, cb as uint8ArrayToUtf8, T as BytesFunction, U as BytesGeneric, cc as base64ToUint8Array, dg as enumKeyFromValue, dh as BytesUnaryOperator, bs as cloneFunction, bw as contractOptionsDecorator, bz as ensureBudgetFunction, di as PuyaLibFunction, bW as opUpFeeSourceType, af as IntrinsicEnumType, bP as logicSigOptionsDecorator, ac as InstanceType, aC as ObjectWithOptionalFieldsType, c7 as vrfVerifyPType, bR as mimcConfigurationsPType, by as ecdsaPType, bx as ecPType, bl as base64PType, ag as IntrinsicFunctionGroupType, dj as Expression, ai as IntrinsicFunctionType, aM as ReferenceArrayGeneric, aN as ReferenceArrayType, dk as AppStorageKind, a$ as UnsupportedType, dl as transientTypeErrors, a7 as GlobalStateGeneric, aR as TemplateVarFunction, dm as getGroupTransactionType, bH as itxnComposePType, aW as Uint64EnumMemberLiteralType, b0 as anyItxnParamsType, c6 as validateEncodingFunction, M as BooleanFunction, aO as StringFunction, aI as ReadonlyArrayGeneric, aK as ReadonlyGeneric, a2 as GeneratorGeneric, a3 as GeneratorType, aG as PromiseGeneric, aH as PromiseType, W as ClassMethodDecoratorContext, aQ as SuperPrototypeSelectorGeneric, aF as PolytypeClassMethodHelper, bL as logFunction, ba as assertFunction, bA as errFunction, bM as loggedAssertFunction, bN as loggedErrFunction, c5 as urangeFunction, br as bzeroFunction, aj as IntrinsicFunctionTypeType, q as ALL_OP_ENUMS, ah as IntrinsicFunctionGroupTypeType, a5 as GlobalMapGeneric, at as LocalStateGeneric, ar as LocalMapGeneric, N as BoxGeneric, Q as BoxMapGeneric, u as ApplicationFunction, r as AccountFunction, E as AssetFunction, p as paymentGtxnType, aE as PaymentTxnFunction, k as keyRegistrationGtxnType, an as KeyRegistrationTxnFunction, i as assetConfigGtxnType, B as AssetConfigTxnFunction, j as assetTransferGtxnType, F as AssetTransferTxnFunction, m as assetFreezeGtxnType, D as AssetFreezeTxnFunction, n as applicationCallGtxnType, t as ApplicationCallTxnFunction, aS as TransactionFunction, bX as paymentItxnFunction, bI as keyRegistrationItxnFunction, bc as assetConfigItxnFunction, bi as assetTransferItxnFunction, bf as assetFreezeItxnFunction, b3 as applicationCallItxnFunction, bZ as paymentItxnType, bK as keyRegistrationItxnType, be as assetConfigItxnType, bk as assetTransferItxnType, bh as assetFreezeItxnType, bY as paymentItxnParamsType, bJ as keyRegistrationItxnParamsType, bd as assetConfigItxnParamsType, bj as assetTransferItxnParamsType, bg as assetFreezeItxnParamsType, b4 as applicationCallItxnParamsType, bC as inputOnlyObjects, dn as Contract, dp as InstanceSuperMethodTarget, dq as ExpressionStatement, dr as AssertExpression, ds as VoidConstant, dt as ArrayConcat, du as ArrayPop, dv as ArrayReplace, dw as ArrayLength, dx as SizeOf, dy as UpdateInnerTransaction, dz as CheckedMaybe, dA as StageInnerTransactions, dB as SubmitInnerTransaction, dC as AssignmentExpression, dD as CommaExpression, dE as NumericComparisonExpression, dF as BytesComparisonExpression, dG as PuyaLibCall, dH as UInt64UnaryOperation, dI as UInt64PostfixUnaryOperation, dJ as BigUIntPostfixUnaryOperation, dK as BytesUnaryOperation, dL as UInt64BinaryOperation, dM as BigUIntBinaryOperation, dN as BooleanBinaryOperation, dO as Not, dP as Emit, dQ as Range, dR as Enumeration, dS as Reversed, dT as StateExists, dU as ARC4Router, dV as MethodSignatureString, dW as SubroutineID, dX as ContractMethodTarget, dY as InstanceMethodTarget, ca as uint8ArrayToBase32, ck as mkDirIfNotExists, dZ as patchErrorLocation, d_ as Goto, d$ as ReturnStatement, e0 as ContractMethod, e1 as sameSets, b as ContractClassModel, e2 as Subroutine, e3 as LogicSigClassModel, e4 as ptypeIn, e5 as expandMaybeArray, a as LoggingContext, P as PuyaError } from './contract-class-model-D-NUE8Zg.js';
 import * as fs from 'node:fs';
 import 'node:util';
 import pathe__default, { normalize } from 'pathe';
@@ -244,14 +244,14 @@ const arc4StructBaseType = new ARC4StructType({
     description: undefined,
     frozen: false,
 });
-const Arc4TupleGeneric = new GenericPType({
+const ARC4TupleGeneric = new GenericPType({
     name: 'Tuple',
     module: Constants.moduleNames.algoTs.arc4.encodedTypes,
     parameterise([tupleType, ...rest]) {
         codeInvariant(tupleType && !rest.length, `${this.name} expects 1 generic parameter`);
         codeInvariant(tupleType instanceof ReadonlyTuplePType || tupleType instanceof MutableTuplePType, `${this.name} generic parameter must be a native tuple type`);
         const encodedTypes = tupleType.items.map((itemType, index) => {
-            codeInvariant(itemType instanceof ARC4EncodedType, `Item ${index} of ARC4 Tuple must be an ARC4 encoded type`);
+            codeInvariant(itemType instanceof ARC4EncodedType, `Item ${index} of ${this.name} must be an ARC4 encoded type`);
             return itemType;
         });
         return new ARC4TupleType({
@@ -291,9 +291,9 @@ const UintNGeneric = new GenericPType({
     name: 'Uint',
     module: Constants.moduleNames.algoTs.arc4.encodedTypes,
     parameterise(typeArgs) {
-        codeInvariant(typeArgs.length === 1, 'UintNType type expects exactly one type parameter');
+        codeInvariant(typeArgs.length === 1, `${this.name} type expects exactly one type parameter`);
         const [size] = typeArgs;
-        codeInvariant(size instanceof NumericLiteralPType && size.literalValue, `Generic type param for UintNType must be a literal number. Inferred type is ${size.name}`);
+        codeInvariant(size instanceof NumericLiteralPType && size.literalValue, `Generic type param for ${this.name} must be a literal number. Inferred type is ${size.name}`);
         return new UintNType({ n: size.literalValue });
     },
 });
@@ -326,8 +326,8 @@ const UFixedNxMGeneric = new GenericPType({
     parameterise(typeArgs) {
         codeInvariant(typeArgs.length === 2, `${this.name} expects exactly 2 generic type parameters`);
         const [n, m] = typeArgs;
-        codeInvariant(n instanceof NumericLiteralPType && n.literalValue, `Generic type param 'N' for ${this.name}  must be a literal number. Inferred type is ${n.name}`);
-        codeInvariant(m instanceof NumericLiteralPType && m.literalValue, `Generic type param 'M' for UintNType must be a literal number. Inferred type is ${m.name}`);
+        codeInvariant(n instanceof NumericLiteralPType && n.literalValue, `Generic type param 'N' for ${this.name} must be a literal number. Inferred type is ${n.name}`);
+        codeInvariant(m instanceof NumericLiteralPType && m.literalValue, `Generic type param 'M' for ${this.name} must be a literal number. Inferred type is ${m.name}`);
         return new UFixedNxMType({
             n: n.literalValue,
             m: m.literalValue,
@@ -352,7 +352,7 @@ class UFixedNxMType extends ARC4EncodedType {
         codeInvariant(m >= 1n && m <= 160n, 'm must be between 1 and 160');
         this.n = n;
         this.m = m;
-        this.name = `${UFixedNxMGeneric.name}<${n}, ${m}>`;
+        this.name = `UFixed<${n}, ${m}>`;
         this.wtype = new wtypes.ARC4UFixedNxM({ n: this.n, m: this.m });
         this.abiTypeSignature = `ufixed${n}x${m}`;
     }
@@ -364,10 +364,10 @@ const arc4ByteAlias = new UintNType({ n: 8n, wtype: wtypes.arc4ByteAliasWType, n
 const DynamicArrayGeneric = new GenericPType({
     name: 'DynamicArray',
     module: Constants.moduleNames.algoTs.arc4.encodedTypes,
-    parameterise: (typeArgs) => {
-        codeInvariant(typeArgs.length === 1, 'DynamicArray type expects exactly one type parameter');
+    parameterise(typeArgs) {
+        codeInvariant(typeArgs.length === 1, `${this.name} type expects exactly one type parameter`);
         const [elementType] = typeArgs;
-        codeInvariant(elementType instanceof ARC4EncodedType, `Generic type param for DynamicArray must be an ARC4 encoded type. Inferred type is ${elementType.name}`);
+        codeInvariant(elementType instanceof ARC4EncodedType, `Generic type param for ${this.name} must be an ARC4 encoded type. Inferred type is ${elementType.name}`);
         return new DynamicArrayType({ elementType: elementType });
     },
 });
@@ -403,11 +403,11 @@ class DynamicArrayType extends ARC4ArrayType {
 const StaticArrayGeneric = new GenericPType({
     name: 'StaticArray',
     module: Constants.moduleNames.algoTs.arc4.encodedTypes,
-    parameterise: (typeArgs) => {
-        codeInvariant(typeArgs.length === 2, 'StaticArray type expects exactly one type parameters');
+    parameterise(typeArgs) {
+        codeInvariant(typeArgs.length === 2, `${this.name} type expects exactly two type parameters`);
         const [elementType, arraySize] = typeArgs;
-        codeInvariant(elementType instanceof ARC4EncodedType, `Element type generic type param for StaticArray must be an ARC4 encoded type. Inferred type is ${elementType.name}`);
-        codeInvariant(arraySize instanceof NumericLiteralPType, `Array size generic type param for StaticArray must be a literal number. Inferred type is ${arraySize.name}`);
+        codeInvariant(elementType instanceof ARC4EncodedType, `Element type generic type param for ${this.name} must be an ARC4 encoded type. Inferred type is ${elementType.name}`);
+        codeInvariant(arraySize instanceof NumericLiteralPType, `Array size generic type param for ${this.name} must be a literal number. Inferred type is ${arraySize.name}`);
         return new StaticArrayType({ arraySize: arraySize.literalValue, elementType });
     },
 });
@@ -459,10 +459,10 @@ const AddressClass = new LibClassType({
 const StaticBytesGeneric = new GenericPType({
     name: 'StaticBytes',
     module: Constants.moduleNames.algoTs.arc4.encodedTypes,
-    parameterise: (typeArgs) => {
-        codeInvariant(typeArgs.length === 1, 'StaticBytes type expects exactly one type parameter');
+    parameterise(typeArgs) {
+        codeInvariant(typeArgs.length === 1, `${this.name} type expects exactly one type parameter`);
         const [length] = typeArgs;
-        codeInvariant(length instanceof NumericLiteralPType, `Length generic type param for StaticBytes must be a literal number. Inferred type is ${length.name}`);
+        codeInvariant(length instanceof NumericLiteralPType, `Length generic type param for ${this.name} must be a literal number. Inferred type is ${length.name}`);
         return new StaticBytesType({
             length: length.literalValue,
         });
@@ -480,12 +480,12 @@ class StaticBytesType extends StaticArrayType {
         });
     }
 }
-const DynamicBytesConstructor = new LibClassType({
+const DynamicBytesClass = new LibClassType({
     name: 'DynamicBytes',
     module: Constants.moduleNames.algoTs.arc4.encodedTypes,
 });
-const DynamicBytesType = new DynamicArrayType({
-    name: `DynamicBytes`,
+const dynamicBytesType = new DynamicArrayType({
+    name: 'DynamicBytes',
     immutable: true,
     elementType: arc4ByteAlias,
     nativeType: bytesPType,
@@ -522,9 +522,9 @@ const ContractProxyGeneric = new GenericPType({
     name: 'ContractProxy',
     module: Constants.moduleNames.algoTs.arc4.c2c,
     parameterise(args) {
-        invariant(args.length === 1, 'ContractProxy expects exactly 1 type arg');
+        codeInvariant(args.length === 1, `${this.name} expects exactly 1 type arg`);
         const [typeArg] = args;
-        invariant(typeArg instanceof ContractClassPType && typeArg.isARC4, 'Contract Proxy generic type arg must extend arc4 Contract type');
+        codeInvariant(typeArg instanceof ContractClassPType && typeArg.isARC4, `${this.name} generic type arg must extend arc4 Contract type`);
         return new ContractProxyType({ contractType: typeArg });
     },
 });
@@ -549,7 +549,7 @@ const TypedApplicationCallResponseGeneric = new GenericPType({
     name: 'TypedApplicationCallResponse',
     module: Constants.moduleNames.algoTs.arc4.c2c,
     parameterise(args) {
-        invariant(args.length === 1, 'TypedApplicationCallResponse expects exactly 1 type arg');
+        codeInvariant(args.length === 1, `${this.name} expects exactly 1 type arg`);
         const [typeArg] = args;
         return new TypedApplicationCallResponseType({ returnValue: typeArg });
     },
@@ -562,11 +562,11 @@ class TypedApplicationCallResponseType extends ImmutableObjectPType {
     constructor({ returnValue }) {
         super({
             properties: returnValue.equals(voidPType)
-                ? [{ name: 'itxn', ptype: applicationItxnType, description: null }]
+                ? [{ name: 'itxn', ptype: applicationCallItxnType, description: null }]
                 : [
                     {
                         name: 'itxn',
-                        ptype: applicationItxnType,
+                        ptype: applicationCallItxnType,
                         description: null,
                     },
                     {
@@ -2417,7 +2417,7 @@ let TypeResolver = (() => {
                 return node.typeArguments.map((t) => this.resolveTypeNode(t, sourceLocation));
             }
             const sig = this.checker.getResolvedSignature(node);
-            invariant(sig, 'CallExpression must resolve to a signature');
+            invariant(sig, 'CallExpression must resolve to a signature', sourceLocation);
             const tps = this.checker.getTypeArgumentsForResolvedSignature(sig);
             return tps?.map((t) => this.resolveType(t, sourceLocation)) ?? [];
         }
@@ -2592,7 +2592,7 @@ let TypeResolver = (() => {
                 if (typeName.fullName === logicSigBaseType.fullName)
                     return logicSigBaseType;
                 const [baseType, ...rest] = tsType.getBaseTypes()?.map((t) => this.resolveType(t, sourceLocation)) ?? [];
-                invariant(rest.length === 0, 'Class can have at most one base type');
+                invariant(rest.length === 0, 'Class can have at most one base type', sourceLocation);
                 // Treat sub-types of UintN type as the base type.
                 if (baseType instanceof UintNType)
                     return baseType;
@@ -2685,7 +2685,7 @@ let TypeResolver = (() => {
                 if (expectReadonly !== readonly) {
                     const correction = expectReadonly
                         ? 'Add a readonly modifier to this property, or remove it from all others'
-                        : 'Remove the readonly modifier from this property, or add it all others';
+                        : 'Remove the readonly modifier from this property, or add it to all others';
                     logger.error(propLocation, `All properties of a type must share the same readonly annotation. ${correction}`);
                 }
                 const ptype = this.resolveType(type, propLocation);
@@ -2708,7 +2708,7 @@ let TypeResolver = (() => {
         }
         reflectConstructorType(tsType, sourceLocation) {
             const constructorSignatures = tsType.getConstructSignatures();
-            invariant(constructorSignatures.length, 'Must have at least one signature');
+            invariant(constructorSignatures.length, 'Must have at least one signature', sourceLocation);
             const typeDeclaration = tsType.getSymbol()?.declarations?.[0];
             if (typeDeclaration && ts.isClassDeclaration(typeDeclaration)) {
                 const ptype = this.resolve(typeDeclaration, sourceLocation);
@@ -2793,7 +2793,7 @@ let TypeResolver = (() => {
             });
         }
         resolveClusteredPrototype(tsType, sourceLocation) {
-            invariant(isIntersectionType(tsType), 'Clustered prototypes must be an intersection type');
+            invariant(isIntersectionType(tsType), 'Clustered prototypes must be an intersection type', sourceLocation);
             const baseContracts = [];
             for (const t of tsType.types.map((t) => this.resolveType(t, sourceLocation))) {
                 if (t instanceof ContractClassPType) {
@@ -4755,7 +4755,7 @@ function concatArrays(left, right, sourceLocation) {
           TODO: This is only required because puya doesn't support staticarray + other => dynamic array
           To work around this, we convert arc4 static bytes and static array to dynamic bytes and dynamic array
          */
-        const dynamicType = left.ptype instanceof StaticBytesType ? DynamicBytesType : new DynamicArrayType({ ...left.ptype });
+        const dynamicType = left.ptype instanceof StaticBytesType ? dynamicBytesType : new DynamicArrayType({ ...left.ptype });
         return concatArrays(toArc4Dynamic(left.ptype.arraySize, left.resolve(), dynamicType), right, sourceLocation);
     }
     else if (left.ptype instanceof FixedArrayPType || left.ptype instanceof ReadonlyArrayPType) {
@@ -4783,8 +4783,8 @@ function getArrayConcatType(left, right, sourceLocation) {
     if (left instanceof ARC4ArrayType) {
         if (right instanceof ARC4ArrayType) {
             sameElementType(left.elementType, right.elementType, sourceLocation);
-            if (left.equals(DynamicBytesType) || left instanceof StaticBytesType) {
-                return DynamicBytesType;
+            if (left.equals(dynamicBytesType) || left instanceof StaticBytesType) {
+                return dynamicBytesType;
             }
             return new DynamicArrayType({
                 elementType: left.elementType,
@@ -5229,7 +5229,7 @@ class StaticBytesClassBuilder extends ClassBuilder {
     }
 }
 class DynamicBytesClassBuilder extends ClassBuilder {
-    ptype = DynamicBytesConstructor;
+    ptype = DynamicBytesClass;
     newCall(args, typeArgs, sourceLocation) {
         const { args: [initialValue], } = parseFunctionArgs({
             args,
@@ -5239,7 +5239,7 @@ class DynamicBytesClassBuilder extends ClassBuilder {
             genericTypeArgs: 0,
             argSpec: (a) => [a.optional(bytesPType, stringPType)],
         });
-        const resultPType = DynamicBytesType;
+        const resultPType = dynamicBytesType;
         if (!initialValue) {
             return instanceEb(nodeFactory.bytesConstant({
                 value: new Uint8Array([0, 0]),
@@ -5758,7 +5758,7 @@ function getTxnFieldMetaData({ kind, memberName, direction = 'out', }) {
 }
 
 class CompileFunctionBuilder extends FunctionBuilder {
-    ptype = compileFunctionType;
+    ptype = compileFunction;
     call(args, typeArgs, sourceLocation) {
         const { args: [contractOrSig, options], } = parseFunctionArgs({
             args,
@@ -6161,7 +6161,7 @@ class ContractProxyBareCreateFunctionBuilder extends FunctionBuilder {
             fields,
             applicationProxy: this.proxy,
         });
-        return instanceEb(itxnResult, applicationItxnType);
+        return instanceEb(itxnResult, applicationCallItxnType);
     }
 }
 class ContractProxyCallBuilder extends NodeBuilder {
@@ -6498,7 +6498,7 @@ class StructExpressionBuilder extends Arc4EncodedBaseExpressionBuilder {
 }
 
 class Arc4TupleClassBuilder extends ClassBuilder {
-    ptype = Arc4TupleGeneric;
+    ptype = ARC4TupleGeneric;
     newCall(args, typeArgs, sourceLocation) {
         const { args: tupleItems, ptypes: [tupleType], } = parseFunctionArgs({
             args,
@@ -6508,7 +6508,7 @@ class Arc4TupleClassBuilder extends ClassBuilder {
             callLocation: sourceLocation,
             argSpec: (a) => args.map(() => a.required()),
         });
-        const ptype = Arc4TupleGeneric.parameterise([tupleType]);
+        const ptype = ARC4TupleGeneric.parameterise([tupleType]);
         if (args.length === 0) {
             return new Arc4TupleExpressionBuilder(intrinsicFactory.bzero({
                 size: nodeFactory.sizeOf({ sizeWtype: ptype.wtype, wtype: wtypes.uint64WType, sourceLocation }),
@@ -8213,7 +8213,7 @@ class BzeroFunctionBuilder extends FunctionBuilder {
 }
 
 class CloneFunctionBuilder extends FunctionBuilder {
-    ptype = cloneFunctionPType;
+    ptype = cloneFunction;
     call(args, typeArgs, sourceLocation) {
         const { args: [target], } = parseFunctionArgs({
             args,
@@ -15815,7 +15815,7 @@ class UrangeFunctionBuilder extends FunctionBuilder {
 }
 
 class ValidateEncodingFunctionBuilder extends FunctionBuilder {
-    ptype = validateEncodingFunctionPType;
+    ptype = validateEncodingFunction;
     call(args, typeArgs, sourceLocation) {
         const { ptypes: [ptype], args: [theValue], } = parseFunctionArgs({
             args,
@@ -15911,10 +15911,10 @@ function registerPTypes(typeRegistry) {
     typeRegistry.register({ ptype: ensureBudgetFunction, singletonEb: EnsureBudgetFunctionBuilder });
     typeRegistry.register({ ptype: urangeFunction, singletonEb: UrangeFunctionBuilder });
     typeRegistry.register({ ptype: TemplateVarFunction, singletonEb: TemplateVarFunctionBuilder });
-    typeRegistry.register({ ptype: compileFunctionType, singletonEb: CompileFunctionBuilder });
+    typeRegistry.register({ ptype: compileFunction, singletonEb: CompileFunctionBuilder });
     typeRegistry.register({ ptype: arc28EmitFunction, singletonEb: Arc28EmitFunctionBuilder });
-    typeRegistry.register({ ptype: cloneFunctionPType, singletonEb: CloneFunctionBuilder });
-    typeRegistry.register({ ptype: validateEncodingFunctionPType, singletonEb: ValidateEncodingFunctionBuilder });
+    typeRegistry.register({ ptype: cloneFunction, singletonEb: CloneFunctionBuilder });
+    typeRegistry.register({ ptype: validateEncodingFunction, singletonEb: ValidateEncodingFunctionBuilder });
     typeRegistry.register({ ptype: ContractClassPType, singletonEb: ContractClassBuilder });
     typeRegistry.register({ ptype: contractOptionsDecorator, singletonEb: ContractOptionsDecoratorBuilder });
     typeRegistry.register({ ptype: LogicSigPType, singletonEb: LogicSigClassBuilder });
@@ -16006,7 +16006,7 @@ function registerPTypes(typeRegistry) {
         singletonEb: BoxMapFunctionBuilder,
     });
     // Reference types
-    typeRegistry.register({ ptype: ApplicationFunctionType, singletonEb: ApplicationFunctionBuilder });
+    typeRegistry.register({ ptype: ApplicationFunction, singletonEb: ApplicationFunctionBuilder });
     typeRegistry.register({ ptype: applicationPType, instanceEb: ApplicationExpressionBuilder });
     typeRegistry.register({ ptype: AccountFunction, singletonEb: AccountFunctionBuilder });
     typeRegistry.register({ ptype: accountPType, instanceEb: AccountExpressionBuilder });
@@ -16039,8 +16039,8 @@ function registerPTypes(typeRegistry) {
     // More specific types need to be registered before their base types
     // This ensures the specific type is selected during type resolution
     // For example, StaticBytesExpressionBuilder should be selected over general StaticArrayExpressionBuilder for StaticBytesType
-    typeRegistry.register({ ptype: DynamicBytesConstructor, singletonEb: DynamicBytesClassBuilder });
-    typeRegistry.register({ ptype: DynamicBytesType, instanceEb: DynamicBytesExpressionBuilder });
+    typeRegistry.register({ ptype: DynamicBytesClass, singletonEb: DynamicBytesClassBuilder });
+    typeRegistry.register({ ptype: dynamicBytesType, instanceEb: DynamicBytesExpressionBuilder });
     typeRegistry.registerGeneric({
         generic: StaticBytesGeneric,
         ptype: StaticBytesType,
@@ -16066,7 +16066,7 @@ function registerPTypes(typeRegistry) {
     typeRegistry.register({ ptype: arc4StringType, instanceEb: StrExpressionBuilder });
     typeRegistry.register({ ptype: ARC4StrClass, singletonEb: StrClassBuilder });
     typeRegistry.registerGeneric({
-        generic: Arc4TupleGeneric,
+        generic: ARC4TupleGeneric,
         ptype: ARC4TupleType,
         instanceEb: Arc4TupleExpressionBuilder,
         singletonEb: Arc4TupleClassBuilder,
@@ -16094,23 +16094,23 @@ function registerPTypes(typeRegistry) {
     typeRegistry.register({ ptype: assetFreezeGtxnType, instanceEb: GroupTransactionExpressionBuilder });
     typeRegistry.register({ ptype: AssetFreezeTxnFunction, singletonEb: GroupTransactionFunctionBuilder });
     typeRegistry.register({ ptype: applicationCallGtxnType, instanceEb: GroupTransactionExpressionBuilder });
-    typeRegistry.register({ ptype: ApplicationTxnFunction, singletonEb: GroupTransactionFunctionBuilder });
+    typeRegistry.register({ ptype: ApplicationCallTxnFunction, singletonEb: GroupTransactionFunctionBuilder });
     typeRegistry.register({ ptype: anyGtxnType, instanceEb: GroupTransactionExpressionBuilder });
     typeRegistry.register({ ptype: TransactionFunction, singletonEb: GroupTransactionFunctionBuilder });
     // ITXN Types
-    typeRegistry.register({ ptype: paymentItxnFn, singletonEb: ItxnParamsFactoryFunctionBuilder });
-    typeRegistry.register({ ptype: keyRegistrationItxnFn, singletonEb: ItxnParamsFactoryFunctionBuilder });
-    typeRegistry.register({ ptype: assetConfigItxnFn, singletonEb: ItxnParamsFactoryFunctionBuilder });
-    typeRegistry.register({ ptype: assetTransferItxnFn, singletonEb: ItxnParamsFactoryFunctionBuilder });
-    typeRegistry.register({ ptype: assetFreezeItxnFn, singletonEb: ItxnParamsFactoryFunctionBuilder });
-    typeRegistry.register({ ptype: applicationCallItxnFn, singletonEb: ItxnParamsFactoryFunctionBuilder });
+    typeRegistry.register({ ptype: paymentItxnFunction, singletonEb: ItxnParamsFactoryFunctionBuilder });
+    typeRegistry.register({ ptype: keyRegistrationItxnFunction, singletonEb: ItxnParamsFactoryFunctionBuilder });
+    typeRegistry.register({ ptype: assetConfigItxnFunction, singletonEb: ItxnParamsFactoryFunctionBuilder });
+    typeRegistry.register({ ptype: assetTransferItxnFunction, singletonEb: ItxnParamsFactoryFunctionBuilder });
+    typeRegistry.register({ ptype: assetFreezeItxnFunction, singletonEb: ItxnParamsFactoryFunctionBuilder });
+    typeRegistry.register({ ptype: applicationCallItxnFunction, singletonEb: ItxnParamsFactoryFunctionBuilder });
     typeRegistry.register({ ptype: submitGroupItxnFunction, singletonEb: SubmitItxnGroupFunctionBuilder });
     typeRegistry.register({ ptype: paymentItxnType, instanceEb: InnerTransactionExpressionBuilder });
     typeRegistry.register({ ptype: keyRegistrationItxnType, instanceEb: InnerTransactionExpressionBuilder });
     typeRegistry.register({ ptype: assetConfigItxnType, instanceEb: InnerTransactionExpressionBuilder });
     typeRegistry.register({ ptype: assetTransferItxnType, instanceEb: InnerTransactionExpressionBuilder });
     typeRegistry.register({ ptype: assetFreezeItxnType, instanceEb: InnerTransactionExpressionBuilder });
-    typeRegistry.register({ ptype: applicationItxnType, instanceEb: InnerTransactionExpressionBuilder });
+    typeRegistry.register({ ptype: applicationCallItxnType, instanceEb: InnerTransactionExpressionBuilder });
     typeRegistry.register({ ptype: paymentItxnParamsType, instanceEb: ItxnParamsExpressionBuilder });
     typeRegistry.register({ ptype: keyRegistrationItxnParamsType, instanceEb: ItxnParamsExpressionBuilder });
     typeRegistry.register({ ptype: assetConfigItxnParamsType, instanceEb: ItxnParamsExpressionBuilder });
@@ -23506,5 +23506,5 @@ class PuyaOptions {
     }
 }
 
-export { parseCliTemplateVar as $, ARC4ArrayType as A, ByteClass as B, ContractProxyGeneric as C, DynamicArrayGeneric as D, abiCallFunction as E, arc4AddressAlias as F, arc4BooleanType as G, arc4ByteAlias as H, arc4StringType as I, arc4StructBaseType as J, compileArc4Function as K, convertBytesFunction as L, decodeArc4Function as M, encodeArc4Function as N, methodSelectorFunction as O, sizeOfFunction as P, uint8ArrayToHex as Q, hexToUint8Array as R, StaticArrayGeneric as S, TypedApplicationCallResponseGeneric as T, UFixedNxMGeneric as U, CompileOptions as V, TypeResolver as W, processInputPaths as X, registerPTypes as Y, typeRegistry as Z, defaultPuyaOptions as _, ARC4BoolClass as a, LocalsCoalescingStrategy as a0, PuyaService as a1, deserializeAndLog as a2, createTsProgram as a3, buildAwst as a4, validateAwst as a5, sleep as a6, DefaultMap as a7, relinquishThread as a8, ARC4EncodedType as b, ARC4InstanceType as c, ARC4StrClass as d, ARC4StructClass as e, ARC4StructType as f, ARC4TupleType as g, AddressClass as h, Arc4TupleGeneric as i, ContractProxyType as j, DynamicArrayType as k, DynamicBytesConstructor as l, DynamicBytesType as m, StaticArrayType as n, StaticBytesGeneric as o, StaticBytesType as p, TypedApplicationCallResponseType as q, UFixedNxMType as r, UintN128Class as s, UintN16Class as t, UintN256Class as u, UintN32Class as v, UintN64Class as w, UintN8Class as x, UintNGeneric as y, UintNType as z };
-//# sourceMappingURL=options-DD9MApH4.js.map
+export { parseCliTemplateVar as $, ARC4ArrayType as A, ByteClass as B, ContractProxyGeneric as C, DynamicArrayGeneric as D, arc4AddressAlias as E, arc4BooleanType as F, arc4ByteAlias as G, arc4StringType as H, arc4StructBaseType as I, compileArc4Function as J, convertBytesFunction as K, decodeArc4Function as L, dynamicBytesType as M, encodeArc4Function as N, methodSelectorFunction as O, sizeOfFunction as P, uint8ArrayToHex as Q, hexToUint8Array as R, StaticArrayGeneric as S, TypedApplicationCallResponseGeneric as T, UFixedNxMGeneric as U, CompileOptions as V, TypeResolver as W, processInputPaths as X, registerPTypes as Y, typeRegistry as Z, defaultPuyaOptions as _, ARC4BoolClass as a, LocalsCoalescingStrategy as a0, PuyaService as a1, deserializeAndLog as a2, createTsProgram as a3, buildAwst as a4, validateAwst as a5, sleep as a6, DefaultMap as a7, relinquishThread as a8, ARC4EncodedType as b, ARC4InstanceType as c, ARC4StrClass as d, ARC4StructClass as e, ARC4StructType as f, ARC4TupleGeneric as g, ARC4TupleType as h, AddressClass as i, ContractProxyType as j, DynamicArrayType as k, DynamicBytesClass as l, StaticArrayType as m, StaticBytesGeneric as n, StaticBytesType as o, TypedApplicationCallResponseType as p, UFixedNxMType as q, UintN128Class as r, UintN16Class as s, UintN256Class as t, UintN32Class as u, UintN64Class as v, UintN8Class as w, UintNGeneric as x, UintNType as y, abiCallFunction as z };
+//# sourceMappingURL=options-DLmtdJgF.js.map