Merge pull request #671 from multiversx/fix-managed-decimal-nested-decoding

Fix nested decoding for managed decimal

Author: popenta

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@multiversx/sdk-core",
-  "version": "15.2.1",
+  "version": "15.2.2",
   "description": "MultiversX SDK for JavaScript and TypeScript",
   "author": "MultiversX",
   "homepage": "https://multiversx.com",

package.json

@@ -33,8 +33,10 @@ import {
     I8Value,
     List,
     ListType,
+    ManagedDecimalType,
     NumericalType,
     NumericalValue,
+    OptionType,
     StringType,
     StringValue,
     Struct,
@@ -478,6 +480,30 @@ describe("test binary codec (advanced)", () => {
         decoded = codec.decodeTopLevel(blueEncodedTopLevel, enumType);
         assert.deepEqual(decoded, blue);
     });
+
+    it("should decode struct", async () => {
+        let codec = new BinaryCodec();
+        let fooType = new StructType("DepositEvent", [
+            new FieldDefinition("tx_nonce", "", new U64Type()),
+            new FieldDefinition("opt_function", "", new OptionType(new BytesType())),
+            new FieldDefinition("opt_arguments", "", new OptionType(new ListType(new BytesType()))),
+            new FieldDefinition("opt_gas_limit", "", new OptionType(new U64Type())),
+            new FieldDefinition("managed_decimal", "", new ManagedDecimalType("usize")),
+        ]);
+
+        const encoded = Buffer.from("00000000000003db0000000000000202bc00000002", "hex");
+
+        let [decoded] = codec.decodeNested(encoded, fooType);
+
+        let plainFoo = decoded.valueOf();
+        assert.deepEqual(plainFoo, {
+            tx_nonce: new BigNumber(987),
+            opt_function: null,
+            opt_arguments: null,
+            opt_gas_limit: null,
+            managed_decimal: new BigNumber(7),
+        });
+    });
 });
 
 function serialized(prettyHex: string): Buffer {

src/abi/codec/binary.spec.ts

@@ -1,8 +1,8 @@
 import BigNumber from "bignumber.js";
 import { BigUIntType, BigUIntValue, ManagedDecimalType, ManagedDecimalValue, U32Value } from "../typesystem";
 import { BinaryCodec } from "./binary";
-import { bufferToBigInt } from "./utils";
 import { SizeOfU32 } from "./constants";
+import { bufferToBigInt } from "./utils";
 
 export class ManagedDecimalCodec {
     private readonly binaryCodec: BinaryCodec;
@@ -12,8 +12,20 @@ export class ManagedDecimalCodec {
     }
 
     decodeNested(buffer: Buffer, type: ManagedDecimalType): [ManagedDecimalValue, number] {
-        const length = buffer.readUInt32BE(0);
-        const payload = buffer.slice(0, length);
+        let payload: Buffer;
+        let length: number;
+
+        if (type.isVariable()) {
+            // read BigUInt value length
+            const bigUintSizeBytes = buffer.slice(0, SizeOfU32);
+            const bigUintLength = bigUintSizeBytes.readUInt32BE(0);
+
+            length = SizeOfU32 + bigUintLength + SizeOfU32;
+            payload = buffer.slice(0, length);
+        } else {
+            length = buffer.readUInt32BE(0);
+            payload = buffer.slice(0, length);
+        }
 
         const result = this.decodeTopLevel(payload, type);
         return [result, length];
@@ -29,13 +41,15 @@ export class ManagedDecimalCodec {
 
             const [value] = this.binaryCodec.decodeNested(buffer.slice(0, bigUintSize), new BigUIntType());
             const scale = buffer.readUInt32BE(bigUintSize);
-            return new ManagedDecimalValue(value.valueOf().shiftedBy(-scale), scale);
+            return new ManagedDecimalValue(value.valueOf().shiftedBy(-scale), scale, true);
         }
 
         const value = bufferToBigInt(buffer);
         const metadata = type.getMetadata();
+
+        // if this code executes, metadata is guaranteed to be a number
         const scale = metadata !== "usize" ? parseInt(metadata.toString()) : 0;
-        return new ManagedDecimalValue(value.shiftedBy(-scale), scale);
+        return new ManagedDecimalValue(value.shiftedBy(-scale), scale, false);
     }
 
     encodeNested(value: ManagedDecimalValue): Buffer {

src/abi/codec/managedDecimal.ts

@@ -1,8 +1,8 @@
 import BigNumber from "bignumber.js";
 import { BigIntType, BigIntValue, ManagedDecimalSignedType, ManagedDecimalSignedValue, U32Value } from "../typesystem";
 import { BinaryCodec } from "./binary";
-import { bufferToBigInt } from "./utils";
 import { SizeOfU32 } from "./constants";
+import { bufferToBigInt } from "./utils";
 
 export class ManagedDecimalSignedCodec {
     private readonly binaryCodec: BinaryCodec;
@@ -12,8 +12,20 @@ export class ManagedDecimalSignedCodec {
     }
 
     decodeNested(buffer: Buffer, type: ManagedDecimalSignedType): [ManagedDecimalSignedValue, number] {
-        const length = buffer.readUInt32BE(0);
-        const payload = buffer.slice(0, length);
+        let payload: Buffer;
+        let length: number;
+
+        if (type.isVariable()) {
+            // read BigInt value length
+            const bigIntSizeBytes = buffer.slice(0, SizeOfU32);
+            const bigIntLength = bigIntSizeBytes.readUInt32BE(0);
+
+            length = SizeOfU32 + bigIntLength + SizeOfU32;
+            payload = buffer.slice(0, length);
+        } else {
+            length = buffer.readUInt32BE(0);
+            payload = buffer.slice(0, length);
+        }
 
         const result = this.decodeTopLevel(payload, type);
         return [result, length];
@@ -30,13 +42,15 @@ export class ManagedDecimalSignedCodec {
             const [value] = this.binaryCodec.decodeNested(buffer.slice(0, bigintSize), new BigIntType());
             const scale = buffer.readUInt32BE(bigintSize);
 
-            return new ManagedDecimalSignedValue(value.valueOf().shiftedBy(-scale), scale);
+            return new ManagedDecimalSignedValue(value.valueOf().shiftedBy(-scale), scale, true);
         }
 
         const value = bufferToBigInt(buffer);
         const metadata = type.getMetadata();
+
+        // if this code executes, metadata is guaranteed to be a number
         const scale = metadata !== "usize" ? parseInt(metadata.toString()) : 0;
-        return new ManagedDecimalSignedValue(value.shiftedBy(-scale), scale);
+        return new ManagedDecimalSignedValue(value.shiftedBy(-scale), scale, false);
     }
 
     encodeNested(value: ManagedDecimalSignedValue): Buffer {