Merge pull request #5153 from ItsNickBarry/task-type-bigint

Add `BigInt` task argument type

Author: alcuadrado

.changeset/clever-peaches-obey.md

@@ -0,0 +1,5 @@
+---
+"hardhat": minor
+---
+
+Added BigInt task argument type

packages/hardhat-core/src/internal/core/params/argumentTypes.ts

@@ -121,6 +121,50 @@ export const int: CLIArgumentType<number> = {
   },
 };
 
+/**
+ * BigInt type.
+ * Accepts either a decimal string integer or hexadecimal string integer.
+ * @throws HH301
+ */
+export const bigint: CLIArgumentType<bigint> = {
+  name: "bigint",
+  parse: (argName, strValue) => {
+    const decimalPattern = /^\d+(?:n)?$/;
+    const hexPattern = /^0[xX][\dABCDEabcde]+$/;
+
+    if (
+      strValue.match(decimalPattern) === null &&
+      strValue.match(hexPattern) === null
+    ) {
+      throw new HardhatError(ERRORS.ARGUMENTS.INVALID_VALUE_FOR_TYPE, {
+        value: strValue,
+        name: argName,
+        type: bigint.name,
+      });
+    }
+
+    return BigInt(strValue.replace("n", ""));
+  },
+  /**
+   * Check if argument value is of type "bigint".
+   *
+   * @param argName {string} argument's name - used for context in case of error.
+   * @param value {any} argument's value to validate.
+   *
+   * @throws HH301 if value is not of type "bigint"
+   */
+  validate: (argName: string, value: any): void => {
+    const isBigInt = typeof value === "bigint";
+    if (!isBigInt) {
+      throw new HardhatError(ERRORS.ARGUMENTS.INVALID_VALUE_FOR_TYPE, {
+        value,
+        name: argName,
+        type: bigint.name,
+      });
+    }
+  },
+};
+
 /**
  * Float type.
  * Accepts either a decimal string number or hexadecimal string number.

packages/hardhat-core/test/internal/core/params/argumentTypes.ts

@@ -127,6 +127,82 @@ describe("argumentTypes", () => {
     });
   });
 
+  describe("bigint type", () => {
+    it("should work with decimal values", () => {
+      assert.equal(types.bigint.parse("arg", "0"), 0n);
+      assert.equal(types.bigint.parse("arg", "1"), 1n);
+      assert.equal(types.bigint.parse("arg", "1123"), 1123n);
+      assert.equal(types.bigint.parse("arg", "05678"), 5678n);
+      assert.equal(
+        types.bigint.parse("arg", "9007199254740992"),
+        BigInt("9007199254740992")
+      );
+    });
+
+    it("should work with hex values", () => {
+      assert.equal(types.bigint.parse("arg", "0x0"), BigInt(0));
+      assert.equal(types.bigint.parse("arg", "0x1"), BigInt(1));
+      assert.equal(types.bigint.parse("arg", "0xA"), BigInt(0xa));
+      assert.equal(types.bigint.parse("arg", "0xa"), BigInt(0xa));
+      assert.equal(types.bigint.parse("arg", "0x0a"), BigInt(0x0a));
+      assert.equal(
+        types.bigint.parse("arg", "0x20000000000000"),
+        BigInt("0x20000000000000")
+      );
+    });
+
+    it("should work with bigint values with 'n' suffix", () => {
+      assert.equal(types.bigint.parse("arg", "0n"), BigInt(0));
+    });
+
+    it("should fail with incorrect values", () => {
+      expectHardhatError(
+        () => types.bigint.parse("arg", ""),
+        ERRORS.ARGUMENTS.INVALID_VALUE_FOR_TYPE
+      );
+      expectHardhatError(
+        () => types.bigint.parse("arg", "1."),
+        ERRORS.ARGUMENTS.INVALID_VALUE_FOR_TYPE
+      );
+      expectHardhatError(
+        () => types.bigint.parse("arg", ".1"),
+        ERRORS.ARGUMENTS.INVALID_VALUE_FOR_TYPE
+      );
+      expectHardhatError(
+        () => types.bigint.parse("arg", "0.1"),
+        ERRORS.ARGUMENTS.INVALID_VALUE_FOR_TYPE
+      );
+      expectHardhatError(
+        () => types.bigint.parse("arg", "asdas"),
+        ERRORS.ARGUMENTS.INVALID_VALUE_FOR_TYPE
+      );
+      expectHardhatError(
+        () => types.bigint.parse("arg", "a1"),
+        ERRORS.ARGUMENTS.INVALID_VALUE_FOR_TYPE
+      );
+      expectHardhatError(
+        () => types.bigint.parse("arg", "1a"),
+        ERRORS.ARGUMENTS.INVALID_VALUE_FOR_TYPE
+      );
+      expectHardhatError(
+        () => types.bigint.parse("arg", "1 1"),
+        ERRORS.ARGUMENTS.INVALID_VALUE_FOR_TYPE
+      );
+      expectHardhatError(
+        () => types.bigint.parse("arg", "x123"),
+        ERRORS.ARGUMENTS.INVALID_VALUE_FOR_TYPE
+      );
+      expectHardhatError(
+        () => types.bigint.parse("arg", "1e0"),
+        ERRORS.ARGUMENTS.INVALID_VALUE_FOR_TYPE
+      );
+      expectHardhatError(
+        () => types.bigint.parse("arg", "0x0n"),
+        ERRORS.ARGUMENTS.INVALID_VALUE_FOR_TYPE
+      );
+    });
+  });
+
   describe("float type", () => {
     it("should work with integer decimal values", () => {
       assert.equal(types.float.parse("arg", "0"), 0);