refactor: use encoding utils from puya-ts instead of redefining them

Author: boblat

src/encoders.ts

@@ -1,7 +1,7 @@
 import type { biguint, bytes, TransactionType, uint64 } from '@algorandfoundation/algorand-typescript'
 import type { OnCompleteAction } from '@algorandfoundation/algorand-typescript/arc4'
 import { ARC4Encoded } from '@algorandfoundation/algorand-typescript/arc4'
-import { uint8ArrayToBigInt } from './encoding-util'
+import { encodingUtil } from '@algorandfoundation/puya-ts'
 import { InternalError } from './errors'
 import { BytesBackedCls, Uint64BackedCls } from './impl/base'
 import { arc4Encoders, encodeArc4Impl, getArc4Encoder } from './impl/encoded-types'
@@ -18,11 +18,11 @@ export type TypeInfo = {
 export type fromBytes<T> = (val: Uint8Array | StubBytesCompat, typeInfo: TypeInfo, prefix?: 'none' | 'log') => T
 
 const booleanFromBytes: fromBytes<boolean> = (val) => {
-  return uint8ArrayToBigInt(asUint8Array(val)) > 0n
+  return encodingUtil.uint8ArrayToBigInt(asUint8Array(val)) > 0n
 }
 
 const bigUintFromBytes: fromBytes<biguint> = (val) => {
-  return BigUint(uint8ArrayToBigInt(asUint8Array(val)))
+  return BigUint(encodingUtil.uint8ArrayToBigInt(asUint8Array(val)))
 }
 
 const bytesFromBytes: fromBytes<bytes> = (val) => {
@@ -34,15 +34,15 @@ const stringFromBytes: fromBytes<string> = (val) => {
 }
 
 const uint64FromBytes: fromBytes<uint64> = (val) => {
-  return Uint64(uint8ArrayToBigInt(asUint8Array(val)))
+  return Uint64(encodingUtil.uint8ArrayToBigInt(asUint8Array(val)))
 }
 
 const onCompletionFromBytes: fromBytes<OnCompleteAction> = (val) => {
-  return Uint64(uint8ArrayToBigInt(asUint8Array(val))) as OnCompleteAction
+  return Uint64(encodingUtil.uint8ArrayToBigInt(asUint8Array(val))) as OnCompleteAction
 }
 
 const transactionTypeFromBytes: fromBytes<TransactionType> = (val) => {
-  return Uint64(uint8ArrayToBigInt(asUint8Array(val))) as TransactionType
+  return Uint64(encodingUtil.uint8ArrayToBigInt(asUint8Array(val))) as TransactionType
 }
 
 export const encoders: Record<string, fromBytes<DeliberateAny>> = {

src/encoding-util.ts

@@ -1,6 +1,6 @@
 import type { arc4, bytes } from '@algorandfoundation/algorand-typescript'
+import { encodingUtil } from '@algorandfoundation/puya-ts'
 import { captureMethodConfig } from '../abi-metadata'
-import { utf8ToUint8Array } from '../encoding-util'
 import type { DeliberateAny } from '../typescript-helpers'
 import { BaseContract } from './base-contract'
 import { sha512_256 } from './crypto'
@@ -39,5 +39,5 @@ export function baremethod<TContract extends Contract>(config?: arc4.BareMethodC
 }
 
 export const methodSelector: typeof arc4.methodSelector = (methodSignature: string): bytes => {
-  return sha512_256(Bytes(utf8ToUint8Array(methodSignature))).slice(0, 4)
+  return sha512_256(Bytes(encodingUtil.utf8ToUint8Array(methodSignature))).slice(0, 4)
 }

src/impl/contract.ts

@@ -33,10 +33,9 @@ import {
 } from '../constants'
 import { lazyContext } from '../context-helpers/internal-context'
 import type { fromBytes, TypeInfo } from '../encoders'
-import { uint8ArrayToNumber } from '../encoding-util'
 import { AvmError, avmInvariant, CodeError } from '../errors'
 import type { DeliberateAny } from '../typescript-helpers'
-import { asBigInt, asBigUint, asBigUintCls, asBytesCls, asUint64, asUint8Array, conactUint8Arrays } from '../util'
+import { asBigInt, asBigUint, asBigUintCls, 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'

src/impl/encoded-types.ts

@@ -1,4 +1,5 @@
 import type { Account as AccountType, Application as ApplicationType, bytes, op, uint64 } from '@algorandfoundation/algorand-typescript'
+import { encodingUtil } from '@algorandfoundation/puya-ts'
 import {
   DEFAULT_ACCOUNT_MIN_BALANCE,
   DEFAULT_ASSET_CREATE_MIN_BALANCE,
@@ -9,7 +10,6 @@ import {
   ZERO_ADDRESS,
 } from '../constants'
 import { lazyContext } from '../context-helpers/internal-context'
-import { bigIntToUint8Array } from '../encoding-util'
 import { InternalError } from '../errors'
 import { getObjectReference } from '../util'
 import { sha256 } from './crypto'
@@ -150,7 +150,7 @@ export const Global: typeof op.Global = {
     const data = getGlobalData()
     if (data.groupId !== undefined) return data.groupId
     const reference = getObjectReference(lazyContext.activeGroup)
-    const referenceBytes = Bytes(bigIntToUint8Array(reference))
+    const referenceBytes = Bytes(encodingUtil.bigIntToUint8Array(reference))
     return sha256(referenceBytes)
   },
 

src/impl/global.ts

@@ -1,13 +1,5 @@
 import type { biguint, BigUintCompat, bytes, BytesCompat, uint64, Uint64Compat } from '@algorandfoundation/algorand-typescript'
-import {
-  base64ToUint8Array,
-  bigIntToUint8Array,
-  hexToUint8Array,
-  uint8ArrayToBigInt,
-  uint8ArrayToHex,
-  uint8ArrayToUtf8,
-  utf8ToUint8Array,
-} from '../encoding-util'
+import { encodingUtil } from '@algorandfoundation/puya-ts'
 import { avmError, AvmError, avmInvariant, CodeError, InternalError } from '../errors'
 import { nameOfType } from '../typescript-helpers'
 import { base32ToUint8Array } from './base-32'
@@ -309,7 +301,7 @@ export class Uint64Cls extends AlgoTsPrimitiveCls {
   }
 
   toBytes(): BytesCls {
-    return new BytesCls(bigIntToUint8Array(this.#value, 8))
+    return new BytesCls(encodingUtil.bigIntToUint8Array(this.#value, 8))
   }
 
   asAlgoTs(): uint64 {
@@ -348,7 +340,7 @@ export class BigUintCls extends AlgoTsPrimitiveCls {
   }
 
   toBytes(): BytesCls {
-    return new BytesCls(bigIntToUint8Array(this.#value))
+    return new BytesCls(encodingUtil.bigIntToUint8Array(this.#value))
   }
 
   asAlgoTs(): biguint {
@@ -435,7 +427,7 @@ export class BytesCls extends AlgoTsPrimitiveCls {
     checkBytes(this.#v)
     // Add an enumerable property for debugging code to show
     Object.defineProperty(this, 'bytes', {
-      value: uint8ArrayToHex(this.#v),
+      value: encodingUtil.uint8ArrayToHex(this.#v),
       writable: false,
       enumerable: true,
     })
@@ -507,7 +499,7 @@ export class BytesCls extends AlgoTsPrimitiveCls {
   }
 
   valueOf(): string {
-    return uint8ArrayToHex(this.#v)
+    return encodingUtil.uint8ArrayToHex(this.#v)
   }
 
   static [Symbol.hasInstance](x: unknown): x is BytesCls {
@@ -516,7 +508,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 === 'string') return new BytesCls(encodingUtil.utf8ToUint8Array(v))
     if (v instanceof BytesCls) return v
     if (v instanceof Uint8Array) return new BytesCls(v)
     throw new InternalError(`Cannot convert ${nameOfType(v)} to bytes`)
@@ -535,27 +527,27 @@ export class BytesCls extends AlgoTsPrimitiveCls {
   }
 
   static fromHex(hex: string): BytesCls {
-    return new BytesCls(hexToUint8Array(hex))
+    return new BytesCls(encodingUtil.hexToUint8Array(hex))
   }
 
   static fromBase64(b64: string): BytesCls {
-    return new BytesCls(base64ToUint8Array(b64))
+    return new BytesCls(encodingUtil.base64ToUint8Array(b64))
   }
 
   static fromBase32(b32: string): BytesCls {
     return new BytesCls(base32ToUint8Array(b32))
   }
 
   toUint64(): Uint64Cls {
-    return new Uint64Cls(uint8ArrayToBigInt(this.#v))
+    return new Uint64Cls(encodingUtil.uint8ArrayToBigInt(this.#v))
   }
 
   toBigUint(): BigUintCls {
-    return new BigUintCls(uint8ArrayToBigInt(this.#v))
+    return new BigUintCls(encodingUtil.uint8ArrayToBigInt(this.#v))
   }
 
   toString(): string {
-    return uint8ArrayToUtf8(this.#v)
+    return encodingUtil.uint8ArrayToUtf8(this.#v)
   }
 
   asAlgoTs(): bytes {

src/impl/primitives.ts

@@ -1,7 +1,7 @@
 import { ARC4Encoded } from '@algorandfoundation/algorand-typescript/arc4'
+import { encodingUtil } from '@algorandfoundation/puya-ts'
 import { MAX_UINT64 } from './constants'
 import type { TypeInfo } from './encoders'
-import { uint8ArrayToBigInt } from './encoding-util'
 import { AvmError, CodeError, InternalError } from './errors'
 import { Uint64BackedCls } from './impl/base'
 import { AlgoTsPrimitiveCls, BigUintCls, BytesCls, checkBigUint, checkBytes, Uint64Cls } from './impl/primitives'
@@ -229,8 +229,8 @@ function bigUintBinaryOp(left: DeliberateAny, right: DeliberateAny, op: BinaryOp
 function bytesBinaryOp(left: DeliberateAny, right: DeliberateAny, op: BinaryOps): DeliberateAny {
   const lbb = checkBytes(BytesCls.fromCompat(left).asUint8Array())
   const rbb = checkBytes(BytesCls.fromCompat(right).asUint8Array())
-  const lbi = uint8ArrayToBigInt(lbb)
-  const rbi = uint8ArrayToBigInt(rbb)
+  const lbi = encodingUtil.uint8ArrayToBigInt(lbb)
+  const rbi = encodingUtil.uint8ArrayToBigInt(rbb)
 
   const result = (function () {
     switch (op) {

src/runtime-helpers.ts

@@ -155,6 +155,10 @@ export const conactUint8Arrays = (...values: Uint8Array[]): Uint8Array => {
   return result
 }
 
+export const uint8ArrayToNumber = (value: Uint8Array): number => {
+  return value.reduce((acc, x) => acc * 256 + x, 0)
+}
+
 /**
  * Runtime assertion function that throws if condition is falsy.
  *