diff --git a/.github/workflows/test-localnet.yml b/.github/workflows/test-localnet.yml
new file mode 100644
index 00000000..0bb7c4d7
--- /dev/null
+++ b/.github/workflows/test-localnet.yml
@@ -0,0 +1,65 @@
+name: MultiversX Integration Tests
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+
+jobs:
+  integration_tests:
+    runs-on: ubuntu-latest
+
+    steps:
+      # Step 1: Checkout the repository
+      - name: Checkout code
+        uses: actions/checkout@v3
+
+      # Step 2: Set up Python environment
+      - name: Set up Python 3.x
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.x'
+
+    # Step 3: Install pipx (to manage Python tools)
+      - name: Install pipx
+        run: |
+          python3 -m pip install --user pipx
+          python3 -m pipx ensurepath
+          # Add the pipx binary location to PATH
+          echo "$HOME/.local/bin" >> $GITHUB_PATH
+        shell: bash
+
+      # Step 4: Install mxpy (MultiversX Python SDK)
+      - name: Install mxpy (MultiversX SDK)
+        run: |
+          pipx install multiversx-sdk-cli --force
+
+      # Step 5: Set up MultiversX localnet using mxpy
+      - name: Set up MultiversX localnet
+        run: |
+          # Start the local testnet with mxpy
+          mkdir -p ~/localnet && cd ~/localnet
+          mxpy localnet setup
+          nohup mxpy localnet start > localnet.log 2>&1 & echo $! > localnet.pid
+          sleep 60 # Allow time for the testnet to fully start
+
+      # Step 6: Install Node.js and dependencies
+      - name: Set up Node.js environment
+        uses: actions/setup-node@v3
+        with:
+          node-version: '16.x'
+
+      - name: Install Node.js dependencies
+        run: npm install
+
+      # Step 7: Run integration tests
+      - name: Run integration tests
+        run: |
+          npm run tests-localnet
+
+      # Step 8: Stop the testnet using the stored PID
+      - name: Stop MultiversX local testnet
+        if: success() || failure()
+        run: |
+          kill $(cat localnet.pid) || echo "Testnet already stopped"
diff --git a/package-lock.json b/package-lock.json
index 11b387c1..5c83ae96 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@multiversx/sdk-core",
-  "version": "13.6.0",
+  "version": "13.6.1",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@multiversx/sdk-core",
-      "version": "13.6.0",
+      "version": "13.6.1",
       "license": "MIT",
       "dependencies": {
         "@multiversx/sdk-transaction-decoder": "1.0.2",
diff --git a/package.json b/package.json
index 6a29957f..11211ca8 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@multiversx/sdk-core",
-  "version": "13.6.0",
+  "version": "13.6.1",
   "description": "MultiversX SDK for JavaScript and TypeScript",
   "author": "MultiversX",
   "homepage": "https://multiversx.com",
diff --git a/src/smartcontracts/codec/binary.ts b/src/smartcontracts/codec/binary.ts
index eb52e9d0..0c5bbdb2 100644
--- a/src/smartcontracts/codec/binary.ts
+++ b/src/smartcontracts/codec/binary.ts
@@ -18,6 +18,8 @@ import {
     ArrayVec,
     ManagedDecimalType,
     ManagedDecimalValue,
+    ManagedDecimalSignedType,
+    ManagedDecimalSignedValue,
 } from "../typesystem";
 import { guardTrue } from "../../utils";
 import { OptionValueBinaryCodec } from "./option";
@@ -28,6 +30,7 @@ import { EnumBinaryCodec } from "./enum";
 import { TupleBinaryCodec } from "./tuple";
 import { ArrayVecBinaryCodec } from "./arrayVec";
 import { ManagedDecimalCodec } from "./managedDecimal";
+import { ManagedDecimalSignedCodec } from "./managedDecimalSigned";
 
 export class BinaryCodec {
     readonly constraints: BinaryCodecConstraints;
@@ -39,6 +42,7 @@ export class BinaryCodec {
     private readonly tupleCodec: TupleBinaryCodec;
     private readonly enumCodec: EnumBinaryCodec;
     private readonly managedDecimalCodec: ManagedDecimalCodec;
+    private readonly managedDecimalSignedCodec: ManagedDecimalSignedCodec;
 
     constructor(constraints: BinaryCodecConstraints | null = null) {
         this.constraints = constraints || new BinaryCodecConstraints();
@@ -50,6 +54,7 @@ export class BinaryCodec {
         this.tupleCodec = new TupleBinaryCodec(this);
         this.enumCodec = new EnumBinaryCodec(this);
         this.managedDecimalCodec = new ManagedDecimalCodec(this);
+        this.managedDecimalSignedCodec = new ManagedDecimalSignedCodec(this);
     }
 
     decodeTopLevel<TResult extends TypedValue = TypedValue>(buffer: Buffer, type: Type): TResult {
@@ -64,6 +69,8 @@ export class BinaryCodec {
             onTuple: () => this.tupleCodec.decodeTopLevel(buffer, <TupleType>type),
             onEnum: () => this.enumCodec.decodeTopLevel(buffer, <EnumType>type),
             onManagedDecimal: () => this.managedDecimalCodec.decodeTopLevel(buffer, <ManagedDecimalType>type),
+            onManagedDecimalSigned: () =>
+                this.managedDecimalSignedCodec.decodeTopLevel(buffer, <ManagedDecimalSignedType>type),
         });
 
         return <TResult>typedValue;
@@ -81,6 +88,8 @@ export class BinaryCodec {
             onTuple: () => this.tupleCodec.decodeNested(buffer, <TupleType>type),
             onEnum: () => this.enumCodec.decodeNested(buffer, <EnumType>type),
             onManagedDecimal: () => this.managedDecimalCodec.decodeNested(buffer, <ManagedDecimalType>type),
+            onManagedDecimalSigned: () =>
+                this.managedDecimalSignedCodec.decodeNested(buffer, <ManagedDecimalSignedType>type),
         });
 
         return [<TResult>typedResult, decodedLength];
@@ -98,6 +107,8 @@ export class BinaryCodec {
             onTuple: () => this.tupleCodec.encodeNested(<Tuple>typedValue),
             onEnum: () => this.enumCodec.encodeNested(<EnumValue>typedValue),
             onManagedDecimal: () => this.managedDecimalCodec.encodeNested(<ManagedDecimalValue>typedValue),
+            onManagedDecimalSigned: () =>
+                this.managedDecimalSignedCodec.encodeNested(<ManagedDecimalSignedValue>typedValue),
         });
     }
 
@@ -113,6 +124,8 @@ export class BinaryCodec {
             onTuple: () => this.tupleCodec.encodeTopLevel(<Tuple>typedValue),
             onEnum: () => this.enumCodec.encodeTopLevel(<EnumValue>typedValue),
             onManagedDecimal: () => this.managedDecimalCodec.encodeTopLevel(<ManagedDecimalValue>typedValue),
+            onManagedDecimalSigned: () =>
+                this.managedDecimalSignedCodec.encodeTopLevel(<ManagedDecimalSignedValue>typedValue),
         });
     }
 }
diff --git a/src/smartcontracts/codec/managedDecimal.ts b/src/smartcontracts/codec/managedDecimal.ts
index 1a0e1c1c..0e2c5e43 100644
--- a/src/smartcontracts/codec/managedDecimal.ts
+++ b/src/smartcontracts/codec/managedDecimal.ts
@@ -1,5 +1,5 @@
 import BigNumber from "bignumber.js";
-import { BigUIntValue, ManagedDecimalType, ManagedDecimalValue, U32Value } from "../typesystem";
+import { BigUIntType, BigUIntValue, ManagedDecimalType, ManagedDecimalValue, U32Value } from "../typesystem";
 import { BinaryCodec } from "./binary";
 import { bufferToBigInt } from "./utils";
 import { SizeOfU32 } from "./constants";
@@ -27,25 +27,25 @@ export class ManagedDecimalCodec {
         if (type.isVariable()) {
             const bigUintSize = buffer.length - SizeOfU32;
 
-            const value = new BigNumber(buffer.slice(0, bigUintSize).toString("hex"), 16);
+            const [value] = this.binaryCodec.decodeNested(buffer.slice(0, bigUintSize), new BigUIntType());
             const scale = buffer.readUInt32BE(bigUintSize);
-
-            return new ManagedDecimalValue(value, scale);
+            return new ManagedDecimalValue(value.valueOf().shiftedBy(-scale), scale);
         }
 
         const value = bufferToBigInt(buffer);
         const metadata = type.getMetadata();
-        const scale = typeof metadata === "number" ? metadata : 0;
-        return new ManagedDecimalValue(value, scale);
+        const scale = metadata !== "usize" ? parseInt(metadata.toString()) : 0;
+        return new ManagedDecimalValue(value.shiftedBy(-scale), scale);
     }
 
     encodeNested(value: ManagedDecimalValue): Buffer {
         let buffers: Buffer[] = [];
+        const rawValue = new BigUIntValue(value.valueOf().shiftedBy(value.getScale()));
         if (value.isVariable()) {
-            buffers.push(Buffer.from(this.binaryCodec.encodeNested(new BigUIntValue(value.valueOf()))));
+            buffers.push(Buffer.from(this.binaryCodec.encodeNested(rawValue)));
             buffers.push(Buffer.from(this.binaryCodec.encodeNested(new U32Value(value.getScale()))));
         } else {
-            buffers.push(Buffer.from(this.binaryCodec.encodeTopLevel(new BigUIntValue(value.valueOf()))));
+            buffers.push(this.binaryCodec.encodeTopLevel(rawValue));
         }
         return Buffer.concat(buffers);
     }
diff --git a/src/smartcontracts/codec/managedDecimalSigned.ts b/src/smartcontracts/codec/managedDecimalSigned.ts
new file mode 100644
index 00000000..181d275b
--- /dev/null
+++ b/src/smartcontracts/codec/managedDecimalSigned.ts
@@ -0,0 +1,57 @@
+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";
+
+export class ManagedDecimalSignedCodec {
+    private readonly binaryCodec: BinaryCodec;
+
+    constructor(binaryCodec: BinaryCodec) {
+        this.binaryCodec = binaryCodec;
+    }
+
+    decodeNested(buffer: Buffer, type: ManagedDecimalSignedType): [ManagedDecimalSignedValue, number] {
+        const length = buffer.readUInt32BE(0);
+        const payload = buffer.slice(0, length);
+
+        const result = this.decodeTopLevel(payload, type);
+        return [result, length];
+    }
+
+    decodeTopLevel(buffer: Buffer, type: ManagedDecimalSignedType): ManagedDecimalSignedValue {
+        if (buffer.length === 0) {
+            return new ManagedDecimalSignedValue(new BigNumber(0), 0);
+        }
+
+        if (type.isVariable()) {
+            const bigintSize = buffer.length - SizeOfU32;
+
+            const [value] = this.binaryCodec.decodeNested(buffer.slice(0, bigintSize), new BigIntType());
+            const scale = buffer.readUInt32BE(bigintSize);
+
+            return new ManagedDecimalSignedValue(value.valueOf().shiftedBy(-scale), scale);
+        }
+
+        const value = bufferToBigInt(buffer);
+        const metadata = type.getMetadata();
+        const scale = metadata !== "usize" ? parseInt(metadata.toString()) : 0;
+        return new ManagedDecimalSignedValue(value.shiftedBy(-scale), scale);
+    }
+
+    encodeNested(value: ManagedDecimalSignedValue): Buffer {
+        let buffers: Buffer[] = [];
+        const rawValue = new BigIntValue(value.valueOf().shiftedBy(value.getScale()));
+        if (value.isVariable()) {
+            buffers.push(Buffer.from(this.binaryCodec.encodeNested(rawValue)));
+            buffers.push(Buffer.from(this.binaryCodec.encodeNested(new U32Value(value.getScale()))));
+        } else {
+            buffers.push(Buffer.from(this.binaryCodec.encodeTopLevel(rawValue)));
+        }
+        return Buffer.concat(buffers);
+    }
+
+    encodeTopLevel(value: ManagedDecimalSignedValue): Buffer {
+        return this.encodeNested(value);
+    }
+}
diff --git a/src/smartcontracts/interaction.local.net.spec.ts b/src/smartcontracts/interaction.local.net.spec.ts
index db572bfd..05b8a810 100644
--- a/src/smartcontracts/interaction.local.net.spec.ts
+++ b/src/smartcontracts/interaction.local.net.spec.ts
@@ -185,7 +185,7 @@ describe("test smart contract interactor", function () {
         assert.isTrue(typedBundle.returnCode.equals(ReturnCode.Ok));
     });
 
-    it("should interact with 'basic-features' (local testnet) using the SmartContractTransactionsFactory", async function () {
+    it("should interact with 'basic-features' (local testnet)", async function () {
         this.timeout(140000);
 
         let abiRegistry = await loadAbiRegistry("src/testdata/basic-features.abi.json");
@@ -226,7 +226,7 @@ describe("test smart contract interactor", function () {
             .buildTransaction();
 
         let additionInteraction = <Interaction>contract.methods
-            .managed_decimal_addition([new ManagedDecimalValue(2, 2), new ManagedDecimalValue(3, 2)])
+            .managed_decimal_addition([new ManagedDecimalValue("2.5", 2), new ManagedDecimalValue("2.7", 2)])
             .withGasLimit(10000000)
             .withChainID(network.ChainID)
             .withSender(alice.address)
@@ -240,7 +240,7 @@ describe("test smart contract interactor", function () {
 
         // log
         let mdLnInteraction = <Interaction>contract.methods
-            .managed_decimal_ln([new ManagedDecimalValue(23000000000, 9)])
+            .managed_decimal_ln([new ManagedDecimalValue("23", 9)])
             .withGasLimit(10000000)
             .withChainID(network.ChainID)
             .withSender(alice.address)
@@ -254,8 +254,8 @@ describe("test smart contract interactor", function () {
 
         let additionVarInteraction = <Interaction>contract.methods
             .managed_decimal_addition_var([
-                new ManagedDecimalValue(378298000000, 9, true),
-                new ManagedDecimalValue(378298000000, 9, true),
+                new ManagedDecimalValue("4", 2, true),
+                new ManagedDecimalValue("5", 2, true),
             ])
             .withGasLimit(50000000)
             .withChainID(network.ChainID)
@@ -268,33 +268,53 @@ describe("test smart contract interactor", function () {
             .useThenIncrementNonceOf(alice.account)
             .buildTransaction();
 
+        let lnVarInteraction = <Interaction>contract.methods
+            .managed_decimal_ln_var([new ManagedDecimalValue("23", 9, true)])
+            .withGasLimit(50000000)
+            .withChainID(network.ChainID)
+            .withSender(alice.address)
+            .withValue(0);
+
+        // managed_decimal_ln_var()
+        let lnVarTransaction = lnVarInteraction
+            .withSender(alice.address)
+            .useThenIncrementNonceOf(alice.account)
+            .buildTransaction();
+
         // returnEgld()
         await signTransaction({ transaction: returnEgldTransaction, wallet: alice });
         let { bundle: bundleEgld } = await controller.execute(returnEgldInteraction, returnEgldTransaction);
         assert.isTrue(bundleEgld.returnCode.equals(ReturnCode.Ok));
         assert.lengthOf(bundleEgld.values, 1);
-        assert.deepEqual(bundleEgld.values[0], new ManagedDecimalValue(1, 18));
+        assert.deepEqual(bundleEgld.values[0], new ManagedDecimalValue("0.000000000000000001", 18));
 
         // addition with const decimals()
         await signTransaction({ transaction: additionTransaction, wallet: alice });
         let { bundle: bundleAdditionConst } = await controller.execute(additionInteraction, additionTransaction);
         assert.isTrue(bundleAdditionConst.returnCode.equals(ReturnCode.Ok));
         assert.lengthOf(bundleAdditionConst.values, 1);
-        assert.deepEqual(bundleAdditionConst.values[0], new ManagedDecimalValue(5, 2));
+        assert.deepEqual(bundleAdditionConst.values[0], new ManagedDecimalValue("5.2", 2));
 
         // log
         await signTransaction({ transaction: mdLnTransaction, wallet: alice });
         let { bundle: bundleMDLn } = await controller.execute(mdLnInteraction, mdLnTransaction);
         assert.isTrue(bundleMDLn.returnCode.equals(ReturnCode.Ok));
         assert.lengthOf(bundleMDLn.values, 1);
-        assert.deepEqual(bundleMDLn.values[0], new ManagedDecimalSignedValue(3135553845, 9));
+        assert.deepEqual(bundleMDLn.values[0], new ManagedDecimalSignedValue("3.135553845", 9));
 
         // addition with var decimals
         await signTransaction({ transaction: additionVarTransaction, wallet: alice });
         let { bundle: bundleAddition } = await controller.execute(additionVarInteraction, additionVarTransaction);
         assert.isTrue(bundleAddition.returnCode.equals(ReturnCode.Ok));
         assert.lengthOf(bundleAddition.values, 1);
-        assert.deepEqual(bundleAddition.values[0], new ManagedDecimalValue(new BigNumber(6254154138880), 9));
+        assert.deepEqual(bundleAddition.values[0], new ManagedDecimalValue("9", 2));
+
+        // log
+        await signTransaction({ transaction: lnVarTransaction, wallet: alice });
+        let { bundle: bundleLnVar } = await controller.execute(lnVarInteraction, lnVarTransaction);
+        assert.isTrue(bundleLnVar.returnCode.equals(ReturnCode.Ok));
+        assert.lengthOf(bundleLnVar.values, 1);
+        assert.deepEqual(bundleLnVar.values[0], new ManagedDecimalSignedValue("3.135553845", 9));
     });
 
     it("should interact with 'counter' (local testnet)", async function () {
diff --git a/src/smartcontracts/typesystem/index.ts b/src/smartcontracts/typesystem/index.ts
index a2cadaa0..7f5dd2da 100644
--- a/src/smartcontracts/typesystem/index.ts
+++ b/src/smartcontracts/typesystem/index.ts
@@ -29,3 +29,4 @@ export * from "./typeMapper";
 export * from "./types";
 export * from "./variadic";
 export * from "./managedDecimal";
+export * from "./managedDecimalSigned";
diff --git a/src/smartcontracts/typesystem/managedDecimal.ts b/src/smartcontracts/typesystem/managedDecimal.ts
index 1522c962..b65b26a4 100644
--- a/src/smartcontracts/typesystem/managedDecimal.ts
+++ b/src/smartcontracts/typesystem/managedDecimal.ts
@@ -69,68 +69,3 @@ export class ManagedDecimalValue extends TypedValue {
         return this.variable;
     }
 }
-
-export class ManagedDecimalSignedType extends Type {
-    static ClassName = "ManagedDecimalSignedType";
-
-    constructor(metadata: number | "usize") {
-        super("ManagedDecimalSigned", undefined, undefined, metadata);
-    }
-
-    getClassName(): string {
-        return ManagedDecimalType.ClassName;
-    }
-
-    getMetadata(): number | "usize" {
-        return this.metadata;
-    }
-
-    isVariable(): boolean {
-        return this.metadata == "usize";
-    }
-}
-
-export class ManagedDecimalSignedValue extends TypedValue {
-    static ClassName = "ManagedDecimalSignedValue";
-    private readonly value: BigNumber;
-    private readonly scale: number;
-    private readonly variable: boolean;
-
-    constructor(value: BigNumber.Value, scale: number, isVariable: boolean = false) {
-        super(new ManagedDecimalSignedType(isVariable ? "usize" : scale));
-        this.value = new BigNumber(value);
-        this.scale = scale;
-        this.variable = isVariable;
-    }
-
-    getClassName(): string {
-        return ManagedDecimalValue.ClassName;
-    }
-
-    getPrecision(): number {
-        return this.value.toFixed(this.scale).replace(".", "").length;
-    }
-
-    /**
-     * Returns whether two objects have the same value.
-     */
-    equals(other: ManagedDecimalSignedValue): boolean {
-        if (this.getPrecision() != other.getPrecision()) {
-            return false;
-        }
-
-        return new BigNumber(this.value).eq(other.value);
-    }
-
-    valueOf(): BigNumber {
-        return this.value;
-    }
-
-    toString(): string {
-        return this.value.toFixed(this.scale);
-    }
-
-    isVariable(): boolean {
-        return this.variable;
-    }
-}
diff --git a/src/smartcontracts/typesystem/managedDecimalSigned.ts b/src/smartcontracts/typesystem/managedDecimalSigned.ts
new file mode 100644
index 00000000..032626f0
--- /dev/null
+++ b/src/smartcontracts/typesystem/managedDecimalSigned.ts
@@ -0,0 +1,71 @@
+import BigNumber from "bignumber.js";
+import { Type, TypedValue } from "./types";
+
+export class ManagedDecimalSignedType extends Type {
+    static ClassName = "ManagedDecimalSignedType";
+
+    constructor(metadata: number | "usize") {
+        super("ManagedDecimalSigned", undefined, undefined, metadata);
+    }
+
+    getClassName(): string {
+        return ManagedDecimalSignedType.ClassName;
+    }
+
+    getMetadata(): number | "usize" {
+        return this.metadata;
+    }
+
+    isVariable(): boolean {
+        return this.metadata == "usize";
+    }
+}
+
+export class ManagedDecimalSignedValue extends TypedValue {
+    static ClassName = "ManagedDecimalSignedValue";
+    private readonly value: BigNumber;
+    private readonly scale: number;
+    private readonly variable: boolean;
+
+    constructor(value: BigNumber.Value, scale: number, isVariable: boolean = false) {
+        super(new ManagedDecimalSignedType(isVariable ? "usize" : scale));
+        this.value = new BigNumber(value);
+        this.scale = scale;
+        this.variable = isVariable;
+    }
+
+    getClassName(): string {
+        return ManagedDecimalSignedValue.ClassName;
+    }
+
+    getPrecision(): number {
+        return this.value.toFixed(this.scale).replace(".", "").length;
+    }
+
+    getScale(): number {
+        return this.scale;
+    }
+
+    /**
+     * Returns whether two objects have the same value.
+     */
+    equals(other: ManagedDecimalSignedValue): boolean {
+        if (this.getPrecision() != other.getPrecision()) {
+            return false;
+        }
+
+        return new BigNumber(this.value).eq(other.value);
+    }
+
+    valueOf(): BigNumber {
+        return this.value;
+    }
+
+    toString(): string {
+        return this.value.toFixed(this.scale);
+    }
+
+    isVariable(): boolean {
+        return this.variable;
+    }
+}
diff --git a/src/smartcontracts/typesystem/matchers.ts b/src/smartcontracts/typesystem/matchers.ts
index 4bf5280a..7a901d75 100644
--- a/src/smartcontracts/typesystem/matchers.ts
+++ b/src/smartcontracts/typesystem/matchers.ts
@@ -16,6 +16,7 @@ import { ArrayVec, ArrayVecType } from "./genericArray";
 import { TypedValue } from "./types";
 import { StringType, StringValue } from "./string";
 import { ManagedDecimalType, ManagedDecimalValue } from "./managedDecimal";
+import { ManagedDecimalSignedType, ManagedDecimalSignedValue } from "./managedDecimalSigned";
 
 // TODO: Extend functionality or rename wrt. restricted / reduced functionality (not all types are handled: composite, variadic).
 export function onTypeSelect<TResult>(
@@ -29,6 +30,7 @@ export function onTypeSelect<TResult>(
         onTuple: () => TResult;
         onEnum: () => TResult;
         onManagedDecimal: () => TResult;
+        onManagedDecimalSigned: () => TResult;
         onOther?: () => TResult;
     },
 ): TResult {
@@ -58,6 +60,10 @@ export function onTypeSelect<TResult>(
         return selectors.onManagedDecimal();
     }
 
+    if (type.hasExactClass(ManagedDecimalSignedType.ClassName)) {
+        return selectors.onManagedDecimalSigned();
+    }
+
     if (selectors.onOther) {
         return selectors.onOther();
     }
@@ -76,6 +82,7 @@ export function onTypedValueSelect<TResult>(
         onTuple: () => TResult;
         onEnum: () => TResult;
         onManagedDecimal: () => TResult;
+        onManagedDecimalSigned: () => TResult;
         onOther?: () => TResult;
     },
 ): TResult {
@@ -103,6 +110,9 @@ export function onTypedValueSelect<TResult>(
     if (value.hasExactClass(ManagedDecimalValue.ClassName)) {
         return selectors.onManagedDecimal();
     }
+    if (value.hasExactClass(ManagedDecimalSignedValue.ClassName)) {
+        return selectors.onManagedDecimalSigned();
+    }
 
     if (selectors.onOther) {
         return selectors.onOther();
diff --git a/src/smartcontracts/typesystem/typeMapper.ts b/src/smartcontracts/typesystem/typeMapper.ts
index f058bacc..e8ca9a4d 100644
--- a/src/smartcontracts/typesystem/typeMapper.ts
+++ b/src/smartcontracts/typesystem/typeMapper.ts
@@ -10,7 +10,8 @@ import { FieldDefinition } from "./fields";
 import { ListType, OptionType } from "./generic";
 import { ArrayVecType } from "./genericArray";
 import { H256Type } from "./h256";
-import { ManagedDecimalSignedType, ManagedDecimalType } from "./managedDecimal";
+import { ManagedDecimalType } from "./managedDecimal";
+import { ManagedDecimalSignedType } from "./managedDecimalSigned";
 import { NothingType } from "./nothing";
 import {
     BigIntType,
diff --git a/src/smartcontracts/typesystem/types.spec.ts b/src/smartcontracts/typesystem/types.spec.ts
index 06d70e52..eb77985a 100644
--- a/src/smartcontracts/typesystem/types.spec.ts
+++ b/src/smartcontracts/typesystem/types.spec.ts
@@ -9,7 +9,8 @@ import { I64Type, NumericalValue, U16Type, U32Type, U32Value } from "./numerical
 import { StringType } from "./string";
 import { TypeExpressionParser } from "./typeExpressionParser";
 import { NullType, PrimitiveType, Type } from "./types";
-import { ManagedDecimalSignedType, ManagedDecimalType } from "./managedDecimal";
+import { ManagedDecimalType } from "./managedDecimal";
+import { ManagedDecimalSignedType } from "./managedDecimalSigned";
 
 describe("test types", () => {
     let parser = new TypeExpressionParser();
diff --git a/src/testdata/basic-features.abi.json b/src/testdata/basic-features.abi.json
index 762e044c..f30c5500 100644
--- a/src/testdata/basic-features.abi.json
+++ b/src/testdata/basic-features.abi.json
@@ -1,20 +1,20 @@
 {
     "buildInfo": {
         "rustc": {
-            "version": "1.80.1",
-            "commitHash": "3f5fd8dd41153bc5fdca9427e9e05be2c767ba23",
-            "commitDate": "2024-08-06",
+            "version": "1.80.0",
+            "commitHash": "051478957371ee0084a7c0913941d2a8c4757bb9",
+            "commitDate": "2024-07-21",
             "channel": "Stable",
-            "short": "rustc 1.80.1 (3f5fd8dd4 2024-08-06)"
+            "short": "rustc 1.80.0 (051478957 2024-07-21)"
         },
         "contractCrate": {
             "name": "basic-features",
             "version": "0.0.0",
-            "gitVersion": "v0.52.3-147-g2659d2399"
+            "gitVersion": "v0.53.0-3-g49a82cb19"
         },
         "framework": {
             "name": "multiversx-sc",
-            "version": "0.52.3"
+            "version": "0.53.0"
         }
     },
     "name": "BasicFeatures",
diff --git a/src/testdata/basic-features.wasm b/src/testdata/basic-features.wasm
old mode 100644
new mode 100755
index ad7cf557..47005bc7
Binary files a/src/testdata/basic-features.wasm and b/src/testdata/basic-features.wasm differ