Initial fixed array size implementation

#118

Author: aaroncox

src/chain/abi.ts

@@ -373,6 +373,7 @@ export namespace ABI {
         fields?: {name: string; type: ResolvedType}[]
         variant?: ResolvedType[]
         ref?: ResolvedType
+        size?: number // Fixed Size Array
 
         constructor(fullName: string, id = 0) {
             let name = fullName
@@ -388,12 +389,20 @@ export namespace ABI {
             } else {
                 this.isOptional = false
             }
+            this.isArray = false
             if (name.endsWith('[]')) {
                 name = name.slice(0, -2)
                 this.isArray = true
-            } else {
-                this.isArray = false
             }
+
+            const fixedMatch = name.match(/(.*)\[(\d+)\]/)
+            if (fixedMatch) {
+                const [, fixedName, fixedSize] = fixedMatch
+                name = fixedName
+                this.isArray = true
+                this.size = Number(fixedSize)
+            }
+
             this.id = id
             this.name = name
         }
@@ -404,7 +413,11 @@ export namespace ABI {
         get typeName(): string {
             let rv = this.name
             if (this.isArray) {
-                rv += '[]'
+                if (this.size) {
+                    rv += `[${this.size}]`
+                } else {
+                    rv += '[]'
+                }
             }
             if (this.isOptional) {
                 rv += '?'

src/serializer/encoder.ts

@@ -159,7 +159,9 @@ export function encodeAny(value: any, type: ABI.ResolvedType, ctx: EncodingConte
             throw new Error(`Expected array for: ${type.typeName}`)
         }
         const len = value.length
-        ctx.encoder.writeVaruint32(len)
+        if (!type.size) {
+            ctx.encoder.writeVaruint32(len)
+        }
         for (let i = 0; i < len; i++) {
             ctx.codingPath.push({field: i, type})
             encodeInner(value[i])

src/serializer/serializable.ts

@@ -28,6 +28,8 @@ export interface ABITypeModifiers {
     optional?: boolean
     /** Type is an array, defaults to false. */
     array?: boolean
+    /** Type has a fixed array size, defaults to undefined */
+    size?: number
     /** Type is a binary extension, defaults to false. */
     extension?: boolean
 }
@@ -93,7 +95,11 @@ export function synthesizeABI(type: ABISerializableConstructor) {
             typeName = t.type
         }
         if (t.array === true) {
-            typeName += '[]'
+            if (t.size) {
+                typeName += `[${t.size}]`
+            } else {
+                typeName += '[]'
+            }
         }
         if (t.optional === true) {
             typeName += '?'
@@ -147,7 +153,11 @@ export function synthesizeABI(type: ABISerializableConstructor) {
 export function abiTypeString(type: ABITypeDescriptor) {
     let typeName = typeof type.type === 'string' ? type.type : type.type.abiName
     if (type.array === true) {
-        typeName += '[]'
+        if (type.size) {
+            typeName += `[${type.size}]`
+        } else {
+            typeName += '[]'
+        }
     }
     if (type.optional === true) {
         typeName += '?'

test/chain.ts

@@ -756,4 +756,113 @@ suite('chain', function () {
         })
         assert.instanceOf(compressedSuccess.getTransaction(), Transaction)
     })
+
+    test('fixed size array', function () {
+        const data = {
+            version: 'eosio::abi/1.2',
+            types: [],
+            structs: [
+                {
+                    name: 'basic',
+                    base: '',
+                    fields: [
+                        {
+                            name: 'input',
+                            type: 'int32',
+                        },
+                    ],
+                },
+                {
+                    name: 'array',
+                    base: '',
+                    fields: [
+                        {
+                            name: 'input',
+                            type: 'int32[]',
+                        },
+                    ],
+                },
+                {
+                    name: 'fixed',
+                    base: '',
+                    fields: [
+                        {
+                            name: 'input',
+                            type: 'int32[4]',
+                        },
+                    ],
+                },
+            ],
+            actions: [
+                {
+                    name: 'basic',
+                    type: 'basic',
+                    ricardian_contract: '',
+                },
+                {
+                    name: 'array',
+                    type: 'array',
+                    ricardian_contract: '',
+                },
+                {
+                    name: 'fixed',
+                    type: 'fixed',
+                    ricardian_contract: '',
+                },
+            ],
+            tables: [],
+            ricardian_clauses: [],
+            error_messages: [],
+            abi_extensions: [],
+            variants: [],
+            action_results: [
+                {
+                    name: 'basic',
+                    result_type: 'int32',
+                },
+                {
+                    name: 'array',
+                    result_type: 'int32[]',
+                },
+                {
+                    name: 'fixed',
+                    result_type: 'int32[4]',
+                },
+            ],
+        }
+
+        const abi = ABI.from(data)
+        assert.isTrue(abi.equals(data))
+        assert.equal(abi.structs[0].fields[0].type, 'int32')
+        assert.equal(abi.structs[1].fields[0].type, 'int32[]')
+        assert.equal(abi.structs[2].fields[0].type, 'int32[4]')
+        assert.equal(abi.action_results[0].result_type, 'int32')
+        assert.equal(abi.action_results[1].result_type, 'int32[]')
+        assert.equal(abi.action_results[2].result_type, 'int32[4]')
+
+        const encoded = Serializer.encode({object: abi})
+        const decoded = Serializer.decode({data: encoded, type: ABI})
+        assert.isTrue(decoded.equals(data))
+        assert.equal(decoded.structs[0].fields[0].type, 'int32')
+        assert.equal(decoded.structs[1].fields[0].type, 'int32[]')
+        assert.equal(decoded.structs[2].fields[0].type, 'int32[4]')
+        assert.equal(decoded.action_results[0].result_type, 'int32')
+        assert.equal(decoded.action_results[1].result_type, 'int32[]')
+        assert.equal(decoded.action_results[2].result_type, 'int32[4]')
+
+        assert.equal(
+            '01000000',
+            Serializer.encode({object: {input: 1}, abi, type: 'basic'}).hexString
+        )
+
+        assert.equal(
+            '0401000000020000000300000004000000',
+            Serializer.encode({object: {input: [1, 2, 3, 4]}, abi, type: 'array'}).hexString
+        )
+
+        assert.equal(
+            '01000000020000000300000004000000',
+            Serializer.encode({object: {input: [1, 2, 3, 4]}, abi, type: 'fixed'}).hexString
+        )
+    })
 })