Clean up colsole logs

src/abi/typeFormulaParser.ts

@@ -30,9 +30,7 @@ export class TypeFormulaParser {
  // It's a type name. We push it as a simple string.
  stack.push(token);
  }
- console.log({ stack });
  }
- console.log({ stack: JSON.stringify(stack) });
  if (stack.length !== 1) {
  throw new Error(`Unexpected stack length at end of parsing: ${stack.length}`);
  }
@@ -88,7 +86,7 @@ export class TypeFormulaParser {
  const typeFormula = new TypeFormula(typeName, [], typeParameters[0].name);
  return typeFormula;
  }
- const typeFormula = new TypeFormula(typeName, typeParameters);
+ const typeFormula = new TypeFormula(typeName, typeParameters.reverse());
  return typeFormula;
  }
 
@@ -97,7 +95,6 @@ export class TypeFormulaParser {
 
  while (true) {
  const item = stack.pop();
- console.log({ item });
  if (item === undefined) {
  throw new Error("Badly specified type parameters");
  }

src/smartcontracts/codec/managedDecimal.ts

@@ -1,7 +1,7 @@
 import BigNumber from "bignumber.js";
-import { BigUIntValue, ManagedDecimalType, ManagedDecimalValue, U64Value } from "../typesystem";
+import { BigUIntValue, ManagedDecimalType, ManagedDecimalValue, U32Value, U64Value } from "../typesystem";
 import { BinaryCodec } from "./binary";
-import { cloneBuffer } from "./utils";
+import { bufferToBigInt, cloneBuffer } from "./utils";
 
 export class ManagedDecimalCodec {
  private readonly binaryCodec: BinaryCodec;
@@ -12,36 +12,41 @@ export class ManagedDecimalCodec {
 
  decodeNested(buffer: Buffer, type: ManagedDecimalType): [ManagedDecimalValue, number] {
  let [bytesValue, length] = this.binaryCodec.decodeNested(buffer, type);
- console.log(11111, { bytesValue });
  return [new ManagedDecimalValue(new BigNumber(1), 1), length];
  }
 
  decodeTopLevel(buffer: Buffer, type: ManagedDecimalType): ManagedDecimalValue {
  let payload = cloneBuffer(buffer);
  let empty = buffer.length == 0;
  if (empty) {
- return new ManagedDecimalValue(new BigNumber(0), type.getScale());
+ return new ManagedDecimalValue(new BigNumber(0), 2);
  }
 
- console.log({ bsc: type });
- const decimalBuff = Buffer.from(this.binaryCodec.encodeTopLevel(new U64Value(type.getScale())));
- const bigUintSize = buffer.length - decimalBuff.length; // Remaining bytes are for BigUInt
- console.log({ buffer, l: buffer.length, d: decimalBuff.length, bigUintSize, decimalBuff, sc: type });
+ if (type.getMetadata() == "usize") {
+ const u32Size = 4;
+ const bigUintSize = buffer.length - u32Size;
 
- // Read BigUInt (dynamic size)
- const bigUintBuffer = payload.slice(0, bigUintSize);
- const u64Buffer = payload.slice(bigUintSize, payload.length);
- const bigUint = new BigNumber(bigUintBuffer.toString("hex"), 16);
- console.log({ payload, bigUintBuffer, u64Buffer });
- const u64Value = new U64Value(u64Buffer.toString("hex")).toString();
+ // Read BigUInt (dynamic size)
+ const bigUintBuffer = buffer.slice(0, bigUintSize);
+ const bigUint = new BigNumber(bigUintBuffer.toString("hex"), 16);
 
- console.log({ payload, bigUintBuffer, u64Buffer, u64Value });
- return new ManagedDecimalValue(bigUint, type.getScale());
+ const u32Offset = bigUintSize;
+ const u32 = buffer.readUInt32BE(u32Offset);
+ return new ManagedDecimalValue(bigUint, parseInt(u32.toString()));
+ }
+ let value = bufferToBigInt(payload);
+ return new ManagedDecimalValue(value, parseInt(type.getMetadata()));
  }
 
  encodeNested(value: ManagedDecimalValue): Buffer {
+ value.getType().getMetadata();
  let buffers: Buffer[] = [];
- buffers.push(Buffer.from(this.binaryCodec.encodeTopLevel(new BigUIntValue(value.valueOf()))));
+ 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);
  }
 

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

@@ -15,7 +15,7 @@ import { ResultsParser } from "./resultsParser";
 import { TransactionWatcher } from "../transactionWatcher";
 import { SmartContractQueriesController } from "../smartContractQueriesController";
 import { QueryRunnerAdapter } from "../adapters/queryRunnerAdapter";
-import { ManagedDecimalValue } from "./typesystem";
+import { ManagedDecimalSignedValue, ManagedDecimalValue } from "./typesystem";
 
 describe("test smart contract interactor", function () {
  let provider = createLocalnetProvider();
@@ -210,23 +210,23 @@ describe("test smart contract interactor", function () {
  } = await controller.deploy(deployTransaction);
  assert.isTrue(returnCode.isSuccess());
 
- // let startInteraction = <Interaction>(
- //  contract.methods
- //  .returns_egld_decimal([])
- //  .withGasLimit(8000000)
- //  .withChainID(network.ChainID)
- //  .withSender(alice.address)
- //  .withValue(1)
- // );
-
- // // start()
- // let startTransaction = startInteraction
- //  .withSender(alice.address)
- //  .useThenIncrementNonceOf(alice.account)
- //  .buildTransaction();
+ 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(122, 5), new ManagedDecimalValue(3, 6)])
+ .managed_decimal_addition([new ManagedDecimalValue(2, 2), new ManagedDecimalValue(3, 2)])
  .withGasLimit(10000000)
  .withChainID(network.ChainID)
  .withSender(alice.address)
@@ -238,31 +238,63 @@ describe("test smart contract interactor", function () {
  .useThenIncrementNonceOf(alice.account)
  .buildTransaction();
 
- // 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();
-
- // await signTransaction({ transaction: startTransaction, wallet: alice });
- // let { bundle: bundleStart } = await controller.execute(startInteraction, startTransaction);
- // assert.isTrue(bundleStart.returnCode.equals(ReturnCode.Ok));
- // assert.lengthOf(bundleStart.values, 1);
- // assert.deepEqual(bundleStart.values[0], new ManagedDecimalValue(1, 18));
+ // 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: bundleAddition } = await controller.execute(additionInteraction, additionTransaction);
+ 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(5), 2));
- // assert.deepEqual(bundleAddition.values[0], new ManagedDecimalValue(new BigNumber(3.135553845), 9));
+ assert.deepEqual(bundleAddition.values[0], new ManagedDecimalValue(new BigNumber(6254154138880), 9));
  });
 
  it("should interact with 'counter' (local testnet)", async function () {

src/smartcontracts/typesystem/managedDecimal.ts

@@ -3,19 +3,18 @@ import { Type, TypedValue } from "./types";
 
 export class ManagedDecimalType extends Type {
  static ClassName = "ManagedDecimalType";
- private readonly scale: number;
+ private readonly scale: any;
 
- constructor(scale: number) {
- super("ManagedDecimal", undefined, undefined, scale);
- this.scale = scale;
+ constructor(metadata: any) {
+ super("ManagedDecimal", undefined, undefined, metadata);
  }
 
  getClassName(): string {
  return ManagedDecimalType.ClassName;
  }
 
- getScale(): number {
- return this.scale;
+ getMetadata(): string {
+ return this.metadata;
  }
 }
 
@@ -24,8 +23,8 @@ export class ManagedDecimalValue extends TypedValue {
  private readonly value: BigNumber;
  private readonly scale: number;
 
- constructor(value: BigNumber.Value, scale: number) {
- super(new ManagedDecimalType(scale));
+ constructor(value: BigNumber.Value, scale: number, isVar: boolean = false) {
+ super(new ManagedDecimalType(isVar ? "usize" : scale));
  this.value = new BigNumber(value);
  this.scale = scale;
  }
@@ -85,9 +84,9 @@ export class ManagedDecimalSignedValue extends TypedValue {
  private readonly value: BigNumber;
  private readonly scale: number;
 
- constructor(value: BigNumber, scale: number) {
+ constructor(value: BigNumber.Value, scale: number) {
  super(new ManagedDecimalType(scale));
- this.value = value;
+ this.value = new BigNumber(value);
  this.scale = scale;
  }
 

src/smartcontracts/typesystem/typeMapper.ts

@@ -76,8 +76,8 @@ export class TypeMapper {
  ["array64", (...typeParameters: Type[]) => new ArrayVecType(64, typeParameters[0])],
  ["array128", (...typeParameters: Type[]) => new ArrayVecType(128, typeParameters[0])],
  ["array256", (...typeParameters: Type[]) => new ArrayVecType(256, typeParameters[0])],
- ["ManagedDecimal", (...metadata: any) => new ManagedDecimalType(parseInt(metadata))],
- ["ManagedDecimalSigned", (...metadata: any) => new ManagedDecimalSignedType(parseInt(metadata))],
+ ["ManagedDecimal", (...metadata: any) => new ManagedDecimalType(metadata)],
+ ["ManagedDecimalSigned", (...metadata: any) => new ManagedDecimalSignedType(metadata)],
  ]);
 
  // For closed types, we hold actual type instances instead of type constructors / factories (no type parameters needed).