feat: add stubs for concat functions and mutable array

Author: boblat

package-lock.json

@@ -71,8 +71,8 @@
     "tslib": "^2.6.2"
   },
   "dependencies": {
-    "@algorandfoundation/algorand-typescript": "^1.0.0-beta.17",
-    "@algorandfoundation/puya-ts": "^1.0.0-beta.24",
+    "@algorandfoundation/algorand-typescript": "^1.0.0-beta.18",
+    "@algorandfoundation/puya-ts": "^1.0.0-beta.25",
     "elliptic": "^6.5.7",
     "js-sha256": "^0.11.0",
     "js-sha3": "^0.9.3",

package.json

@@ -35,7 +35,17 @@ import { lazyContext } from '../context-helpers/internal-context'
 import type { fromBytes, TypeInfo } from '../encoders'
 import { AvmError, avmInvariant, CodeError } from '../errors'
 import type { DeliberateAny } from '../typescript-helpers'
-import { asBigInt, asBigUint, asBigUintCls, asBytesCls, asUint64, asUint8Array, conactUint8Arrays, uint8ArrayToNumber } from '../util'
+import {
+  asBigInt,
+  asBigUint,
+  asBigUintCls,
+  asBytes,
+  asBytesCls,
+  asUint64,
+  asUint8Array,
+  conactUint8Arrays,
+  uint8ArrayToNumber,
+} from '../util'
 import type { StubBytesCompat } from './primitives'
 import { AlgoTsPrimitiveCls, arrayUtil, BigUintCls, Bytes, BytesCls, getUint8Array, isBytes, Uint64Cls } from './primitives'
 import { Account, AccountCls, ApplicationCls, AssetCls } from './reference'
@@ -46,7 +56,8 @@ const maxBigIntValue = (bitSize: number) => 2n ** BigInt(bitSize) - 1n
 const maxBytesLength = (bitSize: number) => Math.floor(bitSize / BITS_IN_BYTE)
 const encodeLength = (length: number) => new BytesCls(encodingUtil.bigIntToUint8Array(BigInt(length), ABI_LENGTH_SIZE))
 
-type CompatForArc4Int<N extends BitSize> = N extends 8 | 16 | 32 | 64 ? Uint64Compat : BigUintCompat
+type CompatForArc4Int<N extends BitSize> = N extends 8 | 16 | 24 | 32 | 40 | 48 | 56 | 64 ? Uint64Compat : BigUintCompat
+const validBitSizes = [...Array(64).keys()].map((x) => (x + 1) * 8)
 export class UintNImpl<N extends BitSize> extends UintN<N> {
   private value: Uint8Array
   private bitSize: N
@@ -57,7 +68,7 @@ export class UintNImpl<N extends BitSize> extends UintN<N> {
     this.typeInfo = typeof typeInfo === 'string' ? JSON.parse(typeInfo) : typeInfo
     this.bitSize = UintNImpl.getMaxBitsLength(this.typeInfo) as N
 
-    assert([8, 16, 32, 64, 128, 256, 512].includes(this.bitSize), `Invalid bit size ${this.bitSize}`)
+    assert(validBitSizes.includes(this.bitSize), `Invalid bit size ${this.bitSize}`)
 
     const bigIntValue = asBigUintCls(v ?? 0n).valueOf()
     const maxValue = maxBigIntValue(this.bitSize)
@@ -299,7 +310,7 @@ const arrayProxyHandler = <TItem>() => ({
   get(target: { items: TItem[] }, prop: PropertyKey) {
     const idx = prop ? parseInt(prop.toString(), 10) : NaN
     if (!isNaN(idx)) {
-      if (idx < target.items.length) return target.items[idx]
+      if (idx >= 0 && idx < target.items.length) return target.items[idx]
       throw new AvmError('Index out of bounds')
     } else if (prop === Symbol.iterator) {
       return target.items[Symbol.iterator].bind(target.items)
@@ -315,7 +326,7 @@ const arrayProxyHandler = <TItem>() => ({
   set(target: { items: TItem[]; setItem: (index: number, value: TItem) => void }, prop: PropertyKey, value: TItem) {
     const idx = prop ? parseInt(prop.toString(), 10) : NaN
     if (!isNaN(idx)) {
-      if (idx < target.items.length) {
+      if (idx >= 0 && idx < target.items.length) {
         target.setItem(idx, value)
         return true
       }
@@ -391,6 +402,20 @@ export class StaticArrayImpl<TItem extends ARC4Encoded, TLength extends number>
     return StaticArrayImpl.fromBytesImpl(this.bytes, JSON.stringify(this.typeInfo)) as StaticArrayImpl<TItem, TLength>
   }
 
+  concat(other: Parameters<InstanceType<typeof StaticArray>['concat']>[0]): DynamicArrayImpl<TItem> {
+    const items = this.items
+    const otherEntries = other.entries()
+    let next = otherEntries.next()
+    while (!next.done) {
+      items.push(next.value[1] as TItem)
+      next = otherEntries.next()
+    }
+    return new DynamicArrayImpl<TItem>(
+      { name: `DynamicArray<${this.genericArgs.elementType.name}>`, genericArgs: { elementType: this.genericArgs.elementType } },
+      ...items,
+    )
+  }
+
   get native(): TItem[] {
     return this.items
   }
@@ -578,6 +603,17 @@ export class DynamicArrayImpl<TItem extends ARC4Encoded> extends DynamicArray<TI
     return popped
   }
 
+  concat(other: Parameters<InstanceType<typeof DynamicArray>['concat']>[0]): DynamicArrayImpl<TItem> {
+    const items = this.items
+    const otherEntries = other.entries()
+    let next = otherEntries.next()
+    while (!next.done) {
+      items.push(next.value[1] as TItem)
+      next = otherEntries.next()
+    }
+    return new DynamicArrayImpl<TItem>(this.typeInfo, ...items)
+  }
+
   static fromBytesImpl(
     value: StubBytesCompat | Uint8Array,
     typeInfo: string | TypeInfo,
@@ -822,6 +858,20 @@ export class DynamicBytesImpl extends DynamicBytes {
     throw new CodeError('DynamicBytes is immutable')
   }
 
+  concat(other: Parameters<InstanceType<typeof DynamicBytes>['concat']>[0]): DynamicBytesImpl {
+    const items = this.items
+    const otherEntries = other.entries()
+    let next = otherEntries.next()
+    while (!next.done) {
+      items.push(next.value[1] as ByteImpl)
+      next = otherEntries.next()
+    }
+    const concatenatedBytes = items
+      .map((item) => item.bytes)
+      .reduce((acc, curr) => conactUint8Arrays(acc, asUint8Array(curr)), new Uint8Array())
+    return new DynamicBytesImpl(this.typeInfo, asBytes(concatenatedBytes))
+  }
+
   static fromBytesImpl(
     value: StubBytesCompat | Uint8Array,
     typeInfo: string | TypeInfo,
@@ -877,6 +927,20 @@ export class StaticBytesImpl extends StaticBytes {
     throw new CodeError('StaticBytes is immutable')
   }
 
+  concat(other: Parameters<InstanceType<typeof StaticBytes>['concat']>[0]): DynamicBytesImpl {
+    const items = this.items
+    const otherEntries = other.entries()
+    let next = otherEntries.next()
+    while (!next.done) {
+      items.push(next.value[1] as ByteImpl)
+      next = otherEntries.next()
+    }
+    const concatenatedBytes = items
+      .map((item) => item.bytes)
+      .reduce((acc, curr) => conactUint8Arrays(acc, asUint8Array(curr)), new Uint8Array())
+    return new DynamicBytesImpl(this.typeInfo, asBytes(concatenatedBytes))
+  }
+
   static fromBytesImpl(value: StubBytesCompat | Uint8Array, typeInfo: string | TypeInfo, prefix: 'none' | 'log' = 'none'): StaticBytesImpl {
     const staticArrayValue = StaticArrayImpl.fromBytesImpl(value, typeInfo, prefix) as StaticArrayImpl<ByteImpl, number>
     const result = new StaticBytesImpl(typeInfo)

src/impl/encoded-types.ts

@@ -16,3 +16,4 @@ export * from './pure'
 export { gloadBytes, gloadUint64, Scratch } from './scratch'
 export { gaid, Txn } from './txn'
 export { VoterParams } from './voter-params'
+export { MutableArray } from './mutable-array'

src/impl/index.ts

@@ -0,0 +1,122 @@
+import type { uint64, Uint64Compat } from '@algorandfoundation/algorand-typescript'
+import { AvmError } from '../errors'
+import { asNumber } from '../util'
+
+export class MutableArray<TItem> {
+  private _values: TItem[]
+
+  constructor(...items: TItem[]) {
+    this._values = items
+
+    return new Proxy(this, {
+      get(target, prop: PropertyKey) {
+        const idx = prop ? parseInt(prop.toString(), 10) : NaN
+        if (!isNaN(idx)) {
+          if (idx >= 0 && idx < target._values.length) return target._values[idx]
+          throw new AvmError('Index out of bounds')
+        }
+        return Reflect.get(target, prop)
+      },
+      set(target, prop: PropertyKey, value: TItem) {
+        const idx = prop ? parseInt(prop.toString(), 10) : NaN
+        if (!isNaN(idx)) {
+          if (idx >= 0 && idx < target._values.length) {
+            target._values[idx] = value
+            return true
+          }
+          throw new AvmError('Index out of bounds')
+        }
+
+        return Reflect.set(target, prop, value)
+      },
+    })
+  }
+
+  /**
+   * Returns the current length of this array
+   */
+  get length(): uint64 {
+    return this._values.length
+  }
+
+  /**
+   * Returns the item at the given index.
+   * Negative indexes are taken from the end.
+   * @param index The index of the item to retrieve
+   */
+  at(index: Uint64Compat): TItem {
+    return this._values[asNumber(index)]
+  }
+
+  /**
+   * Create a new Dynamic array with all items from this array
+   * @internal Not supported yet
+   */
+  slice(): MutableArray<TItem>
+  /**
+   * Create a new MutableArray with all items up till `end`.
+   * Negative indexes are taken from the end.
+   * @param end An index in which to stop copying items.
+   * @internal Not supported yet
+   */
+  slice(end: Uint64Compat): MutableArray<TItem>
+  /**
+   * Create a new MutableArray with items from `start`, up until `end`
+   * Negative indexes are taken from the end.
+   * @param start An index in which to start copying items.
+   * @param end An index in which to stop copying items
+   * @internal Not supported yet
+   */
+  slice(start: Uint64Compat, end: Uint64Compat): MutableArray<TItem>
+  slice(start?: Uint64Compat, end?: Uint64Compat): MutableArray<TItem> {
+    const startIndex = end === undefined ? 0 : asNumber(start ?? 0)
+    const endIndex = end === undefined ? asNumber(start ?? this._values.length) : asNumber(end)
+    return new MutableArray<TItem>(...this._values.slice(startIndex, endIndex))
+  }
+
+  /**
+   * Returns an iterator for the items in this array
+   */
+  [Symbol.iterator](): IterableIterator<TItem> {
+    return this._values[Symbol.iterator]()
+  }
+
+  /**
+   * Returns an iterator for a tuple of the indexes and items in this array
+   */
+  entries(): IterableIterator<readonly [uint64, TItem]> {
+    return this._values.entries()
+  }
+
+  /**
+   * Returns an iterator for the indexes in this array
+   */
+  keys(): IterableIterator<uint64> {
+    return this._values.keys()
+  }
+
+  /**
+   * Get or set the item at the specified index.
+   * Negative indexes are not supported
+   */
+  [index: uint64]: TItem
+
+  /**
+   * Push a number of items into this array
+   * @param items The items to be added to this array
+   */
+  push(...items: TItem[]): void {
+    this._values.push(...items)
+  }
+
+  /**
+   * Pop a single item from this array
+   */
+  pop(): TItem {
+    return this._values.pop()!
+  }
+
+  copy(): MutableArray<TItem> {
+    return new MutableArray(...this._values)
+  }
+}

src/impl/mutable-array.ts

@@ -317,6 +317,9 @@ export class Uint64Cls extends AlgoTsPrimitiveCls {
     }
     return Number(this.#value)
   }
+  toString(): string {
+    return this.#value.toString()
+  }
 }
 
 export function BigUintImpl(v?: BigUintCompat | string): biguint {

src/impl/primitives.ts

@@ -6,6 +6,7 @@ export { ensureBudgetImpl as ensureBudget } from '../impl/ensure-budget'
 export { Global } from '../impl/global'
 export { log } from '../impl/log'
 export { assertMatchImpl as assertMatch, matchImpl as match } from '../impl/match'
+export { MutableArray } from '../impl/mutable-array'
 export { BigUint, Bytes, Uint64 } from '../impl/primitives'
 export { Account, Application, Asset } from '../impl/reference'
 export { Box, BoxMap, BoxRef, GlobalState, LocalState } from '../impl/state'