@hashgraphonline/standards-sdk 0.0.108-canary.1 → 0.0.109

package/dist/es/standards-sdk.es108.js

@@ -1,162 +1,35 @@
-import { assertArgument, assert } from "./standards-sdk.es92.js";
-const BN_0 = BigInt(0);
-const BN_1 = BigInt(1);
-const maxValue = 9007199254740991;
-function fromTwos(_value, _width) {
-  const value = getUint(_value, "value");
-  const width = BigInt(getNumber(_width, "width"));
-  assert(value >> width === BN_0, "overflow", "NUMERIC_FAULT", {
-    operation: "fromTwos",
-    fault: "overflow",
-    value: _value
-  });
-  if (value >> width - BN_1) {
-    const mask2 = (BN_1 << width) - BN_1;
-    return -((~value & mask2) + BN_1);
-  }
-  return value;
-}
-function toTwos(_value, _width) {
-  let value = getBigInt(_value, "value");
-  const width = BigInt(getNumber(_width, "width"));
-  const limit = BN_1 << width - BN_1;
-  if (value < BN_0) {
-    value = -value;
-    assert(value <= limit, "too low", "NUMERIC_FAULT", {
-      operation: "toTwos",
-      fault: "overflow",
-      value: _value
-    });
-    const mask2 = (BN_1 << width) - BN_1;
-    return (~value & mask2) + BN_1;
-  } else {
-    assert(value < limit, "too high", "NUMERIC_FAULT", {
-      operation: "toTwos",
-      fault: "overflow",
-      value: _value
-    });
-  }
-  return value;
-}
-function mask(_value, _bits) {
-  const value = getUint(_value, "value");
-  const bits = BigInt(getNumber(_bits, "bits"));
-  return value & (BN_1 << bits) - BN_1;
-}
-function getBigInt(value, name) {
-  switch (typeof value) {
-    case "bigint":
-      return value;
-    case "number":
-      assertArgument(Number.isInteger(value), "underflow", name || "value", value);
-      assertArgument(value >= -9007199254740991 && value <= maxValue, "overflow", name || "value", value);
-      return BigInt(value);
-    case "string":
-      try {
-        if (value === "") {
-          throw new Error("empty string");
+function checkType(value, type, name) {
+  const types = type.split("|").map((t) => t.trim());
+  for (let i = 0; i < types.length; i++) {
+    switch (type) {
+      case "any":
+        return;
+      case "bigint":
+      case "boolean":
+      case "number":
+      case "string":
+        if (typeof value === type) {
+          return;
         }
-        if (value[0] === "-" && value[1] !== "-") {
-          return -BigInt(value.substring(1));
-        }
-        return BigInt(value);
-      } catch (e) {
-        assertArgument(false, `invalid BigNumberish string: ${e.message}`, name || "value", value);
-      }
-  }
-  assertArgument(false, "invalid BigNumberish value", name || "value", value);
-}
-function getUint(value, name) {
-  const result = getBigInt(value, name);
-  assert(result >= BN_0, "unsigned value cannot be negative", "NUMERIC_FAULT", {
-    fault: "overflow",
-    operation: "getUint",
-    value
-  });
-  return result;
-}
-const Nibbles = "0123456789abcdef";
-function toBigInt(value) {
-  if (value instanceof Uint8Array) {
-    let result = "0x0";
-    for (const v of value) {
-      result += Nibbles[v >> 4];
-      result += Nibbles[v & 15];
     }
-    return BigInt(result);
   }
-  return getBigInt(value);
-}
-function getNumber(value, name) {
-  switch (typeof value) {
-    case "bigint":
-      assertArgument(value >= -9007199254740991 && value <= maxValue, "overflow", name || "value", value);
-      return Number(value);
-    case "number":
-      assertArgument(Number.isInteger(value), "underflow", name || "value", value);
-      assertArgument(value >= -9007199254740991 && value <= maxValue, "overflow", name || "value", value);
-      return value;
-    case "string":
-      try {
-        if (value === "") {
-          throw new Error("empty string");
-        }
-        return getNumber(BigInt(value), name);
-      } catch (e) {
-        assertArgument(false, `invalid numeric string: ${e.message}`, name || "value", value);
-      }
-  }
-  assertArgument(false, "invalid numeric value", name || "value", value);
-}
-function toNumber(value) {
-  return getNumber(toBigInt(value));
-}
-function toBeHex(_value, _width) {
-  const value = getUint(_value, "value");
-  let result = value.toString(16);
-  if (_width == null) {
-    if (result.length % 2) {
-      result = "0" + result;
-    }
-  } else {
-    const width = getNumber(_width, "width");
-    assert(width * 2 >= result.length, `value exceeds width (${width} bytes)`, "NUMERIC_FAULT", {
-      operation: "toBeHex",
-      fault: "overflow",
-      value: _value
-    });
-    while (result.length < width * 2) {
-      result = "0" + result;
+  const error = new Error(`invalid value for type ${type}`);
+  error.code = "INVALID_ARGUMENT";
+  error.argument = `value.${name}`;
+  error.value = value;
+  throw error;
+}
+function defineProperties(target, values, types) {
+  for (let key in values) {
+    let value = values[key];
+    const type = types ? types[key] : null;
+    if (type) {
+      checkType(value, type, key);
     }
+    Object.defineProperty(target, key, { enumerable: true, value, writable: false });
   }
-  return "0x" + result;
-}
-function toBeArray(_value) {
-  const value = getUint(_value, "value");
-  if (value === BN_0) {
-    return new Uint8Array([]);
-  }
-  let hex = value.toString(16);
-  if (hex.length % 2) {
-    hex = "0" + hex;
-  }
-  const result = new Uint8Array(hex.length / 2);
-  for (let i = 0; i < result.length; i++) {
-    const offset = i * 2;
-    result[i] = parseInt(hex.substring(offset, offset + 2), 16);
-  }
-  return result;
 }
 export {
-  fromTwos,
-  getBigInt,
-  getNumber,
-  getUint,
-  mask,
-  toBeArray,
-  toBeHex,
-  toBigInt,
-  toNumber,
-  toTwos
+  defineProperties
 };
 //# sourceMappingURL=standards-sdk.es108.js.map

package/dist/es/standards-sdk.es108.js.map

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es108.js","sources":["../../node_modules/ethers/lib.esm/utils/maths.js"],"sourcesContent":["/**\n *  Some mathematic operations.\n *\n *  @_subsection: api/utils:Math Helpers  [about-maths]\n */\nimport { hexlify, isBytesLike } from \"./data.js\";\nimport { assert, assertArgument } from \"./errors.js\";\nconst BN_0 = BigInt(0);\nconst BN_1 = BigInt(1);\n//const BN_Max256 = (BN_1 << BigInt(256)) - BN_1;\n// IEEE 754 support 53-bits of mantissa\nconst maxValue = 0x1fffffffffffff;\n/**\n *  Convert %%value%% from a twos-compliment representation of %%width%%\n *  bits to its value.\n *\n *  If the highest bit is ``1``, the result will be negative.\n */\nexport function fromTwos(_value, _width) {\n    const value = getUint(_value, \"value\");\n    const width = BigInt(getNumber(_width, \"width\"));\n    assert((value >> width) === BN_0, \"overflow\", \"NUMERIC_FAULT\", {\n        operation: \"fromTwos\", fault: \"overflow\", value: _value\n    });\n    // Top bit set; treat as a negative value\n    if (value >> (width - BN_1)) {\n        const mask = (BN_1 << width) - BN_1;\n        return -(((~value) & mask) + BN_1);\n    }\n    return value;\n}\n/**\n *  Convert %%value%% to a twos-compliment representation of\n *  %%width%% bits.\n *\n *  The result will always be positive.\n */\nexport function toTwos(_value, _width) {\n    let value = getBigInt(_value, \"value\");\n    const width = BigInt(getNumber(_width, \"width\"));\n    const limit = (BN_1 << (width - BN_1));\n    if (value < BN_0) {\n        value = -value;\n        assert(value <= limit, \"too low\", \"NUMERIC_FAULT\", {\n            operation: \"toTwos\", fault: \"overflow\", value: _value\n        });\n        const mask = (BN_1 << width) - BN_1;\n        return ((~value) & mask) + BN_1;\n    }\n    else {\n        assert(value < limit, \"too high\", \"NUMERIC_FAULT\", {\n            operation: \"toTwos\", fault: \"overflow\", value: _value\n        });\n    }\n    return value;\n}\n/**\n *  Mask %%value%% with a bitmask of %%bits%% ones.\n */\nexport function mask(_value, _bits) {\n    const value = getUint(_value, \"value\");\n    const bits = BigInt(getNumber(_bits, \"bits\"));\n    return value & ((BN_1 << bits) - BN_1);\n}\n/**\n *  Gets a BigInt from %%value%%. If it is an invalid value for\n *  a BigInt, then an ArgumentError will be thrown for %%name%%.\n */\nexport function getBigInt(value, name) {\n    switch (typeof (value)) {\n        case \"bigint\": return value;\n        case \"number\":\n            assertArgument(Number.isInteger(value), \"underflow\", name || \"value\", value);\n            assertArgument(value >= -maxValue && value <= maxValue, \"overflow\", name || \"value\", value);\n            return BigInt(value);\n        case \"string\":\n            try {\n                if (value === \"\") {\n                    throw new Error(\"empty string\");\n                }\n                if (value[0] === \"-\" && value[1] !== \"-\") {\n                    return -BigInt(value.substring(1));\n                }\n                return BigInt(value);\n            }\n            catch (e) {\n                assertArgument(false, `invalid BigNumberish string: ${e.message}`, name || \"value\", value);\n            }\n    }\n    assertArgument(false, \"invalid BigNumberish value\", name || \"value\", value);\n}\n/**\n *  Returns %%value%% as a bigint, validating it is valid as a bigint\n *  value and that it is positive.\n */\nexport function getUint(value, name) {\n    const result = getBigInt(value, name);\n    assert(result >= BN_0, \"unsigned value cannot be negative\", \"NUMERIC_FAULT\", {\n        fault: \"overflow\", operation: \"getUint\", value\n    });\n    return result;\n}\nconst Nibbles = \"0123456789abcdef\";\n/*\n * Converts %%value%% to a BigInt. If %%value%% is a Uint8Array, it\n * is treated as Big Endian data.\n */\nexport function toBigInt(value) {\n    if (value instanceof Uint8Array) {\n        let result = \"0x0\";\n        for (const v of value) {\n            result += Nibbles[v >> 4];\n            result += Nibbles[v & 0x0f];\n        }\n        return BigInt(result);\n    }\n    return getBigInt(value);\n}\n/**\n *  Gets a //number// from %%value%%. If it is an invalid value for\n *  a //number//, then an ArgumentError will be thrown for %%name%%.\n */\nexport function getNumber(value, name) {\n    switch (typeof (value)) {\n        case \"bigint\":\n            assertArgument(value >= -maxValue && value <= maxValue, \"overflow\", name || \"value\", value);\n            return Number(value);\n        case \"number\":\n            assertArgument(Number.isInteger(value), \"underflow\", name || \"value\", value);\n            assertArgument(value >= -maxValue && value <= maxValue, \"overflow\", name || \"value\", value);\n            return value;\n        case \"string\":\n            try {\n                if (value === \"\") {\n                    throw new Error(\"empty string\");\n                }\n                return getNumber(BigInt(value), name);\n            }\n            catch (e) {\n                assertArgument(false, `invalid numeric string: ${e.message}`, name || \"value\", value);\n            }\n    }\n    assertArgument(false, \"invalid numeric value\", name || \"value\", value);\n}\n/**\n *  Converts %%value%% to a number. If %%value%% is a Uint8Array, it\n *  is treated as Big Endian data. Throws if the value is not safe.\n */\nexport function toNumber(value) {\n    return getNumber(toBigInt(value));\n}\n/**\n *  Converts %%value%% to a Big Endian hexstring, optionally padded to\n *  %%width%% bytes.\n */\nexport function toBeHex(_value, _width) {\n    const value = getUint(_value, \"value\");\n    let result = value.toString(16);\n    if (_width == null) {\n        // Ensure the value is of even length\n        if (result.length % 2) {\n            result = \"0\" + result;\n        }\n    }\n    else {\n        const width = getNumber(_width, \"width\");\n        assert(width * 2 >= result.length, `value exceeds width (${width} bytes)`, \"NUMERIC_FAULT\", {\n            operation: \"toBeHex\",\n            fault: \"overflow\",\n            value: _value\n        });\n        // Pad the value to the required width\n        while (result.length < (width * 2)) {\n            result = \"0\" + result;\n        }\n    }\n    return \"0x\" + result;\n}\n/**\n *  Converts %%value%% to a Big Endian Uint8Array.\n */\nexport function toBeArray(_value) {\n    const value = getUint(_value, \"value\");\n    if (value === BN_0) {\n        return new Uint8Array([]);\n    }\n    let hex = value.toString(16);\n    if (hex.length % 2) {\n        hex = \"0\" + hex;\n    }\n    const result = new Uint8Array(hex.length / 2);\n    for (let i = 0; i < result.length; i++) {\n        const offset = i * 2;\n        result[i] = parseInt(hex.substring(offset, offset + 2), 16);\n    }\n    return result;\n}\n/**\n *  Returns a [[HexString]] for %%value%% safe to use as a //Quantity//.\n *\n *  A //Quantity// does not have and leading 0 values unless the value is\n *  the literal value `0x0`. This is most commonly used for JSSON-RPC\n *  numeric values.\n */\nexport function toQuantity(value) {\n    let result = hexlify(isBytesLike(value) ? value : toBeArray(value)).substring(2);\n    while (result.startsWith(\"0\")) {\n        result = result.substring(1);\n    }\n    if (result === \"\") {\n        result = \"0\";\n    }\n    return \"0x\" + result;\n}\n//# sourceMappingURL=maths.js.map"],"names":["mask"],"mappings":"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","x_google_ignoreList":[0]}
+{"version":3,"file":"standards-sdk.es108.js","sources":["../../node_modules/ethers/lib.esm/utils/properties.js"],"sourcesContent":["/**\n *  Property helper functions.\n *\n *  @_subsection api/utils:Properties  [about-properties]\n */\nfunction checkType(value, type, name) {\n    const types = type.split(\"|\").map(t => t.trim());\n    for (let i = 0; i < types.length; i++) {\n        switch (type) {\n            case \"any\":\n                return;\n            case \"bigint\":\n            case \"boolean\":\n            case \"number\":\n            case \"string\":\n                if (typeof (value) === type) {\n                    return;\n                }\n        }\n    }\n    const error = new Error(`invalid value for type ${type}`);\n    error.code = \"INVALID_ARGUMENT\";\n    error.argument = `value.${name}`;\n    error.value = value;\n    throw error;\n}\n/**\n *  Resolves to a new object that is a copy of %%value%%, but with all\n *  values resolved.\n */\nexport async function resolveProperties(value) {\n    const keys = Object.keys(value);\n    const results = await Promise.all(keys.map((k) => Promise.resolve(value[k])));\n    return results.reduce((accum, v, index) => {\n        accum[keys[index]] = v;\n        return accum;\n    }, {});\n}\n/**\n *  Assigns the %%values%% to %%target%% as read-only values.\n *\n *  It %%types%% is specified, the values are checked.\n */\nexport function defineProperties(target, values, types) {\n    for (let key in values) {\n        let value = values[key];\n        const type = (types ? types[key] : null);\n        if (type) {\n            checkType(value, type, key);\n        }\n        Object.defineProperty(target, key, { enumerable: true, value, writable: false });\n    }\n}\n//# sourceMappingURL=properties.js.map"],"names":[],"mappings":"AAKA,SAAS,UAAU,OAAO,MAAM,MAAM;AAClC,QAAM,QAAQ,KAAK,MAAM,GAAG,EAAE,IAAI,OAAK,EAAE,MAAM;AAC/C,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACnC,YAAQ,MAAI;AAAA,MACR,KAAK;AACD;AAAA,MACJ,KAAK;AAAA,MACL,KAAK;AAAA,MACL,KAAK;AAAA,MACL,KAAK;AACD,YAAI,OAAQ,UAAW,MAAM;AACzB;AAAA,QACpB;AAAA,IACA;AAAA,EACA;AACI,QAAM,QAAQ,IAAI,MAAM,0BAA0B,IAAI,EAAE;AACxD,QAAM,OAAO;AACb,QAAM,WAAW,SAAS,IAAI;AAC9B,QAAM,QAAQ;AACd,QAAM;AACV;AAkBO,SAAS,iBAAiB,QAAQ,QAAQ,OAAO;AACpD,WAAS,OAAO,QAAQ;AACpB,QAAI,QAAQ,OAAO,GAAG;AACtB,UAAM,OAAQ,QAAQ,MAAM,GAAG,IAAI;AACnC,QAAI,MAAM;AACN,gBAAU,OAAO,MAAM,GAAG;AAAA,IACtC;AACQ,WAAO,eAAe,QAAQ,KAAK,EAAE,YAAY,MAAM,OAAO,UAAU,OAAO;AAAA,EACvF;AACA;","x_google_ignoreList":[0]}