fix enums name mistmatch, argument types and missing members

packages/algo-ts/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@algorandfoundation/algorand-typescript",
-  "version": "0.0.1-alpha.15",
+  "version": "0.0.1-alpha.16",
   "description": "This package contains definitions for the types which comprise Algorand TypeScript which can be compiled to run on the Algorand Virtual Machine using the Puya compiler.",
   "private": false,
   "main": "index.js",

packages/algo-ts/src/impl/primitives.ts

@@ -1,4 +1,5 @@
 import type { biguint, BigUintCompat, bytes, BytesCompat, uint64, Uint64Compat } from '../index'
+import { encodingUtil } from '../internal'
 import { base32ToUint8Array } from './base-32'
 import {
   base64ToUint8Array,
@@ -307,6 +308,7 @@ export class BytesCls extends AlgoTsPrimitiveCls {
   static fromCompat(v: StubBytesCompat | Uint8Array | undefined): BytesCls {
     if (v === undefined) return new BytesCls(new Uint8Array())
     if (typeof v === 'string') return new BytesCls(utf8ToUint8Array(v))
+    if (typeof v == 'bigint') return new BytesCls(encodingUtil.bigIntToUint8Array(v))
     if (v instanceof BytesCls) return v
     if (v instanceof Uint8Array) return new BytesCls(v)
     internalError(`Cannot convert ${nameOfType(v)} to bytes`)

packages/algo-ts/src/index.ts

@@ -12,3 +12,4 @@ export * from './state'
 export * as itxn from './itxn'
 export * as gtxn from './gtxn'
 export { TransactionType } from './transactions'
+export { Base64, Ec, Ecdsa, VrfVerify } from './op-types'

packages/algo-ts/src/op.ts

@@ -139,5 +139,3 @@ export const AssetHolding = createObjectProxy('AssetHolding')
 export const AssetParams = createObjectProxy('AssetParams')
 export const Block = createObjectProxy('Block')
 export const Box = createObjectProxy('Box')
-
-export { VrfVerify } from './op-types'

packages/algo-ts/src/primitives.ts

@@ -4,7 +4,7 @@ import { BigUintCls, BytesCls, getNumber, Uint64Cls } from './impl/primitives'
 export type Uint64Compat = uint64 | bigint | boolean | number
 export type BigUintCompat = bigint | bytes | number | boolean
 export type StringCompat = string
-export type BytesCompat = bytes | string
+export type BytesCompat = bigint | bytes | string
 
 /**
  * An unsigned integer of exactly 64 bits

packages/algo-ts/src/util.ts

@@ -1,7 +1,7 @@
-import { biguint, BigUintCompat, BytesCompat, StringCompat, uint64, Uint64Compat } from './primitives'
 import { ctxMgr } from './execution-context'
 import { AssertError, AvmError } from './impl/errors'
 import { toBytes } from './impl/primitives'
+import { biguint, BigUintCompat, BytesCompat, StringCompat, uint64, Uint64Compat } from './primitives'
 
 export function log(...args: Array<Uint64Compat | BytesCompat | BigUintCompat | StringCompat>): void {
   ctxMgr.instance.log(args.map(toBytes).reduce((left, right) => left.concat(right)))
@@ -14,7 +14,7 @@ export function assert(condition: unknown, message?: string): asserts condition
 }
 
 export function err(message?: string): never {
-  throw new AvmError(message ?? 'Err')
+  throw new AvmError(message ?? 'err opcode executed')
 }
 
 type NumericComparison<T> = T | { lessThan: T } | { greaterThan: T } | { greaterThanEq: T } | { lessThanEq: T } | { between: [T, T] }

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

@@ -193,6 +193,12 @@ export class BytesExpressionBuilder extends InstanceExpressionBuilder<InstanceTy
         )
       case 'bitwiseInvert':
         return new BytesInvertBuilder(this._expr)
+      case 'bitwiseAnd':
+        return new BitwiseAndExpressionBuilder(this._expr)
+      case 'bitwiseOr':
+        return new BitwiseOrExpressionBuilder(this._expr)
+      case 'bitwiseXor':
+        return new BitwiseXorExpressionBuilder(this._expr)
       case 'toString':
         return new ToStringBuilder(this._expr)
       case 'concat':
@@ -273,6 +279,63 @@ export class BytesInvertBuilder extends ParameterlessFunctionBuilder {
   }
 }
 
+export class BitwiseAndExpressionBuilder extends FunctionBuilder {
+  constructor(private expr: awst.Expression) {
+    super(expr.sourceLocation)
+  }
+
+  call(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): NodeBuilder {
+    const [other] = requireExpressionsOfType(args, [bytesPType], sourceLocation)
+    return new BytesExpressionBuilder(
+      nodeFactory.bytesBinaryOperation({
+        wtype: wtypes.bytesWType,
+        left: this.expr,
+        right: other,
+        op: BytesBinaryOperator.bitAnd,
+        sourceLocation,
+      }),
+    )
+  }
+}
+
+export class BitwiseOrExpressionBuilder extends FunctionBuilder {
+  constructor(private expr: awst.Expression) {
+    super(expr.sourceLocation)
+  }
+
+  call(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): NodeBuilder {
+    const [other] = requireExpressionsOfType(args, [bytesPType], sourceLocation)
+    return new BytesExpressionBuilder(
+      nodeFactory.bytesBinaryOperation({
+        wtype: wtypes.bytesWType,
+        left: this.expr,
+        right: other,
+        op: BytesBinaryOperator.bitOr,
+        sourceLocation,
+      }),
+    )
+  }
+}
+
+export class BitwiseXorExpressionBuilder extends FunctionBuilder {
+  constructor(private expr: awst.Expression) {
+    super(expr.sourceLocation)
+  }
+
+  call(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): NodeBuilder {
+    const [other] = requireExpressionsOfType(args, [bytesPType], sourceLocation)
+    return new BytesExpressionBuilder(
+      nodeFactory.bytesBinaryOperation({
+        wtype: wtypes.bytesWType,
+        left: this.expr,
+        right: other,
+        op: BytesBinaryOperator.bitXor,
+        sourceLocation,
+      }),
+    )
+  }
+}
+
 export class ToStringBuilder extends ParameterlessFunctionBuilder {
   constructor(private expr: awst.Expression) {
     super(

src/awst_build/eb/op-module-builder.ts

@@ -4,7 +4,7 @@ import type { SourceLocation } from '../../awst/source-location'
 import { CodeError, InternalError } from '../../errors'
 import { enumerate, invariant } from '../../util'
 import type { IntrinsicOpGrouping, IntrinsicOpMapping } from '../op-metadata'
-import { OP_METADATA } from '../op-metadata'
+import { OP_METADATA, VOID_OPS } from '../op-metadata'
 import type { PType } from '../ptypes'
 import { IntrinsicEnumType, IntrinsicFunctionGroupType, IntrinsicFunctionType, stringPType } from '../ptypes'
 import { typeRegistry } from '../type-registry'
@@ -33,7 +33,7 @@ export class IntrinsicOpGroupBuilder extends NodeBuilder {
     }
     const metaData = this.opGrouping.ops[name]
 
-    if (metaData.signatures.some((s) => s.argNames.length)) {
+    if (VOID_OPS.includes(metaData.op) || metaData.signatures.some((s) => s.argNames.length)) {
       return new GroupedIntrinsicOpBuilder(sourceLocation, metaData)
     }