Merge pull request #8 from algorandfoundation/feat-box

feat: implement Box op code and Box functions

Author: boblat

package-lock.json

@@ -63,7 +63,7 @@
   },
   "dependencies": {
     "@algorandfoundation/algokit-utils": "^6.2.1",
-    "@algorandfoundation/algorand-typescript": "^0.0.1-alpha.13",
+    "@algorandfoundation/algorand-typescript": "^0.0.1-alpha.15",
     "@algorandfoundation/puya-ts": "^1.0.0-alpha.14",
     "algosdk": "^2.9.0",
     "elliptic": "^6.5.7",

package.json

@@ -7,6 +7,7 @@ export const MAX_UINT64 = 2n ** 64n - 1n
 export const MAX_UINT512 = 2n ** 512n - 1n
 export const MAX_BYTES_SIZE = 4096
 export const MAX_ITEMS_IN_LOG = 32
+export const MAX_BOX_SIZE = 32768
 export const BITS_IN_BYTE = 8
 export const DEFAULT_ACCOUNT_MIN_BALANCE = 100_000
 export const DEFAULT_MAX_TXN_LIFE = 1_000

src/constants.ts

@@ -0,0 +1,62 @@
+import { biguint, BigUint, bytes, Bytes, internal, TransactionType, uint64, Uint64 } from '@algorandfoundation/algorand-typescript'
+import { OnCompleteAction } from '@algorandfoundation/algorand-typescript/arc4'
+import { AccountCls } from './impl/account'
+import { ApplicationCls } from './impl/application'
+import { AssetCls } from './impl/asset'
+
+export interface TypeInfo {
+  name: string
+  genericArgs?: TypeInfo[] | Record<string, TypeInfo>
+}
+
+type fromBytes<T> = (val: Uint8Array, typeInfo: TypeInfo) => T
+
+const booleanFromBytes: fromBytes<boolean> = (val) => {
+  return internal.encodingUtil.uint8ArrayToBigInt(val) > 0n
+}
+
+const bigUintFromBytes: fromBytes<biguint> = (val) => {
+  return BigUint(internal.encodingUtil.uint8ArrayToBigInt(val))
+}
+
+const bytesFromBytes: fromBytes<bytes> = (val) => {
+  return Bytes(val)
+}
+
+const stringFromBytes: fromBytes<string> = (val) => {
+  return Bytes(val).toString()
+}
+
+const uint64FromBytes: fromBytes<uint64> = (val) => {
+  return Uint64(internal.encodingUtil.uint8ArrayToBigInt(val))
+}
+
+const onCompletionFromBytes: fromBytes<OnCompleteAction> = (val) => {
+  return Uint64(internal.encodingUtil.uint8ArrayToBigInt(val)) as OnCompleteAction
+}
+
+const transactionTypeFromBytes: fromBytes<TransactionType> = (val) => {
+  return Uint64(internal.encodingUtil.uint8ArrayToBigInt(val)) as TransactionType
+}
+
+export const encoders = {
+  account: AccountCls.fromBytes,
+  application: ApplicationCls.fromBytes,
+  asset: AssetCls.fromBytes,
+  'bool(ean)?': booleanFromBytes,
+  biguint: bigUintFromBytes,
+  bytes: bytesFromBytes,
+  string: stringFromBytes,
+  uint64: uint64FromBytes,
+  OnCompleteAction: onCompletionFromBytes,
+  TransactionType: transactionTypeFromBytes,
+  // 'Tuple<*>': tupleFromBytes,
+}
+
+export const getEncoder = <T>(typeInfo: TypeInfo): fromBytes<T> => {
+  const encoder = Object.entries(encoders).find(([k, _]) => new RegExp(`^${k}$`, 'i').test(typeInfo.name))?.[1]
+  if (!encoder) {
+    throw new Error(`No encoder found for type ${typeInfo.name}`)
+  }
+  return encoder as fromBytes<T>
+}

src/encoders.ts

@@ -13,6 +13,7 @@ export class ApplicationData {
     appLogs: bytes[]
     globalStates: BytesMap<GlobalStateCls<unknown>>
     localStates: BytesMap<LocalState<unknown>>
+    boxes: BytesMap<Uint8Array>
   }
   isCreating: boolean = false
 
@@ -33,6 +34,7 @@ export class ApplicationData {
       appLogs: [],
       globalStates: new BytesMap(),
       localStates: new BytesMap(),
+      boxes: new BytesMap(),
     }
   }
 }

src/impl/application.ts

@@ -1,13 +1,21 @@
-import { bytes, uint64 } from '@algorandfoundation/algorand-typescript'
+import { Bytes, bytes, Uint64, uint64 } from '@algorandfoundation/algorand-typescript'
+import { encodingUtil } from '@algorandfoundation/puya-ts'
+import type { TypeInfo } from '../encoders'
 
 export abstract class BytesBackedCls {
   #value: bytes
+  // #typeInfo: GenericTypeInfo | undefined
 
   get bytes() {
     return this.#value
   }
-  constructor(value: bytes) {
+  constructor(value: bytes, _typeInfo?: TypeInfo) {
     this.#value = value
+    // this.#typeInfo = typeInfo
+  }
+
+  static fromBytes<T extends BytesBackedCls>(this: { new (v: bytes, typeInfo?: TypeInfo): T }, value: Uint8Array, typeInfo?: TypeInfo) {
+    return new this(Bytes(value), typeInfo)
   }
 }
 
@@ -21,4 +29,9 @@ export abstract class Uint64BackedCls {
   constructor(value: uint64) {
     this.#value = value
   }
+
+  static fromBytes<T extends Uint64BackedCls>(this: { new (v: uint64): T }, value: Uint8Array) {
+    const uint64Value = Uint64(encodingUtil.uint8ArrayToBigInt(value))
+    return new this(uint64Value)
+  }
 }

src/impl/base.ts

@@ -0,0 +1,127 @@
+import { bytes, internal, uint64 } from '@algorandfoundation/algorand-typescript'
+import { MAX_BOX_SIZE } from '../constants'
+import { lazyContext } from '../context-helpers/internal-context'
+import { asBytes, asBytesCls, asNumber, asUint8Array, conactUint8Arrays, toBytes } from '../util'
+
+export const Box: internal.opTypes.BoxType = {
+  create(a: internal.primitives.StubBytesCompat, b: internal.primitives.StubUint64Compat): boolean {
+    const name = asBytes(a)
+    const size = asNumber(b)
+    if (name.length === 0 || size > MAX_BOX_SIZE) {
+      throw new internal.errors.InternalError('Invalid box name or size')
+    }
+    const app = lazyContext.activeApplication
+    if (lazyContext.ledger.boxExists(app, name)) {
+      return false
+    }
+    lazyContext.ledger.setBox(app, name, new Uint8Array(size))
+    return true
+  },
+  delete(a: internal.primitives.StubBytesCompat): boolean {
+    const name = asBytes(a)
+    const app = lazyContext.activeApplication
+    if (!lazyContext.ledger.boxExists(app, name)) {
+      return false
+    }
+    lazyContext.ledger.deleteBox(app, name)
+    return true
+  },
+  extract(a: internal.primitives.StubBytesCompat, b: internal.primitives.StubUint64Compat, c: internal.primitives.StubUint64Compat): bytes {
+    const name = asBytes(a)
+    const start = asNumber(b)
+    const length = asNumber(c)
+    const app = lazyContext.activeApplication
+    if (!lazyContext.ledger.boxExists(app, name)) {
+      throw new internal.errors.InternalError('Box does not exist')
+    }
+    const boxContent = lazyContext.ledger.getBox(app, name)
+    return toBytes(boxContent.slice(start, start + length))
+  },
+  get(a: internal.primitives.StubBytesCompat): readonly [bytes, boolean] {
+    const name = asBytes(a)
+    const app = lazyContext.activeApplication
+    const boxContent = lazyContext.ledger.getBox(app, name)
+    return [toBytes(boxContent), lazyContext.ledger.boxExists(app, name)]
+  },
+  length(a: internal.primitives.StubBytesCompat): readonly [uint64, boolean] {
+    const name = asBytes(a)
+    const app = lazyContext.activeApplication
+    const boxContent = lazyContext.ledger.getBox(app, name)
+    const exists = lazyContext.ledger.boxExists(app, name)
+    return [boxContent.length, exists]
+  },
+  put(a: internal.primitives.StubBytesCompat, b: internal.primitives.StubBytesCompat): void {
+    const name = asBytes(a)
+    const app = lazyContext.activeApplication
+    const newContent = asBytesCls(b)
+    if (lazyContext.ledger.boxExists(app, name)) {
+      const boxContent = lazyContext.ledger.getBox(app, name)
+      const length = boxContent.length
+      if (asNumber(length) !== asNumber(newContent.length)) {
+        throw new internal.errors.InternalError('New content length does not match existing box length')
+      }
+    }
+    lazyContext.ledger.setBox(app, name, newContent.asUint8Array())
+  },
+  replace(a: internal.primitives.StubBytesCompat, b: internal.primitives.StubUint64Compat, c: internal.primitives.StubBytesCompat): void {
+    const name = asBytes(a)
+    const start = asNumber(b)
+    const newContent = asUint8Array(c)
+    const app = lazyContext.activeApplication
+    if (!lazyContext.ledger.boxExists(app, name)) {
+      throw new internal.errors.InternalError('Box does not exist')
+    }
+    const boxContent = lazyContext.ledger.getBox(app, name)
+    if (start + newContent.length > boxContent.length) {
+      throw new internal.errors.InternalError('Replacement content exceeds box size')
+    }
+    const updatedContent = conactUint8Arrays(boxContent.slice(0, start), newContent, boxContent.slice(start + newContent.length))
+    lazyContext.ledger.setBox(app, name, updatedContent)
+  },
+  resize(a: internal.primitives.StubBytesCompat, b: internal.primitives.StubUint64Compat): void {
+    const name = asBytes(a)
+    const newSize = asNumber(b)
+    const app = lazyContext.activeApplication
+    if (!lazyContext.ledger.boxExists(app, name)) {
+      throw new internal.errors.InternalError('Box does not exist')
+    }
+    const boxContent = lazyContext.ledger.getBox(app, name)
+    const size = boxContent.length
+    let updatedContent
+    if (newSize > size) {
+      updatedContent = conactUint8Arrays(boxContent, new Uint8Array(newSize - size))
+    } else {
+      updatedContent = boxContent.slice(0, newSize)
+    }
+    lazyContext.ledger.setBox(app, name, updatedContent)
+  },
+  splice(
+    a: internal.primitives.StubBytesCompat,
+    b: internal.primitives.StubUint64Compat,
+    c: internal.primitives.StubUint64Compat,
+    d: internal.primitives.StubBytesCompat,
+  ): void {
+    const name = asBytes(a)
+    const start = asNumber(b)
+    const length = asNumber(c)
+    const newContent = asUint8Array(d)
+    const app = lazyContext.activeApplication
+    if (!lazyContext.ledger.boxExists(app, name)) {
+      throw new internal.errors.InternalError('Box does not exist')
+    }
+    const boxContent = lazyContext.ledger.getBox(app, name)
+    const size = boxContent.length
+    if (start > size) {
+      throw new internal.errors.InternalError('Start index exceeds box size')
+    }
+    const end = Math.min(start + length, size)
+    let updatedContent = conactUint8Arrays(boxContent.slice(0, start), newContent, boxContent.slice(end))
+    //  Adjust the size if necessary
+    if (updatedContent.length > size) {
+      updatedContent = updatedContent.slice(0, size)
+    } else if (updatedContent.length < size) {
+      updatedContent = conactUint8Arrays(updatedContent, new Uint8Array(size - asNumber(updatedContent.length)))
+    }
+    lazyContext.ledger.setBox(app, name, updatedContent)
+  },
+}

src/impl/box.ts

@@ -4,6 +4,7 @@ export { AppLocal } from './app-local'
 export { AppParams } from './app-params'
 export { AssetHolding } from './asset-holding'
 export { AssetParams } from './asset-params'
+export { Box } from './box'
 export * from './crypto'
 export { Global } from './global'
 export { GTxn } from './gtxn'

src/impl/index.ts

@@ -52,7 +52,7 @@ export const bzero = (a: internal.primitives.StubUint64Compat): bytes => {
   if (size > MAX_BYTES_SIZE) {
     internal.errors.avmError('bzero attempted to create a too large string')
   }
-  return Bytes(new Uint8Array(Array(Number(size)).fill(0x00)))
+  return Bytes(new Uint8Array(Number(size)))
 }
 
 export const concat = (a: internal.primitives.StubBytesCompat, b: internal.primitives.StubBytesCompat): bytes => {