Adapt xcm-utils to XCM V3

tests/package.json

@@ -61,7 +61,7 @@
   "license": "ISC",
   "dependencies": {
     "@metamask/eth-sig-util": "^4.0.1",
-    "@moonbeam-network/api-augment": "^0.2201.0",
+    "@moonbeam-network/api-augment": "^0.2301.0",
     "@openzeppelin/contracts": "^4.8.2",
     "@polkadot/api": "^10.1.4",
     "@polkadot/api-augment": "^10.1.4",

tests/tests/test-precompile/test-precompile-xcm-transactor.ts

@@ -43,7 +43,7 @@ const registerXcmTransactorAndContract = async (context: DevTestContext) => {
       context.polkadotApi.tx.xcmTransactor.setTransactInfo(
         RELAY_V3_SOURCE_LOCATION,
         { refTime: 1, proofSize: 64 * 1024 } as any,
-        { refTime: 20000000000, proofSize: 256 * 1024 } as any,
+        { refTime: 20_000_000_000, proofSize: 256 * 1024 } as any,
         { refTime: 1, proofSize: 64 * 1024 } as any
       )
     )

tests/tests/test-xcm/test-xcmv3-max-weight-instructions.ts

@@ -0,0 +1,222 @@
+import "@moonbeam-network/api-augment";
+import { expect } from "chai";
+import { CHARLETH_ADDRESS } from "../../util/accounts";
+import { describeDevMoonbeam } from "../../util/setup-dev-tests";
+import {
+  XcmFragment,
+  injectHrmpMessage,
+  RawXcmMessage,
+  sovereignAccountOfSibling,
+} from "../../util/xcm";
+import { expectEVMResult } from "../../util/eth-transactions";
+import { ALITH_TRANSACTION_TEMPLATE, createTransaction } from "../../util/transactions";
+
+describeDevMoonbeam(
+  "XCM V3 - Max Weight Instructions",
+  (context) => {
+    let dotAsset: any;
+    let amount: bigint;
+    let paraId: number;
+
+    before("Set up initial constants", async function () {
+      paraId = 888;
+      const paraSovereign = sovereignAccountOfSibling(context, paraId);
+      const metadata = await context.polkadotApi.rpc.state.getMetadata();
+      const balancesPalletIndex = (metadata.asLatest.toHuman().pallets as Array<any>).find(
+        (pallet) => pallet.name === "Balances"
+      ).index;
+
+      // Send some native tokens to the sovereign account of paraId (to pay fees)
+      const { result } = await context.createBlock(
+        createTransaction(context, {
+          ...ALITH_TRANSACTION_TEMPLATE,
+          value: 1_000_000_000_000_000_000,
+          to: paraSovereign,
+          data: "0x",
+        })
+      );
+      expectEVMResult(result.events, "Succeed");
+
+      amount = 1_000_000_000_000_000n;
+      dotAsset = {
+        assets: [
+          {
+            multilocation: {
+              parents: 0,
+              interior: {
+                X1: { PalletInstance: balancesPalletIndex },
+              },
+            },
+            fungible: amount,
+          },
+        ],
+        // weight_limit: new BN(4000000000),
+        beneficiary: CHARLETH_ADDRESS,
+      };
+    });
+
+    // WEIGHT::MAX instructions
+    it("Should not execute UniversalOrigin", async function () {
+      const xcmMessage = new XcmFragment(dotAsset)
+        .withdraw_asset()
+        .buy_execution()
+        .universal_origin({ Parachain: paraId })
+        .as_v3();
+
+      // Mock the reception of the xcm message
+      await injectHrmpMessage(context, paraId, {
+        type: "XcmVersionedXcm",
+        payload: xcmMessage,
+      } as RawXcmMessage);
+      await context.createBlock();
+
+      // Search for WeightNotComputable error
+      const records = (await context.polkadotApi.query.system.events()) as any;
+      const events = records.filter(
+        ({ event }) => event.section == "xcmpQueue" && event.method == "Fail"
+      );
+      expect(events).to.have.lengthOf(1);
+      expect(events[0].toHuman().event.data.error).equals("WeightNotComputable");
+    });
+
+    it("Should not execute ExportMessage", async function () {
+      const xcmMessage = new XcmFragment(dotAsset)
+        .withdraw_asset()
+        .buy_execution()
+        .export_message("Ethereum", 1, [1, 2, 3])
+        .as_v3();
+
+      // Mock the reception of the xcm message
+      await injectHrmpMessage(context, paraId, {
+        type: "XcmVersionedXcm",
+        payload: xcmMessage,
+      } as RawXcmMessage);
+      await context.createBlock();
+
+      // Search for WeightNotComputable error
+      const records = (await context.polkadotApi.query.system.events()) as any;
+      const events = records.filter(
+        ({ event }) => event.section == "xcmpQueue" && event.method == "Fail"
+      );
+      expect(events).to.have.lengthOf(1);
+      expect(events[0].toHuman().event.data.error).equals("WeightNotComputable");
+    });
+
+    it("Should not execute LockAsset", async function () {
+      const xcmMessage = new XcmFragment(dotAsset)
+        .withdraw_asset()
+        .buy_execution()
+        .lock_asset(0, 1)
+        .as_v3();
+
+      // Mock the reception of the xcm message
+      await injectHrmpMessage(context, paraId, {
+        type: "XcmVersionedXcm",
+        payload: xcmMessage,
+      } as RawXcmMessage);
+      await context.createBlock();
+
+      // Search for WeightNotComputable error
+      const records = (await context.polkadotApi.query.system.events()) as any;
+      const events = records.filter(
+        ({ event }) => event.section == "xcmpQueue" && event.method == "Fail"
+      );
+      expect(events).to.have.lengthOf(1);
+      expect(events[0].toHuman().event.data.error).equals("WeightNotComputable");
+    });
+
+    it("Should not execute UnlockAsset", async function () {
+      const xcmMessage = new XcmFragment(dotAsset)
+        .withdraw_asset()
+        .buy_execution()
+        .unlock_asset()
+        .as_v3();
+
+      // Mock the reception of the xcm message
+      await injectHrmpMessage(context, paraId, {
+        type: "XcmVersionedXcm",
+        payload: xcmMessage,
+      } as RawXcmMessage);
+      await context.createBlock();
+
+      // Search for WeightNotComputable error
+      const records = (await context.polkadotApi.query.system.events()) as any;
+      const events = records.filter(
+        ({ event }) => event.section == "xcmpQueue" && event.method == "Fail"
+      );
+      expect(events).to.have.lengthOf(1);
+      expect(events[0].toHuman().event.data.error).equals("WeightNotComputable");
+    });
+
+    it("Should not execute NoteUnlockable", async function () {
+      const xcmMessage = new XcmFragment(dotAsset)
+        .withdraw_asset()
+        .buy_execution()
+        .note_unlockable()
+        .as_v3();
+
+      // Mock the reception of the xcm message
+      await injectHrmpMessage(context, paraId, {
+        type: "XcmVersionedXcm",
+        payload: xcmMessage,
+      } as RawXcmMessage);
+      await context.createBlock();
+
+      // Search for WeightNotComputable error
+      const records = (await context.polkadotApi.query.system.events()) as any;
+      const events = records.filter(
+        ({ event }) => event.section == "xcmpQueue" && event.method == "Fail"
+      );
+      expect(events).to.have.lengthOf(1);
+      expect(events[0].toHuman().event.data.error).equals("WeightNotComputable");
+    });
+
+    it("Should not execute RequestUnlock", async function () {
+      const xcmMessage = new XcmFragment(dotAsset)
+        .withdraw_asset()
+        .buy_execution()
+        .request_unlock()
+        .as_v3();
+
+      // Mock the reception of the xcm message
+      await injectHrmpMessage(context, paraId, {
+        type: "XcmVersionedXcm",
+        payload: xcmMessage,
+      } as RawXcmMessage);
+      await context.createBlock();
+
+      // Search for WeightNotComputable error
+      const records = (await context.polkadotApi.query.system.events()) as any;
+      const events = records.filter(
+        ({ event }) => event.section == "xcmpQueue" && event.method == "Fail"
+      );
+      expect(events).to.have.lengthOf(1);
+      expect(events[0].toHuman().event.data.error).equals("WeightNotComputable");
+    });
+
+    it("Should not execute AliasOrigin", async function () {
+      const xcmMessage = new XcmFragment(dotAsset)
+        .withdraw_asset()
+        .buy_execution()
+        .alias_origin(1)
+        .as_v3();
+
+      // Mock the reception of the xcm message
+      await injectHrmpMessage(context, paraId, {
+        type: "XcmVersionedXcm",
+        payload: xcmMessage,
+      } as RawXcmMessage);
+      await context.createBlock();
+
+      // Search for WeightNotComputable error
+      const records = (await context.polkadotApi.query.system.events()) as any;
+      const events = records.filter(
+        ({ event }) => event.section == "xcmpQueue" && event.method == "Fail"
+      );
+      expect(events).to.have.lengthOf(1);
+      expect(events[0].toHuman().event.data.error).equals("WeightNotComputable");
+    });
+  },
+  "Legacy",
+  "moonbase"
+);