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

package/awst/validation/awst-traverser.d.ts

@@ -1,4 +1,4 @@
-import type { AddressConstant, AppAccountStateExpression, AppStateExpression, AppStorageDefinition, ARC4Decode, ARC4Encode, ARC4FromBytes, ARC4Router, ArrayConcat, ArrayExtend, ArrayLength, ArrayPop, ArrayReplace, AssertExpression, AssignmentExpression, AssignmentStatement, BigUIntAugmentedAssignment, BigUIntBinaryOperation, BigUIntPostfixUnaryOperation, Block, BoolConstant, BooleanBinaryOperation, BoxPrefixedKeyExpression, BoxValueExpression, BytesAugmentedAssignment, BytesBinaryOperation, BytesComparisonExpression, BytesConstant, BytesUnaryOperation, CheckedMaybe, CommaExpression, CompiledContract, CompiledLogicSig, ConditionalExpression, Contract, ContractMemberNodeVisitor, ContractMethod, ConvertArray, Copy, CreateInnerTransaction, DecimalConstant, Emit, Enumeration, ExpressionStatement, ExpressionVisitor, FieldExpression, ForInLoop, Goto, GroupTransactionReference, IfElse, IndexExpression, InnerTransactionField, IntegerConstant, IntersectionSliceExpression, IntrinsicCall, LogicSignature, LoopContinue, LoopExit, MethodConstant, NamedTupleExpression, NewArray, NewStruct, Not, NumericComparisonExpression, PuyaLibCall, Range, ReinterpretCast, ReturnStatement, Reversed, RootNodeVisitor, SetInnerTransactionFields, SingleEvaluation, SizeOf, SliceExpression, StageInnerTransactions, StateDelete, StateExists, StateGet, StateGetEx, StatementVisitor, StringConstant, SubmitInnerTransaction, Subroutine, SubroutineCallExpression, Switch, TemplateVar, TupleExpression, TupleItemExpression, UInt64AugmentedAssignment, UInt64BinaryOperation, UInt64PostfixUnaryOperation, UInt64UnaryOperation, UpdateInnerTransaction, VarExpression, VoidConstant, WhileLoop } from '../nodes';
+import type { ABICall, AddressConstant, AppAccountStateExpression, AppStateExpression, AppStorageDefinition, ARC4Decode, ARC4Encode, ARC4FromBytes, ARC4Router, ArrayConcat, ArrayExtend, ArrayLength, ArrayPop, ArrayReplace, AssertExpression, AssignmentExpression, AssignmentStatement, BigUIntAugmentedAssignment, BigUIntBinaryOperation, BigUIntPostfixUnaryOperation, Block, BoolConstant, BooleanBinaryOperation, BoxValueExpression, BytesAugmentedAssignment, BytesBinaryOperation, BytesComparisonExpression, BytesConstant, BytesUnaryOperation, CheckedMaybe, CommaExpression, CompiledContract, CompiledLogicSig, ConditionalExpression, Contract, ContractMemberNodeVisitor, ContractMethod, ConvertArray, Copy, CreateInnerTransaction, DecimalConstant, Emit, EmitFields, Enumeration, ExpressionStatement, ExpressionVisitor, FieldExpression, ForInLoop, Goto, GroupTransactionReference, IfElse, IndexExpression, InnerTransactionField, IntegerConstant, IntersectionSliceExpression, IntrinsicCall, LogicSignature, LoopContinue, LoopExit, MapPrefixedKeyExpression, MethodConstant, NamedTupleExpression, NewArray, NewStruct, Not, NumericComparisonExpression, PuyaLibCall, Range, ReinterpretCast, ReturnStatement, Reversed, RootNodeVisitor, SingleEvaluation, SizeOf, SliceExpression, StageInnerTransactions, StateDelete, StateExists, StateGet, StateGetEx, StatementVisitor, StringConstant, SubmitInnerTransaction, Subroutine, SubroutineCallExpression, Switch, TemplateVar, TupleExpression, TupleItemExpression, UInt64AugmentedAssignment, UInt64BinaryOperation, UInt64PostfixUnaryOperation, UInt64UnaryOperation, UpdateInnerTransaction, VarExpression, VoidConstant, WhileLoop } from '../nodes';
 export declare class FunctionTraverser implements ExpressionVisitor<void>, StatementVisitor<void> {
     visitExpressionStatement(statement: ExpressionStatement): void;
     visitBlock(statement: Block): void;
@@ -46,7 +46,7 @@ export declare class FunctionTraverser implements ExpressionVisitor<void>, State
     visitNamedTupleExpression(expression: NamedTupleExpression): void;
     visitVarExpression(expression: VarExpression): void;
     visitInnerTransactionField(expression: InnerTransactionField): void;
-    visitSetInnerTransactionFields(expression: SetInnerTransactionFields): void;
+    visitABICall(expression: ABICall): void;
     visitSubmitInnerTransaction(expression: SubmitInnerTransaction): void;
     visitSizeOf(expression: SizeOf): void;
     visitFieldExpression(expression: FieldExpression): void;
@@ -55,7 +55,7 @@ export declare class FunctionTraverser implements ExpressionVisitor<void>, State
     visitIntersectionSliceExpression(expression: IntersectionSliceExpression): void;
     visitAppStateExpression(expression: AppStateExpression): void;
     visitAppAccountStateExpression(expression: AppAccountStateExpression): void;
-    visitBoxPrefixedKeyExpression(expression: BoxPrefixedKeyExpression): void;
+    visitMapPrefixedKeyExpression(expression: MapPrefixedKeyExpression): void;
     visitBoxValueExpression(expression: BoxValueExpression): void;
     visitSingleEvaluation(expression: SingleEvaluation): void;
     visitReinterpretCast(expression: ReinterpretCast): void;
@@ -76,6 +76,7 @@ export declare class FunctionTraverser implements ExpressionVisitor<void>, State
     visitBooleanBinaryOperation(expression: BooleanBinaryOperation): void;
     visitNot(expression: Not): void;
     visitEmit(expression: Emit): void;
+    visitEmitFields(expression: EmitFields): void;
     visitRange(expression: Range): void;
     visitEnumeration(expression: Enumeration): void;
     visitReversed(expression: Reversed): void;

package/awst/wtypes.d.ts

@@ -1,7 +1,7 @@
 import { TransactionKind } from './models';
 import type { SourceLocation } from './source-location';
 export declare namespace wtypes {
-    class WType {
+    export class WType {
         constructor(props: {
             name: string;
             immutable?: boolean;
@@ -11,25 +11,25 @@ export declare namespace wtypes {
         equals(other: WType): boolean;
         toString(): string;
     }
-    const voidWType: WType;
-    const boolWType: WType;
-    const uint64WType: WType;
-    const uint64RangeWType: WType;
-    const stateKeyWType: WType;
-    const boxKeyWType: WType;
-    const stringWType: WType;
-    const biguintWType: WType;
-    const assetWType: WType;
-    const accountWType: WType;
-    const applicationWType: WType;
-    class BytesWType extends WType {
+    export const voidWType: WType;
+    export const boolWType: WType;
+    export const uint64WType: WType;
+    export const uint64RangeWType: WType;
+    export const stateKeyWType: WType;
+    export const boxKeyWType: WType;
+    export const stringWType: WType;
+    export const biguintWType: WType;
+    export const assetWType: WType;
+    export const accountWType: WType;
+    export const applicationWType: WType;
+    export class BytesWType extends WType {
         readonly length: bigint | null;
         constructor(args?: {
             length: bigint | null;
         });
     }
-    const bytesWType: BytesWType;
-    class ARC4Type extends WType {
+    export const bytesWType: BytesWType;
+    export class ARC4Type extends WType {
         /**
          * Override the default name of this type with a valid arc4 alias.
          *
@@ -42,7 +42,7 @@ export declare namespace wtypes {
             immutable?: boolean;
         });
     }
-    class WTuple extends WType {
+    export class WTuple extends WType {
         types: WType[];
         names: string[] | undefined;
         constructor(props: {
@@ -53,7 +53,7 @@ export declare namespace wtypes {
         equals(other: WType): boolean;
         toString(): string;
     }
-    abstract class NativeArray extends WType {
+    export abstract class NativeArray extends WType {
         readonly elementType: WType;
         readonly sourceLocation: SourceLocation | null;
         protected constructor(props: {
@@ -62,7 +62,7 @@ export declare namespace wtypes {
             sourceLocation?: SourceLocation;
         });
     }
-    class ReferenceArray extends NativeArray {
+    export class ReferenceArray extends NativeArray {
         readonly immutable = false;
         constructor(props: {
             itemType: WType;
@@ -70,38 +70,45 @@ export declare namespace wtypes {
             sourceLocation?: SourceLocation;
         });
     }
-    class WEnumeration extends WType {
+    export class WEnumeration extends WType {
         readonly sequenceType: WType;
         constructor(props: {
             sequenceType: WType;
         });
     }
-    class WGroupTransaction extends WType {
+    export class WGroupTransaction extends WType {
         transactionType: TransactionKind | null;
         constructor({ transactionType }: {
             transactionType?: TransactionKind;
         });
     }
-    class WInnerTransaction extends WType {
+    export class WInnerTransaction extends WType {
         transactionType: TransactionKind | null;
         constructor({ transactionType }: {
             transactionType?: TransactionKind;
         });
     }
-    class WInnerTransactionFields extends WType {
+    export class WInnerTransactionFields extends WType {
         transactionType: TransactionKind | null;
-        constructor({ transactionType }: {
+        constructor({ transactionType, name }: {
             transactionType?: TransactionKind;
+            name?: string;
+        });
+    }
+    export class WABICallInnerTransactionFields extends WInnerTransactionFields {
+        resultType: WType;
+        constructor({ returnType }: {
+            returnType?: WType;
         });
     }
-    class ARC4UIntN extends ARC4Type {
+    export class ARC4UIntN extends ARC4Type {
         readonly n: bigint;
         constructor({ n, arc4Alias }: {
             n: bigint;
             arc4Alias?: string;
         });
     }
-    class ARC4UFixedNxM extends ARC4Type {
+    export class ARC4UFixedNxM extends ARC4Type {
         readonly n: bigint;
         readonly m: bigint;
         constructor({ n, m }: {
@@ -109,8 +116,13 @@ export declare namespace wtypes {
             m: bigint;
         });
     }
-    class ARC4Struct extends ARC4Type {
-        fields: Record<string, WType>;
+    type WTypeField = {
+        name: string;
+        wtype: WType;
+        description: string | null;
+    };
+    export class ARC4Struct extends ARC4Type {
+        fields: WTypeField[];
         sourceLocation: SourceLocation | null;
         frozen: boolean;
         desc: string | null;
@@ -118,11 +130,11 @@ export declare namespace wtypes {
             frozen: boolean;
             name: string;
             desc: string | null;
-            fields: Record<string, WType>;
+            fields: WTypeField[];
             sourceLocation?: SourceLocation;
         });
     }
-    class ARC4Tuple extends ARC4Type {
+    export class ARC4Tuple extends ARC4Type {
         readonly types: WType[];
         readonly sourceLocation: SourceLocation | null;
         readonly immutable: boolean;
@@ -132,7 +144,7 @@ export declare namespace wtypes {
             immutable: boolean;
         });
     }
-    abstract class ARC4Array extends ARC4Type {
+    export abstract class ARC4Array extends ARC4Type {
         readonly elementType: WType;
         protected constructor(props: {
             arc4Alias: string | null;
@@ -141,7 +153,7 @@ export declare namespace wtypes {
             immutable?: boolean;
         });
     }
-    class ARC4DynamicArray extends ARC4Array {
+    export class ARC4DynamicArray extends ARC4Array {
         readonly sourceLocation: SourceLocation | null;
         constructor({ elementType, sourceLocation, arc4Alias, immutable, }: {
             elementType: WType;
@@ -150,7 +162,7 @@ export declare namespace wtypes {
             immutable?: boolean;
         });
     }
-    class ARC4StaticArray extends ARC4Array {
+    export class ARC4StaticArray extends ARC4Array {
         readonly sourceLocation: SourceLocation | null;
         readonly arraySize: bigint;
         constructor({ elementType, sourceLocation, arraySize, arc4Alias, immutable, }: {
@@ -161,8 +173,9 @@ export declare namespace wtypes {
             immutable?: boolean;
         });
     }
-    const arc4ByteAliasWType: ARC4UIntN;
-    const arc4AddressAliasWType: ARC4StaticArray;
-    const arc4BooleanWType: ARC4Type;
-    const arc4StringAliasWType: ARC4DynamicArray;
+    export const arc4ByteAliasWType: ARC4UIntN;
+    export const arc4AddressAliasWType: ARC4StaticArray;
+    export const arc4BooleanWType: ARC4Type;
+    export const arc4StringAliasWType: ARC4DynamicArray;
+    export {};
 }

package/awst_build/arc4-util.d.ts

@@ -1,17 +1,6 @@
-import type { ResourceEncoding } from '../awst';
 import { ARC4ABIMethodConfig } from '../awst/nodes';
 import type { SourceLocation } from '../awst/source-location';
-import type { ABICompatiblePType, FunctionPType, PType } from './ptypes';
-import { ArrayPType, FixedArrayPType, ImmutableObjectPType, MutableTuplePType, ReadonlyArrayPType, ReadonlyTuplePType } from './ptypes';
-import { ARC4EncodedType, ARC4StructType, ARC4TupleType, DynamicArrayType, StaticArrayType } from './ptypes/arc4-types';
-/**
- * For a given ptype, return the equivalent ABI compatible type - or error if there is no compatible type
- * @param ptype The type 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
- */
-export declare function ptypeToAbiPType(ptype: PType, direction: 'in' | 'out', resourceEncoding: ResourceEncoding, sourceLocation: SourceLocation): ABICompatiblePType;
+import type { FunctionPType } from './ptypes';
 export declare function arc4ConfigFromType(functionType: FunctionPType, sourceLocation: SourceLocation): {
     arc4Config: ARC4ABIMethodConfig;
     methodSelector: import("../awst/nodes").MethodConstant;
@@ -23,29 +12,3 @@ export declare function arc4ConfigFromType(functionType: FunctionPType, sourceLo
  * @param sourceLocation The source location of the code generating the constant,
  */
 export declare function buildArc4MethodConstant(functionType: FunctionPType, arc4Config: ARC4ABIMethodConfig, sourceLocation: SourceLocation): import("../awst/nodes").MethodConstant;
-/**
- * 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
- */
-export declare function getABITypeName(ptype: PType, direction: 'in' | 'out', resourceEncoding: ResourceEncoding, sourceLocation: SourceLocation): string;
-/**
- * Is the given type an ARC4 encoded type, or can it be encoded to one
- * @param ptype The type to check
- */
-export declare function isArc4EncodableType(ptype: PType): boolean;
-/**
- * For a given type, return the arc4 encoded version of that type
- * @param ptype The type to be encoded
- * @param sourceLocation The source location triggering the conversion
- */
-export declare function ptypeToArc4EncodedType(ptype: ReadonlyTuplePType, sourceLocation: SourceLocation): ARC4TupleType;
-export declare function ptypeToArc4EncodedType(ptype: MutableTuplePType, sourceLocation: SourceLocation): ARC4TupleType;
-export declare function ptypeToArc4EncodedType(ptype: ImmutableObjectPType, sourceLocation: SourceLocation): ARC4StructType;
-export declare function ptypeToArc4EncodedType(ptype: ArrayPType, sourceLocation: SourceLocation): DynamicArrayType;
-export declare function ptypeToArc4EncodedType(ptype: ReadonlyArrayPType, sourceLocation: SourceLocation): DynamicArrayType;
-export declare function ptypeToArc4EncodedType(ptype: FixedArrayPType, sourceLocation: SourceLocation): StaticArrayType;
-export declare function ptypeToArc4EncodedType<T extends ARC4EncodedType>(ptype: T, sourceLocation: SourceLocation): T;
-export declare function ptypeToArc4EncodedType(ptype: PType, sourceLocation: SourceLocation): ARC4EncodedType;

package/awst_build/ast-visitors/contract-method-visitor.d.ts

@@ -1,5 +1,4 @@
 import type ts from 'typescript';
-import type { ResourceEncoding } from '../../awst';
 import * as awst from '../../awst/nodes';
 import type { SourceLocation } from '../../awst/source-location';
 import type { NodeBuilder } from '../eb';
@@ -24,7 +23,6 @@ export declare class ContractMethodVisitor extends ContractMethodBaseVisitor {
      * @private
      */
     private getConventionalRoutingConfig;
-    checkABIMethodTypes(functionType: FunctionPType, resourceEncoding: ResourceEncoding, sourceLocation: SourceLocation): void;
     checkBareMethodTypes(functionType: FunctionPType, sourceLocation: SourceLocation): void;
     private buildDefaultArgument;
 }

package/awst_build/eb/arc28/arc-28-emit-function-builder.d.ts

@@ -1,11 +1,10 @@
 import type ts from 'typescript';
-import { SourceLocation } from '../../../awst/source-location';
+import type { SourceLocation } from '../../../awst/source-location';
 import type { PType } from '../../ptypes';
 import type { NodeBuilder } from '../index';
 import { FunctionBuilder } from '../index';
 export declare class Arc28EmitFunctionBuilder extends FunctionBuilder {
     readonly ptype: import("../../ptypes").LibFunctionType;
-    private encode;
     private resolvePropertyValue;
     call(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation<ts.CallExpression>): NodeBuilder;
 }

package/awst_build/eb/arc4/uintn.d.ts

@@ -15,7 +15,7 @@ export declare const classBuilderForUintNAlias: (aliasClass: LibClassType, alias
         newCall(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): InstanceBuilder;
         call(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation<import("typescript").CallExpression>): NodeBuilder;
         readonly sourceLocation: SourceLocation;
-        readonly typeDescription: string;
+        get typeDescription(): string;
         taggedTemplate(head: string, spans: ReadonlyArray<readonly [InstanceBuilder, string]>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): InstanceBuilder;
         hasProperty(_name: string): boolean;
         memberAccess(name: string, sourceLocation: SourceLocation): NodeBuilder;

package/awst_build/eb/arc4/util.d.ts

@@ -21,6 +21,7 @@ export declare class MethodSelectorFunctionBuilder extends FunctionBuilder {
     readonly ptype: import("../../ptypes").LibFunctionType;
     call(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation<ts.CallExpression>): NodeBuilder;
 }
+export declare const validateEncodingMap: Record<string, boolean>;
 export declare class SizeOfFunctionBuilder extends FunctionBuilder {
     readonly ptype: import("../../ptypes").LibFunctionType;
     call(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation<ts.CallExpression>): NodeBuilder;

package/awst_build/eb/array-like/util.d.ts

@@ -3,4 +3,3 @@ import { MutableTuplePType } from '../../ptypes';
 import type { InstanceBuilder } from '../index';
 export declare function newArray(ptype: ArrayPType | ReadonlyArrayPType, valueProvider: InstanceBuilder): import("../../../awst/nodes").NewArray;
 export declare function newTuple(ptype: MutableTuplePType | ReadonlyTuplePType | ArrayLiteralPType, valueProvider: InstanceBuilder): import("../../../awst/nodes").VoidConstant | import("../../../awst/nodes").ARC4Encode | import("../../../awst/nodes").TupleExpression;
-export declare function newArrayOrTuple(ptype: ArrayPType | ReadonlyArrayPType | MutableTuplePType | ReadonlyTuplePType | ArrayLiteralPType, valueProvider: InstanceBuilder): import("../../../awst/nodes").VoidConstant | import("../../../awst/nodes").ARC4Encode | import("../../../awst/nodes").TupleExpression | import("../../../awst/nodes").NewArray;

package/awst_build/eb/logged-error-builder.d.ts

@@ -0,0 +1,11 @@
+import type ts from 'typescript';
+import type { SourceLocation } from '../../awst/source-location';
+import type { PType } from '../ptypes';
+import type { NodeBuilder } from './index';
+import { FunctionBuilder } from './index';
+export declare class LoggedAssertFunctionBuilder extends FunctionBuilder {
+    call(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation<ts.CallExpression>): NodeBuilder;
+}
+export declare class LoggedErrFunctionBuilder extends FunctionBuilder {
+    call(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation<ts.CallExpression>): NodeBuilder;
+}

package/awst_build/eb/storage/global-map.d.ts

@@ -0,0 +1,21 @@
+import type ts from 'typescript';
+import type { Expression } from '../../../awst/nodes';
+import type { SourceLocation } from '../../../awst/source-location';
+import { AppStorageDeclaration } from '../../models/app-storage-declaration';
+import type { ContractClassPType, PType } from '../../ptypes';
+import { GlobalMapType } from '../../ptypes';
+import { FunctionBuilder, InstanceExpressionBuilder, type NodeBuilder } from '../index';
+export declare class GlobalMapFunctionBuilder extends FunctionBuilder {
+    call(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation<ts.CallExpression>): NodeBuilder;
+}
+export declare class GlobalMapExpressionBuilder extends InstanceExpressionBuilder<GlobalMapType> {
+    constructor(expr: Expression, ptype: PType);
+    call(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation<ts.CallExpression>): NodeBuilder;
+    memberAccess(name: string, sourceLocation: SourceLocation): NodeBuilder;
+}
+export declare class GlobalMapFunctionResultBuilder extends GlobalMapExpressionBuilder {
+    private readonly _keyPrefixExpr;
+    constructor(expr: Expression | undefined, ptype: PType, sourceLocation: SourceLocation);
+    resolve(): Expression;
+    buildStorageDeclaration(memberName: string, memberLocation: SourceLocation, memberDescription: string | null, contractType: ContractClassPType): AppStorageDeclaration;
+}

package/awst_build/eb/storage/local-map.d.ts

@@ -0,0 +1,21 @@
+import type ts from 'typescript';
+import type { Expression } from '../../../awst/nodes';
+import type { SourceLocation } from '../../../awst/source-location';
+import { AppStorageDeclaration } from '../../models/app-storage-declaration';
+import type { ContractClassPType, PType } from '../../ptypes';
+import { LocalMapType } from '../../ptypes';
+import { FunctionBuilder, InstanceExpressionBuilder, type NodeBuilder } from '../index';
+export declare class LocalMapFunctionBuilder extends FunctionBuilder {
+    call(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation<ts.CallExpression>): NodeBuilder;
+}
+export declare class LocalMapExpressionBuilder extends InstanceExpressionBuilder<LocalMapType> {
+    constructor(expr: Expression, ptype: PType);
+    call(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation<ts.CallExpression>): NodeBuilder;
+    memberAccess(name: string, sourceLocation: SourceLocation): NodeBuilder;
+}
+export declare class LocalMapFunctionResultBuilder extends LocalMapExpressionBuilder {
+    private readonly _keyPrefixExpr;
+    constructor(expr: Expression | undefined, ptype: PType, sourceLocation: SourceLocation);
+    resolve(): Expression;
+    buildStorageDeclaration(memberName: string, memberLocation: SourceLocation, memberDescription: string | null, contractType: ContractClassPType): AppStorageDeclaration;
+}

package/awst_build/models/decorator-data.d.ts

@@ -42,6 +42,7 @@ export type LogicSigOptionsDecoratorData = {
     avmVersion?: SupportedAvmVersion;
     name?: string;
     scratchSlots?: Set<bigint>;
+    validateEncoding?: boolean;
 };
 export type ContractOptionsDecoratorData = {
     type: typeof Constants.symbolNames.contractOptionsDecoratorName;

package/awst_build/ptypes/arc4-types.d.ts

@@ -1,5 +1,6 @@
 import type { SourceLocation } from '../../awst/source-location';
 import { wtypes } from '../../awst/wtypes';
+import type { PTypeField } from './base';
 import { GenericPType, PType } from './base';
 import { ContractClassPType, ImmutableObjectPType, LibClassType, LibFunctionType, MutableObjectPType, ReadonlyTuplePType } from './index';
 import type { PTypeVisitor } from './visitor';
@@ -59,13 +60,16 @@ export declare class ARC4StructClass extends PType {
     static fromStructType(ptype: ARC4StructType): ARC4StructClass;
     accept<T>(visitor: PTypeVisitor<T>): T;
 }
+export type ARC4StructField = PTypeField & {
+    ptype: ARC4EncodedType;
+};
 export declare class ARC4StructType extends ARC4EncodedType {
     readonly [PType.IdSymbol] = "ARC4StructType";
     readonly name: string;
     readonly module: string;
     readonly description: string | undefined;
     readonly singleton = false;
-    readonly fields: Record<string, ARC4EncodedType>;
+    readonly fields: ARC4StructField[];
     readonly sourceLocation: SourceLocation | undefined;
     readonly frozen: boolean;
     readonly abiTypeSignature: string;
@@ -74,11 +78,12 @@ export declare class ARC4StructType extends ARC4EncodedType {
         module: string;
         frozen: boolean;
         description: string | undefined;
-        fields: Record<string, ARC4EncodedType>;
+        fields: ARC4StructField[];
         sourceLocation?: SourceLocation;
     });
     get nativeType(): MutableObjectPType;
     get wtype(): wtypes.ARC4Struct;
+    getProperty(name: string): ARC4StructField | undefined;
     accept<T>(visitor: PTypeVisitor<T>): T;
 }
 export declare const arc4StructBaseType: ARC4StructType;

package/awst_build/ptypes/base.d.ts

@@ -60,4 +60,9 @@ export type PTypeOrClass = PType | {
     new (...args: DeliberateAny[]): PType;
     equals(other: PType): boolean;
 };
+export type PTypeField = {
+    name: string;
+    ptype: PType;
+    description: string | null;
+};
 export {};

package/awst_build/ptypes/for-export.d.ts

@@ -1,3 +1,2 @@
-export { ptypeToArc4EncodedType } from '../arc4-util';
 export * from './arc4-types';
 export * from './index';

package/awst_build/ptypes/index.d.ts

@@ -2,7 +2,7 @@ import { TransactionKind } from '../../awst/models';
 import { SourceLocation } from '../../awst/source-location';
 import { wtypes } from '../../awst/wtypes';
 import { SymbolName } from '../symbol-name';
-import type { ABICompatiblePType, PTypeOrClass } from './base';
+import type { ABICompatiblePType, PTypeField, PTypeOrClass } from './base';
 import { GenericPType, PType } from './base';
 import type { PTypeVisitor } from './visitor';
 export * from './base';
@@ -148,6 +148,19 @@ export declare class GlobalStateType extends StorageProxyPType {
     });
     accept<T>(visitor: PTypeVisitor<T>): T;
 }
+export declare const GlobalMapGeneric: GenericPType<GlobalMapType>;
+export declare class GlobalMapType extends StorageProxyPType {
+    readonly [PType.IdSymbol] = "GlobalMapType";
+    readonly module: string;
+    get name(): string;
+    get fullName(): string;
+    readonly keyType: PType;
+    constructor(props: {
+        content: PType;
+        keyType: PType;
+    });
+    accept<T>(visitor: PTypeVisitor<T>): T;
+}
 export declare const LocalStateGeneric: GenericPType<LocalStateType>;
 export declare class LocalStateType extends StorageProxyPType {
     readonly [PType.IdSymbol] = "LocalStateType";
@@ -162,6 +175,19 @@ export declare class LocalStateType extends StorageProxyPType {
     static parameterise(typeArgs: PType[]): LocalStateType;
     accept<T>(visitor: PTypeVisitor<T>): T;
 }
+export declare const LocalMapGeneric: GenericPType<LocalMapType>;
+export declare class LocalMapType extends StorageProxyPType {
+    readonly [PType.IdSymbol] = "LocalMapType";
+    readonly module: string;
+    get name(): string;
+    get fullName(): string;
+    readonly keyType: PType;
+    constructor(props: {
+        content: PType;
+        keyType: PType;
+    });
+    accept<T>(visitor: PTypeVisitor<T>): T;
+}
 export declare const BoxGeneric: GenericPType<BoxPType>;
 export declare class BoxPType extends StorageProxyPType {
     readonly [PType.IdSymbol] = "BoxPType";
@@ -186,7 +212,7 @@ export declare class BoxMapPType extends StorageProxyPType {
     });
     accept<T>(visitor: PTypeVisitor<T>): T;
 }
-export type AppStorageType = GlobalStateType | LocalStateType | BoxPType | BoxMapPType;
+export type AppStorageType = GlobalStateType | LocalStateType | BoxPType | BoxMapPType | GlobalMapType | LocalMapType;
 /**
  * An open generic type parameter
  */
@@ -461,24 +487,24 @@ declare abstract class ObjectPType extends PType {
     readonly module: string;
     readonly alias: SymbolName | null;
     readonly description: string | undefined;
-    readonly properties: Record<string, PType>;
+    readonly properties: PTypeField[];
     readonly singleton = false;
     readonly immutable: boolean;
     constructor(props: {
         alias?: SymbolName | null;
-        properties: Record<string, PType>;
+        properties: PTypeField[];
         description?: string;
         namePrefix: string;
         immutable: boolean;
     });
-    orderedProperties(): [string, PType][];
     toString(): string;
+    getProperty(name: string): PTypeField | undefined;
     hasSameStructure(other: ObjectPType): boolean;
 }
 export declare class ObjectLiteralPType extends ObjectPType {
     readonly [PType.IdSymbol] = "ObjectLiteralPType";
     constructor(props: {
-        properties: Record<string, PType>;
+        properties: PTypeField[];
     });
     accept<T>(visitor: PTypeVisitor<T>): T;
     getImmutable(): ImmutableObjectPType;
@@ -489,7 +515,7 @@ export declare class ImmutableObjectPType extends ObjectPType {
     readonly [PType.IdSymbol] = "ImmutableObjectPType";
     constructor(props: {
         alias?: SymbolName | null;
-        properties: Record<string, PType>;
+        properties: PTypeField[];
         description?: string;
     });
     get wtype(): wtypes.WTuple;
@@ -499,7 +525,7 @@ export declare class MutableObjectPType extends ObjectPType {
     readonly [PType.IdSymbol] = "MutableObjectPType";
     constructor(props: {
         alias?: SymbolName | null;
-        properties: Record<string, PType>;
+        properties: PTypeField[];
         description?: string;
     });
     get wtype(): wtypes.ARC4Struct;
@@ -573,6 +599,8 @@ export declare const BytesFunction: LibFunctionType;
 export declare const logFunction: LibFunctionType;
 export declare const assertFunction: LibFunctionType;
 export declare const errFunction: LibFunctionType;
+export declare const loggedAssertFunction: LibFunctionType;
+export declare const loggedErrFunction: LibFunctionType;
 export declare const assetPType: ABICompatibleInstanceType;
 export declare const AssetFunction: LibFunctionType;
 export declare const accountPType: ABICompatibleInstanceType;

package/awst_build/ptypes/util.d.ts

@@ -1,3 +1,3 @@
-import type { PType } from './base';
+import type { PType, PTypeField } from './base';
 export declare const ptypeIn: (target: PType, ...ptypes: [PType, ...PType[]]) => boolean;
-export declare function generateObjectHash(objectProperties: Record<string, PType>): string;
+export declare function generateObjectHash(objectProperties: PTypeField[]): string;

package/awst_build/ptypes/visitor.d.ts

@@ -1,5 +1,5 @@
 import type { ARC4InstanceType, ARC4StructClass, ARC4StructType, ARC4TupleType, ContractProxyType, DynamicArrayType, StaticArrayType, UFixedNxMType, UintNType } from './arc4-types';
-import type { AnyPType, ArrayLiteralPType, ArrayPType, BoxMapPType, BoxPType, BytesPType, ContractClassPType, FixedArrayPType, FunctionPType, GenericPType, GlobalStateType, GroupTransactionPType, ImmutableObjectPType, InnerTransactionPType, InstanceType, InternalType, IntrinsicEnumType, IntrinsicFunctionGroupType, IntrinsicFunctionGroupTypeType, IntrinsicFunctionType, IntrinsicFunctionTypeType, IterableIteratorType, ItxnParamsPType, LibClassType, LibFunctionType, LibObjType, LocalStateType, LogicSigPType, MutableObjectPType, MutableTuplePType, NamespacePType, ObjectLiteralPType, ReadonlyArrayPType, ReadonlyTuplePType, ReferenceArrayType, SuperPrototypeSelector, TransientType, TypeParameterType, Uint64EnumMemberType, Uint64EnumType, UnsupportedType } from './index';
+import type { AnyPType, ArrayLiteralPType, ArrayPType, BoxMapPType, BoxPType, BytesPType, ContractClassPType, FixedArrayPType, FunctionPType, GenericPType, GlobalMapType, GlobalStateType, GroupTransactionPType, ImmutableObjectPType, InnerTransactionPType, InstanceType, InternalType, IntrinsicEnumType, IntrinsicFunctionGroupType, IntrinsicFunctionGroupTypeType, IntrinsicFunctionType, IntrinsicFunctionTypeType, IterableIteratorType, ItxnParamsPType, LibClassType, LibFunctionType, LibObjType, LocalMapType, LocalStateType, LogicSigPType, MutableObjectPType, MutableTuplePType, NamespacePType, ObjectLiteralPType, ReadonlyArrayPType, ReadonlyTuplePType, ReferenceArrayType, SuperPrototypeSelector, TransientType, TypeParameterType, Uint64EnumMemberType, Uint64EnumType, UnsupportedType } from './index';
 export interface PTypeVisitor<T> {
     visitGeneric(ptype: GenericPType): T;
     visitMutableObjectPType(ptype: MutableObjectPType): T;
@@ -43,7 +43,9 @@ export interface PTypeVisitor<T> {
     visitInstanceType(ptype: InstanceType): T;
     visitContractClassPType(ptype: ContractClassPType): T;
     visitGlobalStateType(ptype: GlobalStateType): T;
+    visitGlobalMapType(ptype: GlobalMapType): T;
     visitLocalStateType(ptype: LocalStateType): T;
+    visitLocalMapType(ptype: LocalMapType): T;
     visitBoxPType(ptype: BoxPType): T;
     visitBoxMapPType(ptype: BoxMapPType): T;
     visitTypeParameterType(ptype: TypeParameterType): T;

package/awst_build/ptypes/visitors/default-visitor.d.ts

@@ -1,4 +1,4 @@
-import type { AnyPType, ArrayLiteralPType, ArrayPType, BoxMapPType, BoxPType, BytesPType, ContractClassPType, FixedArrayPType, FunctionPType, GlobalStateType, GroupTransactionPType, ImmutableObjectPType, InnerTransactionPType, InstanceType, InternalType, IntrinsicFunctionGroupType, IntrinsicFunctionGroupTypeType, IntrinsicFunctionType, IntrinsicFunctionTypeType, IterableIteratorType, ItxnParamsPType, LibClassType, LibFunctionType, LibObjType, LocalStateType, LogicSigPType, MutableObjectPType, MutableTuplePType, NamespacePType, ObjectLiteralPType, ReadonlyArrayPType, ReadonlyTuplePType, ReferenceArrayType, SuperPrototypeSelector, TransientType, TypeParameterType, Uint64EnumMemberType, Uint64EnumType, UnsupportedType } from '..';
+import type { AnyPType, ArrayLiteralPType, ArrayPType, BoxMapPType, BoxPType, BytesPType, ContractClassPType, FixedArrayPType, FunctionPType, GlobalMapType, GlobalStateType, GroupTransactionPType, ImmutableObjectPType, InnerTransactionPType, InstanceType, InternalType, IntrinsicFunctionGroupType, IntrinsicFunctionGroupTypeType, IntrinsicFunctionType, IntrinsicFunctionTypeType, IterableIteratorType, ItxnParamsPType, LibClassType, LibFunctionType, LibObjType, LocalMapType, LocalStateType, LogicSigPType, MutableObjectPType, MutableTuplePType, NamespacePType, ObjectLiteralPType, ReadonlyArrayPType, ReadonlyTuplePType, ReferenceArrayType, SuperPrototypeSelector, TransientType, TypeParameterType, Uint64EnumMemberType, Uint64EnumType, UnsupportedType } from '..';
 import type { ARC4InstanceType, ARC4StructClass, ARC4StructType, ARC4TupleType, ContractProxyType, DynamicArrayType, StaticArrayType, UFixedNxMType, UintNType } from '../arc4-types';
 import type { GenericPType, PType } from '../base';
 import type { IntrinsicEnumType } from '../intrinsic-enum-type';
@@ -49,7 +49,9 @@ export declare abstract class DefaultVisitor<T> implements PTypeVisitor<T> {
     visitInstanceType(ptype: InstanceType): T;
     visitContractClassPType(ptype: ContractClassPType): T;
     visitGlobalStateType(ptype: GlobalStateType): T;
+    visitGlobalMapType(ptype: GlobalMapType): T;
     visitLocalStateType(ptype: LocalStateType): T;
+    visitLocalMapType(ptype: LocalMapType): T;
     visitBoxPType(ptype: BoxPType): T;
     visitBoxMapPType(ptype: BoxMapPType): T;
     visitTypeParameterType(ptype: TypeParameterType): T;

package/bin/puyats-clientgen.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../clientgen';