Merge pull request #512 from algorandfoundation/generator-ts-integration

Generator ts integration

Author: PatrickDinh

packages/abi/src/abi-type.ts

@@ -9,6 +9,7 @@ import {
 import type { ABIStructValue, ABIValue } from './abi-value'
 import { StructField } from './arc56-contract'
 import { bigIntToBytes, bytesToBigInt } from './bigint'
+import { getStructValueFromTupleValue, getTupleValueFromStructValue } from './utils'
 
 const STATIC_ARRAY_REGEX = /^([a-z\d[\](),]+)\[(0|[1-9][\d]*)]$/
 const UFIXED_REGEX = /^ufixed([1-9][\d]*)x([1-9][\d]*)$/
@@ -841,56 +842,14 @@ export class ABIStructType extends ABIType {
       return tupleType.encode(value)
     }
 
-    const tupleValue = this.getTupleValueFromStructValue(value)
+    const tupleValue = getTupleValueFromStructValue(this, value)
     return tupleType.encode(tupleValue)
   }
 
   decode(bytes: Uint8Array): ABIStructValue {
     const tupleType = this.toABITupleType()
     const tupleValue = tupleType.decode(bytes)
-    return this.getStructValueFromTupleValue(tupleValue)
-  }
-
-  private getTupleValueFromStructValue(structValue: ABIStructValue): ABIValue[] {
-    const getTupleValueFromStructFields = (structFields: ABIStructField[], values: ABIValue[]): ABIValue[] => {
-      return structFields.map(({ type }, index) => {
-        // if type is an array of fields, treat as unnamed struct
-        if (Array.isArray(type)) {
-          const value = values[index] as ABIStructValue
-          return getTupleValueFromStructFields(type, Object.values(value))
-        }
-        // if type is struct, treat as struct
-        if (type instanceof ABIStructType) {
-          const value = values[index] as ABIStructValue
-          return getTupleValueFromStructFields(type.structFields, Object.values(value))
-        }
-        return values[index]
-      })
-    }
-
-    return getTupleValueFromStructFields(this.structFields, Object.values(structValue))
-  }
-
-  private getStructValueFromTupleValue(tupleValue: ABIValue[]): ABIStructValue {
-    const getStructFieldValues = (structFields: ABIStructField[], values: ABIValue[]): ABIStructValue => {
-      return Object.fromEntries(
-        structFields.map(({ name, type }, index) => {
-          // When the type is an array of fields, the value must be tuple
-          if (Array.isArray(type)) {
-            const value = values[index] as ABIValue[]
-            return [name, getStructFieldValues(type, value)]
-          }
-          // When the type is a struct, the value must be tuple
-          if (type instanceof ABIStructType) {
-            const value = values[index] as ABIValue[]
-            return [name, getStructFieldValues(type.structFields, value)]
-          }
-          return [name, values[index]]
-        }),
-      )
-    }
-
-    return getStructFieldValues(this.structFields, tupleValue)
+    return getStructValueFromTupleValue(this, tupleValue)
   }
 }
 

packages/abi/src/index.ts

@@ -1,5 +1,7 @@
 export {
   ABIMethod,
+  ABIReferenceType,
+  ABITransactionType,
   arc56MethodToABIMethod,
   argTypeIsAbiType,
   argTypeIsReference,
@@ -19,7 +21,6 @@ export type {
   ABIReturn,
   DefaultValueSource,
 } from './abi-method'
-export { ABIReferenceType, ABITransactionType } from './abi-method'
 export {
   ABIAddressType,
   ABIArrayDynamicType,
@@ -67,3 +68,4 @@ export type {
   StructField,
   StructName,
 } from './arc56-contract'
+export { getStructValueFromTupleValue, getTupleValueFromStructValue } from './utils'

packages/abi/src/utils.ts

@@ -0,0 +1,63 @@
+import type { ABIStructField, ABIStructType, ABIType } from './abi-type'
+import type { ABIStructValue, ABIValue } from './abi-value'
+
+/**
+ * Checks if a type is an ABIStructType by checking for the structFields property.
+ */
+function isABIStructType(type: ABIType | ABIStructField[]): type is ABIStructType {
+  return !Array.isArray(type) && 'structFields' in type
+}
+
+/**
+ * Converts a struct value (object with named fields) to a tuple value (array).
+ * @param structType The struct type definition
+ * @param structValue The struct value to convert
+ * @returns The equivalent tuple value
+ */
+export function getTupleValueFromStructValue(structType: ABIStructType, structValue: ABIStructValue): ABIValue[] {
+  const getTupleValueFromStructFields = (structFields: ABIStructField[], values: ABIValue[]): ABIValue[] => {
+    return structFields.map(({ type }, index) => {
+      // if type is an array of fields, treat as unnamed struct
+      if (Array.isArray(type)) {
+        const value = values[index] as ABIStructValue
+        return getTupleValueFromStructFields(type, Object.values(value))
+      }
+      // if type is struct, treat as struct
+      if (isABIStructType(type)) {
+        const value = values[index] as ABIStructValue
+        return getTupleValueFromStructFields(type.structFields, Object.values(value))
+      }
+      return values[index]
+    })
+  }
+
+  return getTupleValueFromStructFields(structType.structFields, Object.values(structValue))
+}
+
+/**
+ * Converts a tuple value (array) to a struct value (object with named fields).
+ * @param structType The struct type definition
+ * @param tupleValue The tuple value to convert
+ * @returns The equivalent struct value
+ */
+export function getStructValueFromTupleValue(structType: ABIStructType, tupleValue: ABIValue[]): ABIStructValue {
+  const getStructFieldValues = (structFields: ABIStructField[], values: ABIValue[]): ABIStructValue => {
+    return Object.fromEntries(
+      structFields.map(({ name, type }, index) => {
+        // When the type is an array of fields, the value must be tuple
+        if (Array.isArray(type)) {
+          const value = values[index] as ABIValue[]
+          return [name, getStructFieldValues(type, value)]
+        }
+        // When the type is a struct, the value must be tuple
+        if (isABIStructType(type)) {
+          const value = values[index] as ABIValue[]
+          return [name, getStructFieldValues(type.structFields, value)]
+        }
+        return [name, values[index]]
+      }),
+    )
+  }
+
+  return getStructFieldValues(structType.structFields, tupleValue)
+}