Work

.github/workflows/ci-all.yml

@@ -28,3 +28,6 @@ jobs:
       audit-script: npm run audit
       upload-artifact-name: puya-ts
       upload-artifact-path: ./dist
+      python-version: 3.12.6
+      pre-test-script: |
+        pipx install puyapy --python 3.12.6

.github/workflows/node-ci.yml

@@ -5,6 +5,9 @@ on:
         required: false
         type: string
         default: 18.x
+      python-version:
+        required: false
+        type: string
       working-directory:
         required: false
         type: string
@@ -110,6 +113,12 @@ jobs:
           cache: 'npm'
           cache-dependency-path: ${{ inputs.working-directory }}/package-lock.json
 
+      - name: Set up Python
+        if: ${{ inputs.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ inputs.python-version }}
+
       - name: Download artifacts
         if: ${{ inputs.download-artifact-name || inputs.download-artifact-pattern }}
         uses: actions/download-artifact@v4

package.json

@@ -12,8 +12,7 @@
     "dev:hello": "tsx src/cli.ts build examples/hello-world/contract.algo.ts --output-awst --output-awst-json",
     "dev:hello-abi": "tsx src/cli.ts build examples/hello-world-abi ",
     "dev:calculator": "tsx src/cli.ts build examples/calculator/contract.algo.ts",
-    "dev:tealscript": "tsx src/cli.ts build examples/tealscript/example.algo.ts",
-    "dev:approvals": "tsx src/cli.ts build tests/approvals --output-awst --output-awst-json --dry-run",
+    "dev:approvals": "tsx src/cli.ts build tests/approvals --output-awst --output-awst-json --no-output-teal --no-output-arc32",
     "dev:expected-output": "tsx src/cli.ts build tests/expected-output --dry-run",
     "dev:testing": "tsx src/cli.ts build tests/approvals/byte-expressions.algo.ts --output-awst --output-awst-json --log-level=info",
     "audit": "better-npm-audit audit",

rollup.config.ts

@@ -33,6 +33,13 @@ const config: RollupOptions = {
     nodeResolve(),
     json(),
   ],
+  onwarn(log, defaultHandler) {
+    if (log.code === 'CIRCULAR_DEPENDENCY') {
+      throw new Error(log.message)
+    } else {
+      defaultHandler(log)
+    }
+  },
 }
 
 export default config

scripts/generate-op-metadata.ts

@@ -1,9 +1,8 @@
-import * as fs from 'fs'
 import { camelCase } from 'change-case'
+import * as fs from 'fs'
+import { enumerate, hasFlags } from '../src/util'
 import type { OpFunction, OpGrouping, OpOverloadedFunction } from './build-op-module'
 import { AlgoTsType, buildOpModule } from './build-op-module'
-import { enumerate, hasFlags } from '../src/util'
-import { it } from 'vitest'
 
 const opModule = buildOpModule()
 
@@ -120,7 +119,7 @@ function mapReturnType(returnTypes: AlgoTsType[]) {
   if (ptypes.length === 1) {
     return ptypes[0]
   }
-  return `new ptypes.TuplePType({items: [${ptypes.join(', ')}], immutable: true})`
+  return `new ptypes.TuplePType({items: [${ptypes.join(', ')}]})`
 }
 
 function* emitTypes() {

src/awst/json-serialize-awst.ts

@@ -1,9 +1,10 @@
 import { snakeCase } from 'change-case'
 import path from 'node:path'
 import { Constants } from '../constants'
+import { logger } from '../logger'
 import { invariant } from '../util'
 import { buildBase85Encoder } from '../util/base-85'
-import { ContractReference, LogicSigReference } from './models'
+import { ARC4ABIMethodConfig, ContractReference, LogicSigReference } from './models'
 import type { RootNode } from './nodes'
 import { SourceLocation } from './source-location'
 
@@ -73,6 +74,23 @@ export class AwstSerializer extends SnakeCaseSerializer<RootNode[]> {
         file: filePath,
       }
     }
+    if (value instanceof ARC4ABIMethodConfig) {
+      // TODO: This can be removed once puya has been updated to support a more advanced default args schema
+      return {
+        _type: value.constructor.name,
+        ...(super.serializerFunction(key, value) as object),
+        default_args: Object.fromEntries(
+          Object.entries(value.defaultArgs).flatMap(([key, v]) => {
+            if (v.source === 'constant') {
+              logger.warn(value.sourceLocation, `Ignoring constant default value for ${key} as puya does not support this yet`)
+              return []
+            } else {
+              return [[key, v.memberName]]
+            }
+          }),
+        ),
+      }
+    }
     if (value instanceof Uint8Array) {
       return this.b85.encode(value)
     }

src/awst/models.ts

@@ -124,7 +124,7 @@ export class LogicSigReference extends ModelBase {
     return this.id
   }
 }
-export type CompilationSet = ReadonlyArray<ContractReference | LogicSigReference>
+export type CompilationSet = Array<ContractReference | LogicSigReference>
 
 export enum TransactionKind {
   pay = 1,

src/awst/node-factory.ts

@@ -201,7 +201,7 @@ const explicitNodeFactory = {
   tupleExpression(props: Omit<Props<TupleExpression>, 'wtype'>) {
     return new TupleExpression({
       ...props,
-      wtype: new WTuple({ types: props.items.map((i) => i.wtype), immutable: false }),
+      wtype: new WTuple({ types: props.items.map((i) => i.wtype), immutable: true }),
     })
   },
   methodDocumentation(props?: { description?: string | null; args?: Map<string, string>; returns?: string | null }) {

src/awst_build/base-visitor.ts

@@ -514,7 +514,6 @@ export abstract class BaseVisitor implements Visitor<Expressions, NodeBuilder> {
           items: sourceType.items.map((item, index) =>
             index < targetType.items.length ? this.buildAssignmentExpressionType(targetType.items[index], item, sourceLocation) : item,
           ),
-          immutable: sourceType.immutable,
         })
       } else if (targetType instanceof ArrayPType) {
         // Narrow array literal types to array type
@@ -556,7 +555,7 @@ export abstract class BaseVisitor implements Visitor<Expressions, NodeBuilder> {
         for (const [index, sourceItemType] of enumerate(assignmentType.items)) {
           const targetItem = targetItems[index]
           if (targetItem && !(targetItem instanceof OmittedExpressionBuilder)) {
-            targets.push(targetItem.resolveToPType(sourceItemType).resolveLValue())
+            targets.push(this.buildLValue(targetItem, sourceItemType, sourceLocation))
           } else {
             targets.push(
               nodeFactory.varExpression({
@@ -575,7 +574,7 @@ export abstract class BaseVisitor implements Visitor<Expressions, NodeBuilder> {
         const targets: LValue[] = []
         for (const [propName, propType] of assignmentType.orderedProperties()) {
           if (target.hasProperty(propName)) {
-            targets.push(target.memberAccess(propName, sourceLocation).resolveLValue())
+            targets.push(this.buildLValue(target.memberAccess(propName, sourceLocation), propType, sourceLocation))
           } else {
             targets.push(
               nodeFactory.varExpression({

src/awst_build/eb/arc4/arrays.ts

@@ -142,9 +142,7 @@ class EntriesFunctionBuilder extends FunctionBuilder {
 
   call(args: ReadonlyArray<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): NodeBuilder {
     parseFunctionArgs({ args, typeArgs, callLocation: sourceLocation, argSpec: (_) => [], genericTypeArgs: 0, funcName: 'entries' })
-    const iteratorType = IterableIteratorType.parameterise([
-      new TuplePType({ items: [uint64PType, this.arrayBuilder.ptype.elementType], immutable: true }),
-    ])
+    const iteratorType = IterableIteratorType.parameterise([new TuplePType({ items: [uint64PType, this.arrayBuilder.ptype.elementType] })])
     return new IterableIteratorExpressionBuilder(
       nodeFactory.enumeration({
         expr: this.arrayBuilder.iterate(sourceLocation),

src/awst_build/eb/assert-match-function-builder.ts

@@ -46,7 +46,7 @@ export class AssertMatchFunctionBuilder extends NodeBuilder {
           )
         } else if (testProperty.hasProperty('between')) {
           const range = requireInstanceBuilder(testProperty.memberAccess('between', sourceLocation)).singleEvaluation()
-          const rangePType = new TuplePType({ items: [subjectType, subjectType], immutable: true })
+          const rangePType = new TuplePType({ items: [subjectType, subjectType] })
           codeInvariant(range.resolvableToPType(rangePType), 'Between range must be of type $')
           const zeroIndex = instanceEb(nodeFactory.uInt64Constant({ value: 0n, sourceLocation }), uint64PType)
           const gte = subjectProperty

src/awst_build/eb/biguint-expression-builder.ts

@@ -10,7 +10,7 @@ import { logger } from '../../logger'
 import { tryConvertEnum } from '../../util'
 import type { InstanceType, PType } from '../ptypes'
 import { BigUintFunction, biguintPType, boolPType, bytesPType, stringPType, uint64PType } from '../ptypes'
-import { BooleanExpressionBuilder } from './boolean-expression-builder'
+import { instanceEb } from '../type-registry'
 import type { InstanceBuilder } from './index'
 import { BuilderBinaryOp, BuilderComparisonOp, BuilderUnaryOp, FunctionBuilder, InstanceExpressionBuilder } from './index'
 import { UInt64ExpressionBuilder } from './uint64-expression-builder'
@@ -94,13 +94,14 @@ export class BigUintExpressionBuilder extends InstanceExpressionBuilder<Instance
         sourceLocation,
       })
     }
-    return new BooleanExpressionBuilder(
+    return instanceEb(
       nodeFactory.numericComparisonExpression({
         lhs: this._expr,
         rhs: otherExpr,
         operator: numComOp,
         sourceLocation,
       }),
+      boolPType,
     )
   }
   boolEval(sourceLocation: SourceLocation, negate: boolean = false): Expression {

src/awst_build/eb/index.ts

@@ -1,6 +1,7 @@
 import { awst } from '../../awst'
 import { nodeFactory } from '../../awst/node-factory'
 import type { Expression } from '../../awst/nodes'
+import { TupleItemExpression } from '../../awst/nodes'
 import type { SourceLocation } from '../../awst/source-location'
 import { CodeError, NotSupported } from '../../errors'
 import { logger } from '../../logger'
@@ -236,14 +237,17 @@ export function requireLValue(expr: awst.Expression): awst.LValue {
     awst.AppAccountStateExpression,
     awst.BoxValueExpression,
   ]
+  if (expr instanceof TupleItemExpression) {
+    throw new CodeError('Expression is not a valid assignment target - object is immutable', { sourceLocation: expr.sourceLocation })
+  }
   if (!lValueNodes.some((l) => expr instanceof l)) {
     throw new CodeError(`Expression is not a valid assignment target`, {
       sourceLocation: expr.sourceLocation,
     })
   }
   if (expr instanceof awst.IndexExpression || expr instanceof awst.FieldExpression) {
     if (expr.base.wtype.immutable) {
-      throw new CodeError(`${expr.wtype} is not a valid assignment target as it is immutable`, {
+      throw new CodeError(`Expression is not a valid assignment target - object is immutable`, {
         sourceLocation: expr.sourceLocation,
       })
     }

src/awst_build/eb/literal/big-int-literal-expression-builder.ts

@@ -14,13 +14,11 @@ import {
   TransientType,
   uint64PType,
 } from '../../ptypes'
-import { typeRegistry } from '../../type-registry'
-import { BigUintExpressionBuilder } from '../biguint-expression-builder'
+import { instanceEb, typeRegistry } from '../../type-registry'
 import { foldBinaryOp, foldComparisonOp } from '../folding'
 import type { BuilderBinaryOp, BuilderComparisonOp, InstanceBuilder } from '../index'
 import { BuilderUnaryOp } from '../index'
 import { LiteralExpressionBuilder } from '../literal-expression-builder'
-import { UInt64ExpressionBuilder } from '../uint64-expression-builder'
 import { isValidLiteralForPType } from '../util'
 
 export class BigIntLiteralExpressionBuilder extends LiteralExpressionBuilder {
@@ -64,9 +62,9 @@ export class BigIntLiteralExpressionBuilder extends LiteralExpressionBuilder {
 
     codeInvariant(isValidLiteralForPType(this.value, ptype), `${ptype.name} overflow or underflow: ${this.value}`, this.sourceLocation)
     if (ptype.equals(uint64PType)) {
-      return new UInt64ExpressionBuilder(nodeFactory.uInt64Constant({ value: this.value, sourceLocation: this.sourceLocation }))
+      return instanceEb(nodeFactory.uInt64Constant({ value: this.value, sourceLocation: this.sourceLocation }), uint64PType)
     } else if (ptype.equals(biguintPType)) {
-      return new BigUintExpressionBuilder(nodeFactory.bigUIntConstant({ value: this.value, sourceLocation: this.sourceLocation }))
+      return instanceEb(nodeFactory.bigUIntConstant({ value: this.value, sourceLocation: this.sourceLocation }), biguintPType)
     }
     throw new CodeError(`${this.value} cannot be converted to type ${ptype.name}`, { sourceLocation: this.sourceLocation })
   }

src/awst_build/eb/literal/object-expression-builder.ts

@@ -44,6 +44,9 @@ export class ObjectExpressionBuilder extends InstanceExpressionBuilder<ObjectPTy
   }
 
   resolveToPType(ptype: PTypeOrClass): InstanceBuilder {
+    if (ptype.equals(this.ptype)) {
+      return this
+    }
     if (this.resolvableToPType(ptype)) {
       const base = this.singleEvaluation()
       return instanceEb(

src/awst_build/eb/literal/object-literal-expression-builder.ts

@@ -38,7 +38,7 @@ export class ObjectLiteralExpressionBuilder extends LiteralExpressionBuilder {
 
   resolve(): Expression {
     // Resolve object to a tuple using its own inferred types
-    return this.toTuple(this.ptype, this.sourceLocation)
+    return this.toTuple(this.ptype)
   }
   resolveLValue(): LValue {
     return nodeFactory.tupleExpression({
@@ -65,7 +65,7 @@ export class ObjectLiteralExpressionBuilder extends LiteralExpressionBuilder {
     return this.parts.some((part) => (part.type === 'properties' ? Object.hasOwn(part.properties, name) : part.obj.hasProperty(name)))
   }
 
-  private toTuple(ptype: ObjectPType, sourceLocation: SourceLocation): Expression {
+  private toTuple(ptype: ObjectPType): Expression {
     return nodeFactory.tupleExpression({
       items: ptype
         .orderedProperties()
@@ -86,7 +86,7 @@ export class ObjectLiteralExpressionBuilder extends LiteralExpressionBuilder {
 
   resolveToPType(ptype: PTypeOrClass): InstanceBuilder {
     codeInvariant(ptype instanceof ObjectPType, `Object literal cannot be resolved to type ${ptype}`, this.sourceLocation)
-    return new ObjectExpressionBuilder(this.toTuple(ptype, this.sourceLocation), ptype)
+    return new ObjectExpressionBuilder(this.toTuple(ptype), ptype)
   }
 
   assign(other: InstanceBuilder, sourceLocation: SourceLocation): InstanceBuilder {

src/awst_build/eb/shared/at-function-builder.ts

@@ -8,8 +8,8 @@ import type { PType } from '../../ptypes'
 import { numberPType, uint64PType } from '../../ptypes'
 import { instanceEb } from '../../type-registry'
 import { FunctionBuilder, type InstanceBuilder } from '../index'
-import { getBigIntOrUint64Expr } from '../util'
 import { parseFunctionArgs } from '../util/arg-parsing'
+import { getBigIntOrUint64Expr } from '../util/get-bigint-or-uint64-expr'
 
 export class AtFunctionBuilder extends FunctionBuilder {
   constructor(

src/awst_build/eb/shared/slice-function-builder.ts

@@ -4,11 +4,11 @@ import type { SourceLocation } from '../../../awst/source-location'
 import type { WType } from '../../../awst/wtypes'
 import type { PType } from '../../ptypes'
 import { numberPType, uint64PType } from '../../ptypes'
-import { BytesExpressionBuilder } from '../bytes-expression-builder'
+import { instanceEb } from '../../type-registry'
 import type { NodeBuilder } from '../index'
 import { FunctionBuilder, type InstanceBuilder } from '../index'
-import { getBigIntOrUint64Expr } from '../util'
 import { parseFunctionArgs } from '../util/arg-parsing'
+import { getBigIntOrUint64Expr } from '../util/get-bigint-or-uint64-expr'
 
 export class SliceFunctionBuilder extends FunctionBuilder {
   constructor(
@@ -29,15 +29,15 @@ export class SliceFunctionBuilder extends FunctionBuilder {
       funcName: 'slice',
       argSpec: (a) => [a.optional(uint64PType, numberPType), a.optional(uint64PType, numberPType)],
     })
-
-    return new BytesExpressionBuilder(
+    return instanceEb(
       nodeFactory.intersectionSliceExpression({
         base: this.base,
         sourceLocation: sourceLocation,
         beginIndex: start ? getBigIntOrUint64Expr(start) : null,
         endIndex: stop ? getBigIntOrUint64Expr(stop) : null,
         wtype: this.resultPType.wtype,
       }),
+      this.resultPType,
     )
   }
 }

src/awst_build/eb/storage/box/box-map.ts

@@ -171,7 +171,7 @@ class BoxMapMaybeFunctionBuilder extends BoxMapFunctionBuilderBase {
       genericTypeArgs: 0,
       argSpec: (a) => [a.required(this.keyType)],
     })
-    const type = new TuplePType({ items: [this.contentType, boolPType], immutable: true })
+    const type = new TuplePType({ items: [this.contentType, boolPType] })
 
     return instanceEb(
       nodeFactory.stateGetEx({

src/awst_build/eb/storage/box/box-ref.ts

@@ -134,11 +134,11 @@ export class BoxRefResizeFunctionBuilder extends BoxRefBaseFunctionBuilder {
       nodeFactory.intrinsicCall({
         opCode: 'box_resize',
         stackArgs: [this.boxValue, size.resolve()],
-        wtype: boolWType,
+        wtype: voidWType,
         immediates: [],
         sourceLocation,
       }),
-      boolPType,
+      voidPType,
     )
   }
 }