Merge pull request #12 from algorandfoundation/feat-arc4-dynamic-types

feat: arc4 types

.nsprc

@@ -1,2 +1 @@
-{
-}
+{}

src/constants.ts

@@ -6,6 +6,7 @@ export const MAX_UINT8 = 2 ** 8 - 1
 export const MAX_UINT64 = 2n ** 64n - 1n
 export const MAX_UINT512 = 2n ** 512n - 1n
 export const MAX_BYTES_SIZE = 4096
+export const MAX_LOG_SIZE = 1024
 export const MAX_ITEMS_IN_LOG = 32
 export const MAX_BOX_SIZE = 32768
 export const BITS_IN_BYTE = 8

src/encoders.ts

@@ -1,62 +1,61 @@
-import { biguint, BigUint, bytes, Bytes, internal, TransactionType, uint64, Uint64 } from '@algorandfoundation/algorand-typescript'
+import { biguint, BigUint, 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'
+import { arc4Encoders, getArc4Encoder } from './impl/encoded-types'
+import { DeliberateAny } from './typescript-helpers'
+import { asBytes, asUint8Array } from './util'
 
-export interface TypeInfo {
+export type TypeInfo = {
   name: string
   genericArgs?: TypeInfo[] | Record<string, TypeInfo>
 }
 
-type fromBytes<T> = (val: Uint8Array, typeInfo: TypeInfo) => T
+export type fromBytes<T> = (val: Uint8Array | internal.primitives.StubBytesCompat, typeInfo: TypeInfo, prefix?: 'none' | 'log') => T
 
 const booleanFromBytes: fromBytes<boolean> = (val) => {
-  return internal.encodingUtil.uint8ArrayToBigInt(val) > 0n
+  return internal.encodingUtil.uint8ArrayToBigInt(asUint8Array(val)) > 0n
 }
 
 const bigUintFromBytes: fromBytes<biguint> = (val) => {
-  return BigUint(internal.encodingUtil.uint8ArrayToBigInt(val))
+  return BigUint(internal.encodingUtil.uint8ArrayToBigInt(asUint8Array(val)))
 }
 
 const bytesFromBytes: fromBytes<bytes> = (val) => {
-  return Bytes(val)
+  return asBytes(val)
 }
 
 const stringFromBytes: fromBytes<string> = (val) => {
-  return Bytes(val).toString()
+  return asBytes(val).toString()
 }
 
 const uint64FromBytes: fromBytes<uint64> = (val) => {
-  return Uint64(internal.encodingUtil.uint8ArrayToBigInt(val))
+  return Uint64(internal.encodingUtil.uint8ArrayToBigInt(asUint8Array(val)))
 }
 
 const onCompletionFromBytes: fromBytes<OnCompleteAction> = (val) => {
-  return Uint64(internal.encodingUtil.uint8ArrayToBigInt(val)) as OnCompleteAction
+  return Uint64(internal.encodingUtil.uint8ArrayToBigInt(asUint8Array(val))) as OnCompleteAction
 }
 
 const transactionTypeFromBytes: fromBytes<TransactionType> = (val) => {
-  return Uint64(internal.encodingUtil.uint8ArrayToBigInt(val)) as TransactionType
+  return Uint64(internal.encodingUtil.uint8ArrayToBigInt(asUint8Array(val))) as TransactionType
 }
 
-export const encoders = {
+export const encoders: Record<string, fromBytes<DeliberateAny>> = {
   account: AccountCls.fromBytes,
   application: ApplicationCls.fromBytes,
   asset: AssetCls.fromBytes,
-  'bool(ean)?': booleanFromBytes,
+  boolean: booleanFromBytes,
   biguint: bigUintFromBytes,
   bytes: bytesFromBytes,
   string: stringFromBytes,
   uint64: uint64FromBytes,
   OnCompleteAction: onCompletionFromBytes,
   TransactionType: transactionTypeFromBytes,
-  // 'Tuple<*>': tupleFromBytes,
+  ...arc4Encoders,
 }
 
 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>
+  return getArc4Encoder<T>(typeInfo, encoders)
 }

src/impl/base.ts

@@ -1,4 +1,4 @@
-import { Bytes, bytes, Uint64, uint64 } from '@algorandfoundation/algorand-typescript'
+import { bytes, internal, Uint64, uint64 } from '@algorandfoundation/algorand-typescript'
 import { encodingUtil } from '@algorandfoundation/puya-ts'
 import type { TypeInfo } from '../encoders'
 
@@ -14,8 +14,12 @@ export abstract class BytesBackedCls {
     // 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)
+  static fromBytes<T extends BytesBackedCls>(
+    this: { new (v: bytes, typeInfo?: TypeInfo): T },
+    value: internal.primitives.StubBytesCompat | Uint8Array,
+    typeInfo?: TypeInfo,
+  ) {
+    return new this(internal.primitives.BytesCls.fromCompat(value).asAlgoTs(), typeInfo)
   }
 }
 
@@ -30,8 +34,9 @@ export abstract class Uint64BackedCls {
     this.#value = value
   }
 
-  static fromBytes<T extends Uint64BackedCls>(this: { new (v: uint64): T }, value: Uint8Array) {
-    const uint64Value = Uint64(encodingUtil.uint8ArrayToBigInt(value))
+  static fromBytes<T extends Uint64BackedCls>(this: { new (v: uint64): T }, value: internal.primitives.StubBytesCompat | Uint8Array) {
+    const uint8ArrayValue = value instanceof Uint8Array ? value : internal.primitives.BytesCls.fromCompat(value).asUint8Array()
+    const uint64Value = Uint64(encodingUtil.uint8ArrayToBigInt(uint8ArrayValue))
     return new this(uint64Value)
   }
 }