Add managed decimal support (as in the rust framework)

src/abi/typeFormula.ts

@@ -1,18 +1,21 @@
 export class TypeFormula {
     name: string;
+    metadata: any;
     typeParameters: TypeFormula[];
 
-    constructor(name: string, typeParameters: TypeFormula[]) {
+    constructor(name: string, typeParameters: TypeFormula[], metadata?: any) {
         this.name = name;
         this.typeParameters = typeParameters;
+        this.metadata = metadata;
     }
 
     toString(): string {
-        if (this.typeParameters.length > 0) {
-            const typeParameters = this.typeParameters.map((typeParameter) => typeParameter.toString()).join(", ");
-            return `${this.name}<${typeParameters}>`;
-        } else {
-            return this.name;
-        }
+        const hasTypeParameters = this.typeParameters.length > 0;
+        const typeParameters = hasTypeParameters
+            ? `<${this.typeParameters.map((tp) => tp.toString()).join(", ")}>`
+            : "";
+        const baseName = `${this.name}${typeParameters}`;
+
+        return this.metadata !== undefined ? `${baseName}*${this.metadata}*` : baseName;
     }
 }

src/abi/typeFormulaParser.ts

@@ -12,7 +12,6 @@ export class TypeFormulaParser {
 
     parseExpression(expression: string): TypeFormula {
         expression = expression.trim();
-
         const tokens = this.tokenizeExpression(expression).filter((token) => token !== TypeFormulaParser.COMMA);
         const stack: any[] = [];
 
@@ -32,7 +31,6 @@ export class TypeFormulaParser {
                 stack.push(token);
             }
         }
-
         if (stack.length !== 1) {
             throw new Error(`Unexpected stack length at end of parsing: ${stack.length}`);
         }
@@ -83,6 +81,11 @@ export class TypeFormulaParser {
     private acquireTypeWithParameters(stack: any[]): TypeFormula {
         const typeParameters = this.acquireTypeParameters(stack);
         const typeName = stack.pop();
+
+        if (typeName === "ManagedDecimal" || typeName === "ManagedDecimalSigned") {
+            const typeFormula = new TypeFormula(typeName, [], typeParameters[0].name);
+            return typeFormula;
+        }
         const typeFormula = new TypeFormula(typeName, typeParameters.reverse());
         return typeFormula;
     }
@@ -92,7 +95,6 @@ export class TypeFormulaParser {
 
         while (true) {
             const item = stack.pop();
-
             if (item === undefined) {
                 throw new Error("Badly specified type parameters");
             }

src/smartcontracts/codec/binary.ts

@@ -16,6 +16,8 @@ import {
     Tuple,
     ArrayVecType,
     ArrayVec,
+    ManagedDecimalType,
+    ManagedDecimalValue,
 } from "../typesystem";
 import { guardTrue } from "../../utils";
 import { OptionValueBinaryCodec } from "./option";
@@ -25,6 +27,7 @@ import { StructBinaryCodec } from "./struct";
 import { EnumBinaryCodec } from "./enum";
 import { TupleBinaryCodec } from "./tuple";
 import { ArrayVecBinaryCodec } from "./arrayVec";
+import { ManagedDecimalCodec } from "./managedDecimal";
 
 export class BinaryCodec {
     readonly constraints: BinaryCodecConstraints;
@@ -35,6 +38,7 @@ export class BinaryCodec {
     private readonly structCodec: StructBinaryCodec;
     private readonly tupleCodec: TupleBinaryCodec;
     private readonly enumCodec: EnumBinaryCodec;
+    private readonly managedDecimalCodec: ManagedDecimalCodec;
 
     constructor(constraints: BinaryCodecConstraints | null = null) {
         this.constraints = constraints || new BinaryCodecConstraints();
@@ -45,6 +49,7 @@ export class BinaryCodec {
         this.structCodec = new StructBinaryCodec(this);
         this.tupleCodec = new TupleBinaryCodec(this);
         this.enumCodec = new EnumBinaryCodec(this);
+        this.managedDecimalCodec = new ManagedDecimalCodec(this);
     }
 
     decodeTopLevel<TResult extends TypedValue = TypedValue>(buffer: Buffer, type: Type): TResult {
@@ -58,6 +63,7 @@ export class BinaryCodec {
             onStruct: () => this.structCodec.decodeTopLevel(buffer, <StructType>type),
             onTuple: () => this.tupleCodec.decodeTopLevel(buffer, <TupleType>type),
             onEnum: () => this.enumCodec.decodeTopLevel(buffer, <EnumType>type),
+            onManagedDecimal: () => this.managedDecimalCodec.decodeTopLevel(buffer, <ManagedDecimalType>type),
         });
 
         return <TResult>typedValue;
@@ -74,6 +80,7 @@ export class BinaryCodec {
             onStruct: () => this.structCodec.decodeNested(buffer, <StructType>type),
             onTuple: () => this.tupleCodec.decodeNested(buffer, <TupleType>type),
             onEnum: () => this.enumCodec.decodeNested(buffer, <EnumType>type),
+            onManagedDecimal: () => this.managedDecimalCodec.decodeNested(buffer, <ManagedDecimalType>type),
         });
 
         return [<TResult>typedResult, decodedLength];
@@ -90,6 +97,7 @@ export class BinaryCodec {
             onStruct: () => this.structCodec.encodeNested(<Struct>typedValue),
             onTuple: () => this.tupleCodec.encodeNested(<Tuple>typedValue),
             onEnum: () => this.enumCodec.encodeNested(<EnumValue>typedValue),
+            onManagedDecimal: () => this.managedDecimalCodec.encodeNested(<ManagedDecimalValue>typedValue),
         });
     }
 
@@ -104,6 +112,7 @@ export class BinaryCodec {
             onStruct: () => this.structCodec.encodeTopLevel(<Struct>typedValue),
             onTuple: () => this.tupleCodec.encodeTopLevel(<Tuple>typedValue),
             onEnum: () => this.enumCodec.encodeTopLevel(<EnumValue>typedValue),
+            onManagedDecimal: () => this.managedDecimalCodec.encodeTopLevel(<ManagedDecimalValue>typedValue),
         });
     }
 }

src/smartcontracts/codec/managedDecimal.ts

@@ -0,0 +1,58 @@
+import BigNumber from "bignumber.js";
+import { BigUIntValue, ManagedDecimalType, ManagedDecimalValue, U32Value } from "../typesystem";
+import { BinaryCodec } from "./binary";
+import { bufferToBigInt } from "./utils";
+
+export class ManagedDecimalCodec {
+    private readonly binaryCodec: BinaryCodec;
+
+    constructor(binaryCodec: BinaryCodec) {
+        this.binaryCodec = binaryCodec;
+    }
+
+    decodeNested(buffer: Buffer, type: ManagedDecimalType): [ManagedDecimalValue, number] {
+        const length = buffer.readUInt32BE(0);
+        const payload = buffer.slice(0, length);
+
+        const result = this.decodeTopLevel(payload, type);
+        const decodedLength = length;
+
+        return [result, decodedLength];
+    }
+
+    decodeTopLevel(buffer: Buffer, type: ManagedDecimalType): ManagedDecimalValue {
+        if (buffer.length === 0) {
+            return new ManagedDecimalValue(new BigNumber(0), 2);
+        }
+
+        const isUsize = type.getMetadata() === "usize";
+
+        if (isUsize) {
+            const u32Size = 4;
+            const bigUintSize = buffer.length - u32Size;
+
+            const bigUint = new BigNumber(buffer.slice(0, bigUintSize).toString("hex"), 16);
+            const u32 = buffer.readUInt32BE(bigUintSize);
+
+            return new ManagedDecimalValue(bigUint, u32);
+        }
+
+        const value = bufferToBigInt(buffer);
+        return new ManagedDecimalValue(value, parseInt(type.getMetadata()));
+    }
+
+    encodeNested(value: ManagedDecimalValue): Buffer {
+        let buffers: Buffer[] = [];
+        if (value.getType().getMetadata() == "usize") {
+            buffers.push(Buffer.from(this.binaryCodec.encodeNested(new BigUIntValue(value.valueOf()))));
+            buffers.push(Buffer.from(this.binaryCodec.encodeNested(new U32Value(value.getScale()))));
+        } else {
+            buffers.push(Buffer.from(this.binaryCodec.encodeTopLevel(new BigUIntValue(value.valueOf()))));
+        }
+        return Buffer.concat(buffers);
+    }
+
+    encodeTopLevel(value: ManagedDecimalValue): Buffer {
+        return this.encodeNested(value);
+    }
+}

src/smartcontracts/interaction.local.net.spec.ts

@@ -15,6 +15,7 @@ import { ResultsParser } from "./resultsParser";
 import { TransactionWatcher } from "../transactionWatcher";
 import { SmartContractQueriesController } from "../smartContractQueriesController";
 import { QueryRunnerAdapter } from "../adapters/queryRunnerAdapter";
+import { ManagedDecimalSignedValue, ManagedDecimalValue } from "./typesystem";
 
 describe("test smart contract interactor", function () {
     let provider = createLocalnetProvider();
@@ -184,6 +185,118 @@ 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 () {
+        this.timeout(140000);
+
+        let abiRegistry = await loadAbiRegistry("src/testdata/basic-features.abi.json");
+        let contract = new SmartContract({ abi: abiRegistry });
+        let controller = new ContractController(provider);
+
+        let network = await provider.getNetworkConfig();
+        await alice.sync(provider);
+
+        // Deploy the contract
+        let deployTransaction = await prepareDeployment({
+            contract: contract,
+            deployer: alice,
+            codePath: "src/testdata/basic-features.wasm",
+            gasLimit: 600000000,
+            initArguments: [],
+            chainID: network.ChainID,
+        });
+
+        let {
+            bundle: { returnCode },
+        } = await controller.deploy(deployTransaction);
+        assert.isTrue(returnCode.isSuccess());
+
+        let returnEgldInteraction = <Interaction>(
+            contract.methods
+                .returns_egld_decimal([])
+                .withGasLimit(10000000)
+                .withChainID(network.ChainID)
+                .withSender(alice.address)
+                .withValue(1)
+        );
+
+        // returnEgld()
+        let returnEgldTransaction = returnEgldInteraction
+            .withSender(alice.address)
+            .useThenIncrementNonceOf(alice.account)
+            .buildTransaction();
+
+        let additionInteraction = <Interaction>contract.methods
+            .managed_decimal_addition([new ManagedDecimalValue(2, 2), new ManagedDecimalValue(3, 2)])
+            .withGasLimit(10000000)
+            .withChainID(network.ChainID)
+            .withSender(alice.address)
+            .withValue(0);
+
+        // addition()
+        let additionTransaction = additionInteraction
+            .withSender(alice.address)
+            .useThenIncrementNonceOf(alice.account)
+            .buildTransaction();
+
+        // log
+        let mdLnInteraction = <Interaction>contract.methods
+            .managed_decimal_ln([new ManagedDecimalValue(23, 9)])
+            .withGasLimit(10000000)
+            .withChainID(network.ChainID)
+            .withSender(alice.address)
+            .withValue(0);
+
+        // mdLn()
+        let mdLnTransaction = mdLnInteraction
+            .withSender(alice.address)
+            .useThenIncrementNonceOf(alice.account)
+            .buildTransaction();
+
+        let additionVarInteraction = <Interaction>contract.methods
+            .managed_decimal_addition_var([
+                new ManagedDecimalValue(378298000000, 9, true),
+                new ManagedDecimalValue(378298000000, 9, true),
+            ])
+            .withGasLimit(50000000)
+            .withChainID(network.ChainID)
+            .withSender(alice.address)
+            .withValue(0);
+
+        // addition()
+        let additionVarTransaction = additionVarInteraction
+            .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));
+
+        // 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));
+
+        // 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(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));
+    });
+
     it("should interact with 'counter' (local testnet)", async function () {
         this.timeout(120000);
 

src/smartcontracts/nativeSerializer.spec.ts

@@ -16,6 +16,8 @@ import {
     EndpointModifiers,
     EndpointParameterDefinition,
     ListType,
+    ManagedDecimalType,
+    ManagedDecimalValue,
     NullType,
     OptionalType,
     OptionalValue,
@@ -401,6 +403,47 @@ describe("test native serializer", () => {
         ]);
     });
 
+    it("should accept managed decimals with constants and variable decimals", async () => {
+        const endpoint = AbiRegistry.create({
+            endpoints: [
+                {
+                    name: "foo",
+                    inputs: [
+                        {
+                            type: "ManagedDecimal<8>",
+                        },
+                        {
+                            type: "ManagedDecimal<usize>",
+                        },
+                    ],
+                    outputs: [],
+                },
+            ],
+        }).getEndpoint("foo");
+
+        // Pass only native values
+        let typedValues = NativeSerializer.nativeToTypedValues(
+            [
+                [2, 8],
+                [12.5644, 6],
+            ],
+            endpoint,
+        );
+
+        assert.deepEqual(typedValues[0].getType(), new ManagedDecimalType(8));
+        assert.deepEqual(typedValues[0].valueOf(), new BigNumber(2));
+        assert.deepEqual(typedValues[1].getType(), new ManagedDecimalType("usize"));
+        assert.deepEqual(typedValues[1].valueOf(), new BigNumber(12.5644));
+
+        // Pass a mix of native and typed values
+        typedValues = NativeSerializer.nativeToTypedValues([new ManagedDecimalValue(2, 8), [12.5644, 6]], endpoint);
+
+        assert.deepEqual(typedValues[0].getType(), new ManagedDecimalType(8));
+        assert.deepEqual(typedValues[0].valueOf(), new BigNumber(2));
+        assert.deepEqual(typedValues[1].getType(), new ManagedDecimalType("usize"));
+        assert.deepEqual(typedValues[1].valueOf(), new BigNumber(12.5644));
+    });
+
     it("should accept no value for variadic types", async () => {
         const endpoint = AbiRegistry.create({
             endpoints: [