@ensofinance/weiroll - npm Package Compare versions

Comparing version 1.3.1 to 1.4.0

.github/workflows/test.yml

@@ -26,3 +26,3 @@ name: Test
           node-version: ${{ matrix.node-version }}
-      - run: npm install
-      - run: npm run test
+      - run: yarn
+      - run: yarn run test

package.json

 {
   "name": "@ensofinance/weiroll",
-  "version": "1.3.1",
+  "version": "1.4.0",
   "devDependencies": {
-    "@ensofinance/weiroll.js": "^0.3.4",
+    "@ensofinance/weiroll.js": "^0.4.0",
     "@nomiclabs/hardhat-ethers": "^2.0.2",
@@ -7,0 +7,0 @@ "@nomiclabs/hardhat-waffle": "^2.0.1",

test/commandbuilder.js

@@ -15,2 +15,5 @@ const { expect } = require("chai");
   let strings;
+  let struct;
+  let fixed;
+  let arrays;
   let abi = ethers.utils.defaultAbiCoder;
@@ -24,32 +27,40 @@
     strings = await deployLibrary("Strings");
+    struct = await deployLibrary("Struct");
+    fixed = await deployLibrary("Fixed");
+    arrays = await deployLibrary("Arrays");
   });
 
-  async function executeBuildInputs(commands, state, abiout, msg) {
-    for (let c of commands) {
-      selector = ethers.utils.hexDataSlice(c, 0, 4);
-      indices = ethers.utils.hexConcat([
-        ethers.utils.hexDataSlice(c, 5, 5 + 6),
-        "0xffffffffffffffffffffffffffffffffffffffffffffffffffff",
-      ]);
-      target = ethers.utils.hexDataSlice(c, 5 + 6);
-      const txBaseGasNoArgs = await cbh.estimateGas.basecall();
-      const txBaseGas = await cbh.estimateGas.testBuildInputsBaseGas(
-        state,
-        selector,
-        indices
-      );
-      const txGas = await cbh.estimateGas.testBuildInputs(
-        state,
-        selector,
-        indices
-      );
-      console.log(
-        `buildInputs gas cost: ${txGas
-          .sub(txBaseGas)
-          .toString()} - argument passing cost: ${txBaseGas
-          .sub(txBaseGasNoArgs)
-          .toNumber()} - total: ${txGas.toNumber()}`
-      );
-      const result = await cbh.testBuildInputs(state, selector, indices);
-      expect(result).to.equal(selector + abiout.slice(2));
+  async function executeBuildInputs(commands, state, abiout, msg){
+    for (let i = 0; i < commands.length; i++) {
+        const c = commands[i]
+        selector = ethers.utils.hexDataSlice(c, 0, 4);
+        flags = ethers.utils.hexDataSlice(c, 4, 5);
+        if (flags == "0x40") {
+          i++;
+          indices = commands[i];
+        } else {
+          indices = ethers.utils.hexConcat([ethers.utils.hexDataSlice(c, 5, 5+6), "0xffffffffffffffffffffffffffffffffffffffffffffffffffff"]);
+        }
+
+        target = ethers.utils.hexDataSlice(c, 5+6);
+        const txBaseGasNoArgs = await cbh.estimateGas.basecall();
+        const txBaseGas = await cbh.estimateGas.testBuildInputsBaseGas(
+          state,
+          selector,
+          indices
+        );
+        const txGas = await cbh.estimateGas.testBuildInputs(
+          state,
+          selector,
+          indices
+        );
+        console.log(
+          `buildInputs gas cost: ${txGas
+            .sub(txBaseGas)
+            .toString()} - argument passing cost: ${txBaseGas
+            .sub(txBaseGasNoArgs)
+            .toNumber()} - total: ${txGas.toNumber()}`
+        );
+        const result = await cbh.testBuildInputs(state, selector, indices);
+        expect(result).to.equal(selector + abiout.slice(2));
     }
@@ -84,4 +95,167 @@ }
     await executeBuildInputs(commands, state, abiout, "Strings.strcat");
+
   });
 
+  it("Should build inputs that match Strings.strlen ABI", async () => {
+    const planner = new weiroll.Planner();
+
+    let args = ["Hello World!"];
+
+    abiout = abi.encode(strings.interface.getFunction("strlen").inputs, args);
+
+    planner.add(strings.strlen(...args));
+
+    const {commands, state} = planner.plan();
+
+    await executeBuildInputs(commands, state, abiout, "Strings.strlen");
+
+  });
+
+  it("Should build inputs that match Struct.returnStringStruct ABI", async () => {
+    const planner = new weiroll.Planner();
+
+    let args = [{ a: "Hello", b: "World"}];
+
+    abiout = abi.encode(struct.interface.getFunction("returnStringStruct").inputs, args);
+
+    planner.add(struct.returnStringStruct(...args));
+
+    const {commands, state} = planner.plan();
+
+    await executeBuildInputs(commands, state, abiout, "Struct.returnStringStruct");
+
+  });
+
+  it("Should build inputs that match Struct.returnComplexStruct ABI", async () => {
+    const planner = new weiroll.Planner();
+
+    let args = [
+      {
+        id: "0xdadadadadadadadadadadadadadadadadadadadadadadadadadadadadadadada",
+        category: 1,
+        from: "0x1212121212121212121212121212121212121212",
+        to: "0x1313131313131313131313131313131313131313",
+        amount: 1000,
+        data: "0xbebebebe"
+      },
+      {
+        from: "0x1414141414141414141414141414141414141414",
+        approvedFrom: false,
+        to: "0x1515151515151515151515151515151515151515",
+        approvedTo: false
+      },
+      0,
+      ethers.constants.MaxUint256
+    ];
+
+    abiout = abi.encode(struct.interface.getFunction("returnComplexStruct").inputs, args);
+
+    planner.add(struct.returnComplexStruct(...args));
+
+    const {commands, state} = planner.plan();
+
+    await executeBuildInputs(commands, state, abiout, "Struct.returnComplexStruct");
+
+  });
+
+  it("Should build inputs that match Struct.returnMultiStructArray ABI", async () => {
+    const planner = new weiroll.Planner();
+
+    let args = [[
+      {
+        a: "0x1010101010101010101010101010101010101010",
+        b: "0x1111111111111111111111111111111111111111",
+        d: {
+          id: "0xdadadadadadadadadadadadadadadadadadadadadadadadadadadadadadadada",
+          category: 1,
+          from: "0x1212121212121212121212121212121212121212",
+          to: "0x1313131313131313131313131313131313131313",
+          amount: 1000,
+          data: "0xbebebebe"
+        }
+      },{
+        a: "0x2020202020202020202020202020202020202020",
+        b: "0x2121212121212121212121212121212121212121",
+        d: {
+          id: "0xfafafafafafafafafafafafafafafafafafafafafafafafafafafafafafafafa",
+          category: 2,
+          from: "0x2222222222222222222222222222222222222222",
+          to: "0x2323232323232323232323232323232323232323",
+          amount: 1000,
+          data: "0xbebebebe"
+        }
+      }
+
+    ]];
+
+    abiout = abi.encode(struct.interface.getFunction("returnMultiStructArray").inputs, args);
+
+    planner.add(struct.returnMultiStructArray(...args));
+
+    const {commands, state} = planner.plan();
+
+    await executeBuildInputs(commands, state, abiout, "Struct.returnMultiStructArray");
+
+  });
+
+  it("Should build inputs that match Fixed.addStruct ABI", async () => {
+    const planner = new weiroll.Planner();
+
+    let args = [{ a: 1, b: 2}];
+
+    abiout = abi.encode(fixed.interface.getFunction("addStruct").inputs, args);
+
+    planner.add(fixed.addStruct(...args));
+
+    const {commands, state} = planner.plan();
+
+    await executeBuildInputs(commands, state, abiout, "Fixed.addStruct");
+
+  });
+
+  it("Should build inputs that match Struct.returnMixedStruct ABI", async () => {
+    const planner = new weiroll.Planner();
+
+    let args = [{ a: 1, b: cbh.address}];
+
+    abiout = abi.encode(struct.interface.getFunction("returnMixedStruct").inputs, args);
+
+    planner.add(struct.returnMixedStruct(...args));
+
+    const {commands, state} = planner.plan();
+
+    await executeBuildInputs(commands, state, abiout, "Struct.returnMixedStruct");
+
+  });
+
+  it("Should build inputs that match Struct.returnParamAndStruct ABI", async () => {
+    const planner = new weiroll.Planner();
+
+    let args = [3, { a: 1, b: cbh.address}];
+
+    abiout = abi.encode(struct.interface.getFunction("returnParamAndStruct").inputs, args);
+
+    planner.add(struct.returnParamAndStruct(...args));
+
+    const {commands, state} = planner.plan();
+
+    await executeBuildInputs(commands, state, abiout, "Struct.returnParamAndStruct");
+
+  });
+
+  it("Should build inputs that match Struct.returnDynamicParamAndStruct ABI", async () => {
+    const planner = new weiroll.Planner();
+
+    let args = ["Test", { a: 1, b: cbh.address}];
+
+    abiout = abi.encode(struct.interface.getFunction("returnDynamicParamAndStruct").inputs, args);
+
+    planner.add(struct.returnDynamicParamAndStruct(...args));
+
+    const {commands, state} = planner.plan();
+
+    await executeBuildInputs(commands, state, abiout, "Struct.returnDynamicParamAndStruct");
+
+  });
+
   it("Should build inputs that match Math.sum ABI", async () => {
@@ -111,2 +285,45 @@ const planner = new weiroll.Planner();
 
+  it("Should build inputs that match Arrays.sumAndMultiply ABI", async () => {
+    const planner = new weiroll.Planner();
+
+    let args1 = [
+      ethers.BigNumber.from("0xAAA0000000000000000000000000000000000000000000000000000000000002"),
+      ethers.BigNumber.from("0x1111111111111111111111111111111111111111111111111111111111111111"),
+      ethers.BigNumber.from("0x2222222222222222222222222222222222222222222222222222222222222222")
+    ];
+
+    let args2 = [
+      ethers.BigNumber.from("0xAAA0000000000000000000000000000000000000000000000000000000000002"),
+      ethers.BigNumber.from("0x1111111111111111111111111111111111111111111111111111111111111111"),
+      ethers.BigNumber.from("0x2222222222222222222222222222222222222222222222222222222222222222")
+    ];
+
+    abiout = abi.encode(arrays.interface.getFunction("sumAndMultiply").inputs, [args1, args2]);
+
+    planner.add(arrays.sumAndMultiply(args1, args2));
+
+    const {commands, state} = planner.plan();
+
+    await executeBuildInputs(commands, state, abiout, "Math.sumAndMultiply");
+
+  });
+
+  it("Should build inputs that match Fixed.addArray ABI", async () => {
+    const planner = new weiroll.Planner();
+
+    let args = [
+      ethers.BigNumber.from("0xAAA0000000000000000000000000000000000000000000000000000000000002"),
+      ethers.BigNumber.from("0x1111111111111111111111111111111111111111111111111111111111111111")
+    ];
+
+    abiout = abi.encode(fixed.interface.getFunction("addArray").inputs, [args]);
+
+    planner.add(fixed.addArray(args));
+
+    const {commands, state} = planner.plan();
+
+    await executeBuildInputs(commands, state, abiout, "Fixed.addArray");
+
+  });
+
   it("Should select and overwrite first 32 byte slot in state for output (static test)", async () => {
@@ -113,0 +330,0 @@ let state = [

test/tuple.js

@@ -33,3 +33,3 @@ const { expect } = require("chai");
       [tupler, "extractElement", "0x008001ffffffff", "0x00"],
-      [multiReturn, "tupleConsumer", "0x0000ffffffffff", "0xff"],
+      [multiReturn, "tupleConsumer", "0x0000ffffffffff", "0xff"]
     ];
@@ -55,4 +55,4 @@
       [multiReturn, "intTuple", "0x80ffffffffffff", "0x00"],
-      [tupler, "extractElement", "0x008001ffffffff", "0x00"],
-      [multiReturn, "tupleConsumer", "0x0000ffffffffff", "0xff"],
+      [tupler, "extractElement","0x008001ffffffff", "0x00"],
+      [multiReturn, "tupleConsumer", "0x0000ffffffffff", "0xff"]
     ];
@@ -59,0 +59,0 @@

test/VM.js

@@ -24,2 +24,3 @@ const { expect } = require("chai");
     strings,
+    struct,
     stateTest,
@@ -37,2 +38,3 @@ sender,
     strings = await deployLibrary("Strings");
+    struct = await deployLibrary("Struct");
     sender = await deployLibrary("Sender");
@@ -350,2 +352,23 @@ revert = await deployLibrary("Revert");
 
+  it("Should pass return value to dynamic tuple", async () => {
+    const planner = new weiroll.Planner();
+    const result = planner.add(math.add(1, 2));
+    planner.add(struct.returnDynamicParamAndStruct("Test", { a: result, b: token.address}));
+    const {commands, state} = planner.plan();
+
+    const tx = await vm.execute(commands, state);
+    await expect(tx)
+      .to.emit(eventsContract.attach(vm.address), "LogString")
+      .withArgs("Test");
+    await expect(tx)
+      .to.emit(eventsContract.attach(vm.address), "LogUint")
+      .withArgs(3);
+    await expect(tx)
+      .to.emit(eventsContract.attach(vm.address), "LogAddress")
+      .withArgs(token.address);
+
+    const receipt = await tx.wait();
+    console.log(`dynamic param and struct: ${receipt.gasUsed.toNumber()} gas`);
+  });
+
   it("Should pass and return raw state to functions", async () => {
@@ -352,0 +375,0 @@ const commands = [

No alert changes

Improved metrics

Total package byte prevSize

67460

28.62%

Number of package files

28

12%

Lines of code

759

27.35%

No dependency changes