@algorandfoundation/puya-ts 1.2.0-beta.1 → 1.2.0-beta.3

package/{options-5IubucAG.js → options-COFRHTFQ.js}

@@ -84,7 +84,7 @@ const Constants = {
         zeroAddressB32: 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY5HFKQ',
     },
     supportedAvmVersions: [10n, 11n, 12n, 13n],
-    targetedPuyaVersion: '5.3.2',
+    targetedPuyaVersion: '5.7.1',
     puyaGithubRepo: 'algorandfoundation/puya',
     minNodeVersion: '20.11.1',
     languageServerSource: 'puyats',
@@ -1115,7 +1115,7 @@ var wtypes;
         constructor({ elementType, sourceLocation, arraySize, arc4Alias, immutable, }) {
             super({
                 elementType,
-                name: `arc4.static_array<${elementType.name}>`,
+                name: `arc4.static_array<${elementType.name},${arraySize}>`,
                 arc4Alias: arc4Alias ?? null,
                 immutable,
             });
@@ -3233,10 +3233,12 @@ class AssertExpression extends Expression {
         this.condition = props.condition;
         this.errorMessage = props.errorMessage;
         this.wtype = props.wtype;
+        this.explicit = props.explicit;
     }
     condition;
     errorMessage;
     wtype;
+    explicit;
     accept(visitor) {
         return visitor.visitAssertExpression(this);
     }
@@ -3335,6 +3337,26 @@ class TemplateVar extends Expression {
         return visitor.visitTemplateVar(this);
     }
 }
+class MethodSignatureString extends Node {
+    constructor(props) {
+        super(props);
+        this.value = props.value;
+    }
+    value;
+}
+class MethodSignature extends Node {
+    constructor(props) {
+        super(props);
+        this.name = props.name;
+        this.argTypes = props.argTypes;
+        this.returnType = props.returnType;
+        this.resourceEncoding = props.resourceEncoding;
+    }
+    name;
+    argTypes;
+    returnType;
+    resourceEncoding;
+}
 class MethodConstant extends Expression {
     constructor(props) {
         super(props);
@@ -3531,6 +3553,20 @@ class UpdateInnerTransaction extends Expression {
         return visitor.visitUpdateInnerTransaction(this);
     }
 }
+class StageInnerTransactions extends Expression {
+    constructor(props) {
+        super(props);
+        this.itxns = props.itxns;
+        this.startNewGroup = props.startNewGroup;
+        this.wtype = props.wtype;
+    }
+    itxns;
+    startNewGroup;
+    wtype;
+    accept(visitor) {
+        return visitor.visitStageInnerTransactions(this);
+    }
+}
 class GroupTransactionReference extends Expression {
     constructor(props) {
         super(props);
@@ -4579,18 +4615,18 @@ class ARC4ABIMethodConfig {
         this.create = props.create;
         this.name = props.name;
         this.resourceEncoding = props.resourceEncoding;
-        this.validateEncoding = props.validateEncoding;
         this.readonly = props.readonly;
         this.defaultArgs = props.defaultArgs;
+        this.validateEncoding = props.validateEncoding;
     }
     sourceLocation;
     allowedCompletionTypes;
     create;
     name;
     resourceEncoding;
-    validateEncoding;
     readonly;
     defaultArgs;
+    validateEncoding;
 }
 const concreteNodes = {
     expressionStatement: ExpressionStatement,
@@ -4610,6 +4646,8 @@ const concreteNodes = {
     stringConstant: StringConstant,
     voidConstant: VoidConstant,
     templateVar: TemplateVar,
+    methodSignatureString: MethodSignatureString,
+    methodSignature: MethodSignature,
     methodConstant: MethodConstant,
     addressConstant: AddressConstant,
     aRC4Encode: ARC4Encode,
@@ -4625,6 +4663,7 @@ const concreteNodes = {
     intrinsicCall: IntrinsicCall,
     createInnerTransaction: CreateInnerTransaction,
     updateInnerTransaction: UpdateInnerTransaction,
+    stageInnerTransactions: StageInnerTransactions,
     groupTransactionReference: GroupTransactionReference,
     checkedMaybe: CheckedMaybe,
     tupleExpression: TupleExpression,
@@ -4761,6 +4800,13 @@ const constantEvaluation = {
 var WInnerTransactionFields = wtypes.WInnerTransactionFields;
 var WTuple = wtypes.WTuple;
 const explicitNodeFactory = {
+    assertExpression(props) {
+        return new AssertExpression({
+            ...props,
+            wtype: wtypes.voidWType,
+            explicit: true,
+        });
+    },
     voidConstant(props) {
         return new VoidConstant({
             ...props,
@@ -5148,6 +5194,7 @@ class LoggingContext {
     #logEvents = [];
     #sourcesByPath = {};
     #logEventsByPath = {};
+    treatWarningsAsErrors = false;
     get logEvents() {
         return this.#logEvents;
     }
@@ -5167,6 +5214,9 @@ class LoggingContext {
         }
     }
     addLog(log) {
+        if (this.treatWarningsAsErrors && log.level === LogLevel.Warning) {
+            log.level = LogLevel.Error;
+        }
         this.#logEvents.push(log);
         const filePath = log.sourceLocation?.file?.toString();
         if (filePath) {
@@ -8507,26 +8557,19 @@ function arc4ConfigFromType(functionType, sourceLocation) {
  * @param sourceLocation The source location of the code generating the constant,
  */
 function buildArc4MethodConstant(functionType, arc4Config, sourceLocation) {
-    const params = functionType.parameters
-        .map(([_, ptype]) => getABITypeName(ptype, 'in', arc4Config.resourceEncoding, sourceLocation))
-        .join(',');
-    const returnType = getABITypeName(functionType.returnType, 'out', arc4Config.resourceEncoding, sourceLocation);
+    const methodSignature = nodeFactory.methodSignature({
+        name: arc4Config.name,
+        argTypes: functionType.parameters.map(([_, ptype]) => ptype.wtypeOrThrow),
+        returnType: functionType.returnType.wtypeOrThrow,
+        resourceEncoding: arc4Config.resourceEncoding,
+        sourceLocation,
+    });
     return nodeFactory.methodConstant({
-        value: `${arc4Config.name}(${params})${returnType}`,
+        value: methodSignature,
         wtype: new wtypes.BytesWType({ length: 4n }),
         sourceLocation,
     });
 }
-/**
- * Get the ARC4 type name for a ptype, or throw if the ptype is not usable in an ABI method.
- * @param ptype The ptype of the parameter
- * @param direction The direction of the parameter (in for method args, out for method returns)
- * @param resourceEncoding The encoding strategy for the foreign resource types (App, Asset, Account)
- * @param sourceLocation The location of the method or parameter, for use in error metadata
- */
-function getABITypeName(ptype, direction, resourceEncoding, sourceLocation) {
-    return ptypeToAbiPType(ptype, direction, resourceEncoding, sourceLocation).abiTypeSignature;
-}
 /**
  * Is the given type an ARC4 encoded type, or can it be encoded to one
  * @param ptype The type to check
@@ -11917,7 +11960,7 @@ class MethodSelectorFunctionBuilder extends FunctionBuilder {
                     throw new CodeError(`${this.typeDescription} expects exactly 1 argument that is either a string literal, or a contract function reference`, { sourceLocation });
                 }
                 return instanceEb(nodeFactory.methodConstant({
-                    value: requireStringConstant(methodSignature).value,
+                    value: nodeFactory.methodSignatureString({ value: requireStringConstant(methodSignature).value, sourceLocation }),
                     wtype: methodConstantType.wtype,
                     sourceLocation,
                 }), methodConstantType);
@@ -12222,7 +12265,26 @@ function parseAppArgs({ fields, methodSelector, functionType, sourceLocation, })
         foreignAssets: new Array(),
     };
     const appArgsBuilder = fields && fields.hasProperty('args') && fields.memberAccess('args', sourceLocation);
-    const parsedSignature = parseArc4Method(methodSelector.value);
+    let parsedSignature = null;
+    if (methodSelector.value instanceof MethodSignature) {
+        parsedSignature = {
+            name: methodSelector.value.name,
+            parameters: methodSelector.value.argTypes,
+            returnType: methodSelector.value.returnType,
+            resourceEncoding: methodSelector.value.resourceEncoding,
+        };
+    }
+    else if (methodSelector.value instanceof MethodSignatureString) {
+        const parsedArc4Method = parseArc4Method(methodSelector.value.value);
+        parsedSignature = {
+            name: parsedArc4Method.name,
+            parameters: parsedArc4Method.parameters.map((ptype) => ptype.wtypeOrThrow),
+            returnType: parsedArc4Method.returnType.wtypeOrThrow,
+        };
+    }
+    if (!parsedSignature) {
+        throw new InternalError('Unable to parse method signature from method selector');
+    }
     const appArgs = [methodSelector];
     if (appArgsBuilder) {
         codeInvariant(isStaticallyIterable(appArgsBuilder), 'Unsupported expression for args', appArgsBuilder.sourceLocation);
@@ -12238,14 +12300,16 @@ function parseAppArgs({ fields, methodSelector, functionType, sourceLocation, })
                 results.itxns.push(arg.resolve());
                 return [];
             }
-            if (publicParamType.equals(assetPType)) {
-                return handleForeignRef(results.foreignAssets, 0n, paramType, arg);
-            }
-            else if (publicParamType.equals(applicationPType)) {
-                return handleForeignRef(results.foreignApps, 1n, paramType, arg);
-            }
-            else if (publicParamType.equals(accountPType)) {
-                return handleForeignRef(results.foreignAccounts, 1n, paramType, arg);
+            if (parsedSignature.resourceEncoding === 'index') {
+                if (publicParamType.equals(wtypes.assetWType)) {
+                    return handleForeignRef(results.foreignAssets, 0n, paramType, arg);
+                }
+                else if (publicParamType.equals(wtypes.applicationWType)) {
+                    return handleForeignRef(results.foreignApps, 1n, paramType, arg);
+                }
+                else if (publicParamType.equals(wtypes.accountWType)) {
+                    return handleForeignRef(results.foreignAccounts, 1n, paramType, arg);
+                }
             }
             let encodedType;
             if (paramType.equals(assetPType) || paramType.equals(applicationPType)) {
@@ -21918,6 +21982,12 @@ class FunctionTraverser {
             v.accept(this);
         }
     }
+    visitStageInnerTransactions(expression) {
+        expression.startNewGroup.accept(this);
+        for (const expr of expression.itxns) {
+            expr.accept(this);
+        }
+    }
     visitGroupTransactionReference(expression) {
         expression.index.accept(this);
     }
@@ -22493,7 +22563,14 @@ class ToCodeVisitor {
         return `TemplateVar[${expression.wtype}](${expression.name})`;
     }
     visitMethodConstant(expression) {
-        return `Method("${expression.value}")`;
+        if (expression.value instanceof MethodSignatureString) {
+            return `Method("${expression.value.value}")`;
+        }
+        const name = expression.value.name;
+        const args = (expression.value.argTypes || []).map((t) => t.toString()).join(',');
+        const return_ = expression.value.returnType.toString();
+        const signature = `${name}(${args})${return_}`;
+        return `Method(signature="${signature}", resource_encoding="${expression.value.resourceEncoding}")`;
     }
     visitAddressConstant(expression) {
         return `Address("${expression.value}")`;
@@ -22549,6 +22626,11 @@ class ToCodeVisitor {
             .join(', ');
         return `update_inner_transaction(${expression.itxn.accept(this)}, ${fields})`;
     }
+    visitStageInnerTransactions(expression) {
+        const startNewGroup = expression.startNewGroup.accept(this);
+        const itxns = expression.itxns.map((itxn) => itxn.accept(this)).join(', ');
+        return `stage_itxns=([${itxns}], start_new_group=${startNewGroup})`;
+    }
     visitCheckedMaybe(expression) {
         return `checked_maybe(${expression.expr.accept(this)}, comment=${expression.comment})`;
     }
@@ -29027,6 +29109,7 @@ class CompileOptions {
     outputSourceMap;
     debugLevel;
     optimizationLevel;
+    treatWarningsAsErrors;
     targetAvmVersion;
     cliTemplateDefinitions;
     templateVarsPrefix;
@@ -29053,6 +29136,7 @@ class CompileOptions {
         this.outputSourceMap = options.outputSourceMap ?? false;
         this.debugLevel = options.debugLevel ?? defaultPuyaOptions.debugLevel;
         this.optimizationLevel = options.optimizationLevel ?? defaultPuyaOptions.optimizationLevel;
+        this.treatWarningsAsErrors = options.treatWarningsAsErrors ?? defaultPuyaOptions.treatWarningsAsErrors;
         this.targetAvmVersion = options.targetAvmVersion ?? defaultPuyaOptions.targetAvmVersion;
         this.cliTemplateDefinitions = options.cliTemplateDefinitions ?? defaultPuyaOptions.cliTemplateDefinitions;
         this.templateVarsPrefix = options.templateVarsPrefix ?? defaultPuyaOptions.templateVarsPrefix;
@@ -29088,6 +29172,7 @@ const defaultPuyaOptions = {
     outputBytecode: false,
     debugLevel: 1,
     optimizationLevel: 1,
+    treatWarningsAsErrors: false,
     targetAvmVersion: 11,
     cliTemplateDefinitions: {},
     templateVarsPrefix: 'TMPL_',
@@ -29107,6 +29192,7 @@ class PuyaOptions {
     outputSourceMap;
     debugLevel;
     optimizationLevel;
+    treatWarningsAsErrors;
     targetAvmVersion;
     cliTemplateDefinitions;
     templateVarsPrefix;
@@ -29126,6 +29212,7 @@ class PuyaOptions {
         this.outputBytecode = options.outputBytecode;
         this.debugLevel = options.debugLevel;
         this.optimizationLevel = options.optimizationLevel;
+        this.treatWarningsAsErrors = options.treatWarningsAsErrors;
         this.targetAvmVersion = options.targetAvmVersion;
         this.cliTemplateDefinitions = options.cliTemplateDefinitions;
         this.templateVarsPrefix = options.templateVarsPrefix;
@@ -29137,4 +29224,4 @@ class PuyaOptions {
 }
 
 export { GeneratorType as $, ABICompatibleInstanceType as A, BaseContractClassType as B, Constants as C, BooleanFunction as D, BoxGeneric as E, BoxMapGeneric as F, BoxMapPType as G, BoxPType as H, ByteClass as I, BytesFunction as J, BytesGeneric as K, BytesPType as L, ClassMethodDecoratorContext as M, ClearStateProgram as N, ClusteredContractClassType as O, ClusteredPrototype as P, ContractClassPType as Q, ContractProxyGeneric as R, ContractProxyType as S, DynamicArrayGeneric as T, DynamicArrayType as U, DynamicBytesConstructor as V, DynamicBytesType as W, FixedArrayGeneric as X, FixedArrayPType as Y, FunctionPType as Z, GeneratorGeneric as _, ALL_OP_ENUMS as a, UintN16Class as a$, GenericPType as a0, GlobalStateGeneric as a1, GlobalStateType as a2, GroupTransactionPType as a3, ImmutableObjectPType as a4, InnerTransactionPType as a5, InstanceType as a6, InternalType as a7, IntersectionPType as a8, IntrinsicEnumType as a9, ReadonlyArrayGeneric as aA, ReadonlyArrayPType as aB, ReadonlyGeneric as aC, ReadonlyTuplePType as aD, ReferenceArrayGeneric as aE, ReferenceArrayType as aF, StaticArrayGeneric as aG, StaticArrayType as aH, StaticBytesGeneric as aI, StaticBytesType as aJ, StringFunction as aK, SuperPrototypeSelector as aL, SuperPrototypeSelectorGeneric as aM, TemplateVarFunction as aN, TransactionFunction as aO, TransactionFunctionType as aP, TransientType as aQ, TypeParameterType as aR, TypedApplicationCallResponseGeneric as aS, TypedApplicationCallResponseType as aT, UFixedNxMGeneric as aU, UFixedNxMType as aV, Uint64EnumMemberLiteralType as aW, Uint64EnumMemberType as aX, Uint64EnumType as aY, Uint64Function as aZ, UintN128Class as a_, IntrinsicFunctionGroupType as aa, IntrinsicFunctionGroupTypeType as ab, IntrinsicFunctionType as ac, IntrinsicFunctionTypeType as ad, IterableIteratorGeneric as ae, IterableIteratorType as af, ItxnParamsPType as ag, KeyRegistrationTxnFunction as ah, LibClassType as ai, LibFunctionType as aj, LibObjType as ak, LocalStateGeneric as al, LocalStateType as am, LogicSigPType as an, MutableObjectPType as ao, MutableTuplePType as ap, NamespacePType as aq, NumberPType as ar, NumericLiteralPType as as, ObjectLiteralPType as at, ObjectWithOptionalFieldsType as au, PType as av, PaymentTxnFunction as aw, PolytypeClassMethodHelper as ax, PromiseGeneric as ay, PromiseType as az, ARC4ArrayType as b, errFunction as b$, UintN256Class as b0, UintN32Class as b1, UintN64Class as b2, UintN8Class as b3, UintNGeneric as b4, UintNType as b5, UnionPType as b6, UnsupportedType as b7, abiCallFunction as b8, accountPType as b9, assetFreezeItxnFn as bA, assetFreezeItxnParamsType as bB, assetFreezeItxnType as bC, assetPType as bD, assetTransferGtxnType as bE, assetTransferItxnFn as bF, assetTransferItxnParamsType as bG, assetTransferItxnType as bH, base64PType as bI, baseContractType as bJ, bigIntPType as bK, biguintPType as bL, boolPType as bM, bytesPType as bN, bzeroFunction as bO, cloneFunctionPType as bP, compileArc4Function as bQ, compileFunctionType as bR, compiledContractType as bS, compiledLogicSigType as bT, contractOptionsDecorator as bU, convertBytesFunction as bV, decodeArc4Function as bW, ecPType as bX, ecdsaPType as bY, encodeArc4Function as bZ, ensureBudgetFunction as b_, anyGtxnType as ba, anyItxnParamsType as bb, anyItxnType as bc, anyPType as bd, applicationCallGtxnType as be, applicationCallItxnFn as bf, applicationCallItxnParamsType as bg, applicationItxnType as bh, applicationPType as bi, arc28EmitFunction as bj, arc4AbiMethodDecorator as bk, arc4AddressAlias as bl, arc4BareMethodDecorator as bm, arc4BaseContractType as bn, arc4BooleanType as bo, arc4ByteAlias as bp, arc4StringType as bq, arc4StructBaseType as br, arc4Uint64 as bs, assertFunction as bt, assertMatchFunction as bu, assetConfigGtxnType as bv, assetConfigItxnFn as bw, assetConfigItxnParamsType as bx, assetConfigItxnType as by, assetFreezeGtxnType as bz, ARC4BoolClass as c, buildAwst as c$, esSymbol as c0, inputOnlyObjects as c1, isArrayType as c2, isObjectType$1 as c3, isTupleLike as c4, itoaMethod as c5, itxnComposePType as c6, keyRegistrationGtxnType as c7, keyRegistrationItxnFn as c8, keyRegistrationItxnParamsType as c9, validateEncodingFunctionPType as cA, voidPType as cB, vrfVerifyPType as cC, uint8ArrayToBigInt as cD, uint8ArrayToBase64 as cE, uint8ArrayToBase32 as cF, uint8ArrayToHex as cG, uint8ArrayToUtf8 as cH, base64ToUint8Array as cI, base32ToUint8Array as cJ, hexToUint8Array as cK, bigIntToUint8Array as cL, utf8ToUint8Array as cM, SourceLocation as cN, registerPTypes as cO, typeRegistry as cP, TypeResolver as cQ, processInputPaths as cR, LoggingContext as cS, CompileOptions as cT, AbsolutePath as cU, mkDirIfNotExists as cV, PuyaService as cW, deserializeAndLog as cX, LogLevel as cY, logger as cZ, createTsProgram as c_, keyRegistrationItxnType as ca, logFunction as cb, logicSigBaseType as cc, logicSigOptionsDecorator as cd, matchFunction as ce, methodSelectorFunction as cf, mimcConfigurationsPType as cg, neverPType as ch, nullPType as ci, numberPType as cj, onCompleteActionType as ck, opUpFeeSourceType as cl, paymentGtxnType as cm, paymentItxnFn as cn, paymentItxnParamsType as co, paymentItxnType as cp, ptypeToArc4EncodedType as cq, readonlyDecorator as cr, sizeOfFunction as cs, stringPType as ct, submitGroupItxnFunction as cu, transactionTypeType as cv, uint64PType as cw, undefinedPType as cx, unknownPType as cy, urangeFunction as cz, ARC4EncodedType as d, validateAwst as d0, isMinLevel as d1, enumFromValue as d2, defaultPuyaOptions as d3, parseCliTemplateVar as d4, LocalsCoalescingStrategy as d5, sleep as d6, InternalError as d7, distinct as d8, DefaultMap as d9, zipStrict as da, relinquishThread as db, isIn as dc, LogSource as dd, ARC4InstanceType as e, ARC4StrClass as f, ARC4StructClass as g, ARC4StructType as h, ARC4TupleType as i, AccountFunction as j, AddressClass as k, AnyPType as l, ApplicationFunctionType as m, ApplicationTxnFunction as n, ApprovalProgram as o, Arc4TupleGeneric as p, ArrayGeneric as q, ArrayLiteralPType as r, ArrayPType as s, AssetConfigTxnFunction as t, AssetFreezeTxnFunction as u, AssetFunction as v, AssetTransferTxnFunction as w, BigIntLiteralPType as x, BigIntPType as y, BigUintFunction as z };
-//# sourceMappingURL=options-5IubucAG.js.map
+//# sourceMappingURL=options-COFRHTFQ.js.map