starknet 6.9.0 → 6.10.1

package/dist/utils/calldata/responseParser.mjs

@@ -0,0 +1,201 @@
+import { CairoUint256 } from "../cairoDataTypes/uint256.mjs";
+import { CairoUint512 } from "../cairoDataTypes/uint512.mjs";
+import { addHexPrefix, removeHexPrefix } from "../encode.mjs";
+import { toHex } from "../num.mjs";
+import { decodeShortString } from "../shortString.mjs";
+import { stringFromByteArray } from "./byteArray.mjs";
+import {
+  getArrayType,
+  isCairo1Type,
+  isLen,
+  isTypeArray,
+  isTypeBool,
+  isTypeByteArray,
+  isTypeEnum,
+  isTypeNonZero,
+  isTypeSecp256k1Point,
+  isTypeTuple
+} from "./cairo.mjs";
+import {
+  CairoCustomEnum,
+  CairoOption,
+  CairoOptionVariant,
+  CairoResult,
+  CairoResultVariant
+} from "./enum/index.mjs";
+import extractTupleMemberTypes from "./tuple.mjs";
+function parseBaseTypes(type, it) {
+  let temp;
+  switch (true) {
+    case isTypeBool(type):
+      temp = it.next().value;
+      return Boolean(BigInt(temp));
+    case CairoUint256.isAbiType(type):
+      const low = it.next().value;
+      const high = it.next().value;
+      return new CairoUint256(low, high).toBigInt();
+    case CairoUint512.isAbiType(type):
+      const limb0 = it.next().value;
+      const limb1 = it.next().value;
+      const limb2 = it.next().value;
+      const limb3 = it.next().value;
+      return new CairoUint512(limb0, limb1, limb2, limb3).toBigInt();
+    case type === "core::starknet::eth_address::EthAddress":
+      temp = it.next().value;
+      return BigInt(temp);
+    case type === "core::bytes_31::bytes31":
+      temp = it.next().value;
+      return decodeShortString(temp);
+    case isTypeSecp256k1Point(type):
+      const xLow = removeHexPrefix(it.next().value).padStart(32, "0");
+      const xHigh = removeHexPrefix(it.next().value).padStart(32, "0");
+      const yLow = removeHexPrefix(it.next().value).padStart(32, "0");
+      const yHigh = removeHexPrefix(it.next().value).padStart(32, "0");
+      const pubK = BigInt(addHexPrefix(xHigh + xLow + yHigh + yLow));
+      return pubK;
+    default:
+      temp = it.next().value;
+      return BigInt(temp);
+  }
+}
+function parseResponseValue(responseIterator, element, structs, enums) {
+  if (element.type === "()") {
+    return {};
+  }
+  if (CairoUint256.isAbiType(element.type)) {
+    const low = responseIterator.next().value;
+    const high = responseIterator.next().value;
+    return new CairoUint256(low, high).toBigInt();
+  }
+  if (CairoUint512.isAbiType(element.type)) {
+    const limb0 = responseIterator.next().value;
+    const limb1 = responseIterator.next().value;
+    const limb2 = responseIterator.next().value;
+    const limb3 = responseIterator.next().value;
+    return new CairoUint512(limb0, limb1, limb2, limb3).toBigInt();
+  }
+  if (isTypeByteArray(element.type)) {
+    const parsedBytes31Arr = [];
+    const bytes31ArrLen = BigInt(responseIterator.next().value);
+    while (parsedBytes31Arr.length < bytes31ArrLen) {
+      parsedBytes31Arr.push(toHex(responseIterator.next().value));
+    }
+    const pending_word = toHex(responseIterator.next().value);
+    const pending_word_len = BigInt(responseIterator.next().value);
+    const myByteArray = {
+      data: parsedBytes31Arr,
+      pending_word,
+      pending_word_len
+    };
+    return stringFromByteArray(myByteArray);
+  }
+  if (isTypeArray(element.type)) {
+    const parsedDataArr = [];
+    const el = { name: "", type: getArrayType(element.type) };
+    const len = BigInt(responseIterator.next().value);
+    while (parsedDataArr.length < len) {
+      parsedDataArr.push(parseResponseValue(responseIterator, el, structs, enums));
+    }
+    return parsedDataArr;
+  }
+  if (isTypeNonZero(element.type)) {
+    const el = { name: "", type: getArrayType(element.type) };
+    return parseResponseValue(responseIterator, el, structs, enums);
+  }
+  if (structs && element.type in structs && structs[element.type]) {
+    if (element.type === "core::starknet::eth_address::EthAddress") {
+      return parseBaseTypes(element.type, responseIterator);
+    }
+    return structs[element.type].members.reduce((acc, el) => {
+      acc[el.name] = parseResponseValue(responseIterator, el, structs, enums);
+      return acc;
+    }, {});
+  }
+  if (enums && element.type in enums && enums[element.type]) {
+    const variantNum = Number(responseIterator.next().value);
+    const rawEnum = enums[element.type].variants.reduce((acc, variant, num) => {
+      if (num === variantNum) {
+        acc[variant.name] = parseResponseValue(
+          responseIterator,
+          { name: "", type: variant.type },
+          structs,
+          enums
+        );
+        return acc;
+      }
+      acc[variant.name] = void 0;
+      return acc;
+    }, {});
+    if (element.type.startsWith("core::option::Option")) {
+      const content = variantNum === CairoOptionVariant.Some ? rawEnum.Some : void 0;
+      return new CairoOption(variantNum, content);
+    }
+    if (element.type.startsWith("core::result::Result")) {
+      let content;
+      if (variantNum === CairoResultVariant.Ok) {
+        content = rawEnum.Ok;
+      } else {
+        content = rawEnum.Err;
+      }
+      return new CairoResult(variantNum, content);
+    }
+    const customEnum = new CairoCustomEnum(rawEnum);
+    return customEnum;
+  }
+  if (isTypeTuple(element.type)) {
+    const memberTypes = extractTupleMemberTypes(element.type);
+    return memberTypes.reduce((acc, it, idx) => {
+      const name = it?.name ? it.name : idx;
+      const type = it?.type ? it.type : it;
+      const el = { name, type };
+      acc[name] = parseResponseValue(responseIterator, el, structs, enums);
+      return acc;
+    }, {});
+  }
+  if (isTypeArray(element.type)) {
+    const parsedDataArr = [];
+    const el = { name: "", type: getArrayType(element.type) };
+    const len = BigInt(responseIterator.next().value);
+    while (parsedDataArr.length < len) {
+      parsedDataArr.push(parseResponseValue(responseIterator, el, structs, enums));
+    }
+    return parsedDataArr;
+  }
+  return parseBaseTypes(element.type, responseIterator);
+}
+export default function responseParser(responseIterator, output, structs, enums, parsedResult) {
+  const { name, type } = output;
+  let temp;
+  switch (true) {
+    case isLen(name):
+      temp = responseIterator.next().value;
+      return BigInt(temp);
+    case (structs && type in structs || isTypeTuple(type)):
+      return parseResponseValue(responseIterator, output, structs, enums);
+    case (enums && isTypeEnum(type, enums)):
+      return parseResponseValue(responseIterator, output, structs, enums);
+    case isTypeArray(type):
+      if (isCairo1Type(type)) {
+        return parseResponseValue(responseIterator, output, structs, enums);
+      }
+      const parsedDataArr = [];
+      if (parsedResult && parsedResult[`${name}_len`]) {
+        const arrLen = parsedResult[`${name}_len`];
+        while (parsedDataArr.length < arrLen) {
+          parsedDataArr.push(
+            parseResponseValue(
+              responseIterator,
+              { name, type: output.type.replace("*", "") },
+              structs,
+              enums
+            )
+          );
+        }
+      }
+      return parsedDataArr;
+    case isTypeNonZero(type):
+      return parseResponseValue(responseIterator, output, structs, enums);
+    default:
+      return parseBaseTypes(type, responseIterator);
+  }
+}

package/dist/utils/calldata/tuple.cjs

@@ -0,0 +1,106 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+module.exports = extractTupleMemberTypes;
+var _cairo = require("./cairo.cjs");
+function parseNamedTuple(namedTuple) {
+  const name = namedTuple.substring(0, namedTuple.indexOf(":"));
+  const type = namedTuple.substring(name.length + ":".length);
+  return {
+    name,
+    type
+  };
+}
+function parseSubTuple(s) {
+  if (!s.includes("(")) return {
+    subTuple: [],
+    result: s
+  };
+  const subTuple = [];
+  let result = "";
+  let i = 0;
+  while (i < s.length) {
+    if (s[i] === "(") {
+      let counter = 1;
+      const lBracket = i;
+      i++;
+      while (counter) {
+        if (s[i] === ")") counter--;
+        if (s[i] === "(") counter++;
+        i++;
+      }
+      subTuple.push(s.substring(lBracket, i));
+      result += " ";
+      i--;
+    } else {
+      result += s[i];
+    }
+    i++;
+  }
+  return {
+    subTuple,
+    result
+  };
+}
+function extractCairo0Tuple(type) {
+  const cleanType = type.replace(/\s/g, "").slice(1, -1);
+  const {
+    subTuple,
+    result
+  } = parseSubTuple(cleanType);
+  let recomposed = result.split(",").map(it => {
+    return subTuple.length ? it.replace(" ", subTuple.shift()) : it;
+  });
+  if ((0, _cairo.isTypeNamedTuple)(type)) {
+    recomposed = recomposed.reduce((acc, it) => {
+      return acc.concat(parseNamedTuple(it));
+    }, []);
+  }
+  return recomposed;
+}
+function getClosureOffset(input, open, close) {
+  for (let i = 0, counter = 0; i < input.length; i++) {
+    if (input[i] === open) {
+      counter++;
+    } else if (input[i] === close && --counter === 0) {
+      return i;
+    }
+  }
+  return Number.POSITIVE_INFINITY;
+}
+function extractCairo1Tuple(type) {
+  const input = type.slice(1, -1);
+  const result = [];
+  let currentIndex = 0;
+  let limitIndex;
+  while (currentIndex < input.length) {
+    switch (true) {
+      case input[currentIndex] === "(":
+        {
+          limitIndex = currentIndex + getClosureOffset(input.slice(currentIndex), "(", ")") + 1;
+          break;
+        }
+      case input.startsWith("core::result::Result::<", currentIndex) || input.startsWith("core::array::Array::<", currentIndex) || input.startsWith("core::option::Option::<", currentIndex):
+        {
+          limitIndex = currentIndex + getClosureOffset(input.slice(currentIndex), "<", ">") + 1;
+          break;
+        }
+      default:
+        {
+          const commaIndex = input.indexOf(",", currentIndex);
+          limitIndex = commaIndex !== -1 ? commaIndex : Number.POSITIVE_INFINITY;
+        }
+    }
+    result.push(input.slice(currentIndex, limitIndex));
+    currentIndex = limitIndex + 2;
+  }
+  return result;
+}
+function extractTupleMemberTypes(type) {
+  if ((0, _cairo.isCairo1Type)(type)) {
+    return extractCairo1Tuple(type);
+  }
+  return extractCairo0Tuple(type);
+}

package/dist/utils/calldata/tuple.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Convert tuple string definition into object like definition
+ * @param type tuple string definition
+ * @returns object like tuple
+ */
+export default function extractTupleMemberTypes(type: string): (string | object)[];

package/dist/utils/calldata/tuple.mjs

@@ -0,0 +1,88 @@
+import { isCairo1Type, isTypeNamedTuple } from "./cairo.mjs";
+function parseNamedTuple(namedTuple) {
+  const name = namedTuple.substring(0, namedTuple.indexOf(":"));
+  const type = namedTuple.substring(name.length + ":".length);
+  return { name, type };
+}
+function parseSubTuple(s) {
+  if (!s.includes("(")) return { subTuple: [], result: s };
+  const subTuple = [];
+  let result = "";
+  let i = 0;
+  while (i < s.length) {
+    if (s[i] === "(") {
+      let counter = 1;
+      const lBracket = i;
+      i++;
+      while (counter) {
+        if (s[i] === ")") counter--;
+        if (s[i] === "(") counter++;
+        i++;
+      }
+      subTuple.push(s.substring(lBracket, i));
+      result += " ";
+      i--;
+    } else {
+      result += s[i];
+    }
+    i++;
+  }
+  return {
+    subTuple,
+    result
+  };
+}
+function extractCairo0Tuple(type) {
+  const cleanType = type.replace(/\s/g, "").slice(1, -1);
+  const { subTuple, result } = parseSubTuple(cleanType);
+  let recomposed = result.split(",").map((it) => {
+    return subTuple.length ? it.replace(" ", subTuple.shift()) : it;
+  });
+  if (isTypeNamedTuple(type)) {
+    recomposed = recomposed.reduce((acc, it) => {
+      return acc.concat(parseNamedTuple(it));
+    }, []);
+  }
+  return recomposed;
+}
+function getClosureOffset(input, open, close) {
+  for (let i = 0, counter = 0; i < input.length; i++) {
+    if (input[i] === open) {
+      counter++;
+    } else if (input[i] === close && --counter === 0) {
+      return i;
+    }
+  }
+  return Number.POSITIVE_INFINITY;
+}
+function extractCairo1Tuple(type) {
+  const input = type.slice(1, -1);
+  const result = [];
+  let currentIndex = 0;
+  let limitIndex;
+  while (currentIndex < input.length) {
+    switch (true) {
+      case input[currentIndex] === "(": {
+        limitIndex = currentIndex + getClosureOffset(input.slice(currentIndex), "(", ")") + 1;
+        break;
+      }
+      case (input.startsWith("core::result::Result::<", currentIndex) || input.startsWith("core::array::Array::<", currentIndex) || input.startsWith("core::option::Option::<", currentIndex)): {
+        limitIndex = currentIndex + getClosureOffset(input.slice(currentIndex), "<", ">") + 1;
+        break;
+      }
+      default: {
+        const commaIndex = input.indexOf(",", currentIndex);
+        limitIndex = commaIndex !== -1 ? commaIndex : Number.POSITIVE_INFINITY;
+      }
+    }
+    result.push(input.slice(currentIndex, limitIndex));
+    currentIndex = limitIndex + 2;
+  }
+  return result;
+}
+export default function extractTupleMemberTypes(type) {
+  if (isCairo1Type(type)) {
+    return extractCairo1Tuple(type);
+  }
+  return extractCairo0Tuple(type);
+}

package/dist/utils/calldata/validate.cjs

@@ -0,0 +1,241 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+module.exports = validateFields;
+var _types = require("../../types/index.cjs");
+var _assert = _interopRequireDefault(require("../assert.cjs"));
+var _uint = require("../cairoDataTypes/uint256.cjs");
+var _uint2 = require("../cairoDataTypes/uint512.cjs");
+var _num = require("../num.cjs");
+var _shortString = require("../shortString.cjs");
+var _cairo = require("./cairo.cjs");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const validateFelt = (parameter, input) => {
+  (0, _assert.default)((0, _shortString.isString)(parameter) || (0, _num.isNumber)(parameter) || (0, _num.isBigInt)(parameter), `Validate: arg ${input.name} should be a felt typed as (String, Number or BigInt)`);
+  if ((0, _shortString.isString)(parameter) && !(0, _num.isHex)(parameter)) return;
+  const param = BigInt(parameter.toString(10));
+  (0, _assert.default)(
+  // from : https://github.com/starkware-libs/starknet-specs/blob/29bab650be6b1847c92d4461d4c33008b5e50b1a/api/starknet_api_openrpc.json#L1266
+  param >= 0n && param <= 2n ** 252n - 1n, `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^252-1]`);
+};
+const validateBytes31 = (parameter, input) => {
+  (0, _assert.default)((0, _shortString.isString)(parameter), `Validate: arg ${input.name} should be a string.`);
+  (0, _assert.default)(parameter.length < 32, `Validate: arg ${input.name} cairo typed ${input.type} should be a string of less than 32 characters.`);
+};
+const validateByteArray = (parameter, input) => {
+  (0, _assert.default)((0, _shortString.isString)(parameter), `Validate: arg ${input.name} should be a string.`);
+};
+const validateUint = (parameter, input) => {
+  if ((0, _num.isNumber)(parameter)) {
+    (0, _assert.default)(parameter <= Number.MAX_SAFE_INTEGER, `Validation: Parameter is to large to be typed as Number use (BigInt or String)`);
+  }
+  (0, _assert.default)((0, _shortString.isString)(parameter) || (0, _num.isNumber)(parameter) || (0, _num.isBigInt)(parameter) || typeof parameter === "object" && "low" in parameter && "high" in parameter || typeof parameter === "object" && ["limb0", "limb1", "limb2", "limb3"].every(key => key in parameter), `Validate: arg ${input.name} of cairo type ${input.type} should be type (String, Number or BigInt), but is ${typeof parameter} ${parameter}.`);
+  let param;
+  switch (input.type) {
+    case _types.Uint.u256:
+      param = new _uint.CairoUint256(parameter).toBigInt();
+      break;
+    case _types.Uint.u512:
+      param = new _uint2.CairoUint512(parameter).toBigInt();
+      break;
+    default:
+      param = (0, _num.toBigInt)(parameter);
+  }
+  switch (input.type) {
+    case _types.Uint.u8:
+      (0, _assert.default)(param >= 0n && param <= 255n, `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0 - 255]`);
+      break;
+    case _types.Uint.u16:
+      (0, _assert.default)(param >= 0n && param <= 65535n, `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 65535]`);
+      break;
+    case _types.Uint.u32:
+      (0, _assert.default)(param >= 0n && param <= 4294967295n, `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 4294967295]`);
+      break;
+    case _types.Uint.u64:
+      (0, _assert.default)(param >= 0n && param <= 2n ** 64n - 1n, `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^64-1]`);
+      break;
+    case _types.Uint.u128:
+      (0, _assert.default)(param >= 0n && param <= 2n ** 128n - 1n, `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^128-1]`);
+      break;
+    case _types.Uint.u256:
+      (0, _assert.default)(param >= 0n && param <= 2n ** 256n - 1n, `Validate: arg ${input.name} is ${input.type} 0 - 2^256-1`);
+      break;
+    case _types.Uint.u512:
+      (0, _assert.default)(_uint2.CairoUint512.is(param), `Validate: arg ${input.name} is ${input.type} 0 - 2^512-1`);
+      break;
+    case _types.Literal.ClassHash:
+      (0, _assert.default)(
+      // from : https://github.com/starkware-libs/starknet-specs/blob/29bab650be6b1847c92d4461d4c33008b5e50b1a/api/starknet_api_openrpc.json#L1670
+      param >= 0n && param <= 2n ** 252n - 1n, `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^252-1]`);
+      break;
+    case _types.Literal.ContractAddress:
+      (0, _assert.default)(
+      // from : https://github.com/starkware-libs/starknet-specs/blob/29bab650be6b1847c92d4461d4c33008b5e50b1a/api/starknet_api_openrpc.json#L1245
+      param >= 0n && param <= 2n ** 252n - 1n, `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^252-1]`);
+      break;
+    case _types.Literal.Secp256k1Point:
+      {
+        (0, _assert.default)(param >= 0n && param <= 2n ** 512n - 1n, `Validate: arg ${input.name} must be ${input.type} : a 512 bits number.`);
+        break;
+      }
+    default:
+      break;
+  }
+};
+const validateBool = (parameter, input) => {
+  (0, _assert.default)((0, _num.isBoolean)(parameter), `Validate: arg ${input.name} of cairo type ${input.type} should be type (Boolean)`);
+};
+const validateStruct = (parameter, input, structs) => {
+  if (input.type === _types.Uint.u256 || input.type === _types.Uint.u512) {
+    validateUint(parameter, input);
+    return;
+  }
+  if (input.type === "core::starknet::eth_address::EthAddress") {
+    (0, _assert.default)(typeof parameter !== "object", `EthAddress type is waiting a BigNumberish. Got ${parameter}`);
+    const param = BigInt(parameter.toString(10));
+    (0, _assert.default)(
+    // from : https://github.com/starkware-libs/starknet-specs/blob/29bab650be6b1847c92d4461d4c33008b5e50b1a/api/starknet_api_openrpc.json#L1259
+    param >= 0n && param <= 2n ** 160n - 1n, `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^160-1]`);
+    return;
+  }
+  (0, _assert.default)(typeof parameter === "object" && !Array.isArray(parameter), `Validate: arg ${input.name} is cairo type struct (${input.type}), and should be defined as js object (not array)`);
+  structs[input.type].members.forEach(({
+    name
+  }) => {
+    (0, _assert.default)(Object.keys(parameter).includes(name), `Validate: arg ${input.name} should have a property ${name}`);
+  });
+};
+const validateEnum = (parameter, input) => {
+  (0, _assert.default)(typeof parameter === "object" && !Array.isArray(parameter), `Validate: arg ${input.name} is cairo type Enum (${input.type}), and should be defined as js object (not array)`);
+  const methodsKeys = Object.getOwnPropertyNames(Object.getPrototypeOf(parameter));
+  const keys = [...Object.getOwnPropertyNames(parameter), ...methodsKeys];
+  if ((0, _cairo.isTypeOption)(input.type) && keys.includes("isSome") && keys.includes("isNone")) {
+    return;
+  }
+  if ((0, _cairo.isTypeResult)(input.type) && keys.includes("isOk") && keys.includes("isErr")) {
+    return;
+  }
+  if (keys.includes("variant") && keys.includes("activeVariant")) {
+    return;
+  }
+  throw new Error(`Validate Enum: argument ${input.name}, type ${input.type}, value received ${parameter}, is not an Enum.`);
+};
+const validateTuple = (parameter, input) => {
+  (0, _assert.default)(typeof parameter === "object" && !Array.isArray(parameter), `Validate: arg ${input.name} should be a tuple (defined as object)`);
+};
+const validateArray = (parameter, input, structs, enums) => {
+  const baseType = (0, _cairo.getArrayType)(input.type);
+  if ((0, _cairo.isTypeFelt)(baseType) && (0, _shortString.isLongText)(parameter)) {
+    return;
+  }
+  (0, _assert.default)(Array.isArray(parameter), `Validate: arg ${input.name} should be an Array`);
+  switch (true) {
+    case (0, _cairo.isTypeFelt)(baseType):
+      parameter.forEach(param => validateFelt(param, input));
+      break;
+    case (0, _cairo.isTypeTuple)(baseType):
+      parameter.forEach(it => validateTuple(it, {
+        name: input.name,
+        type: baseType
+      }));
+      break;
+    case (0, _cairo.isTypeArray)(baseType):
+      parameter.forEach(param => validateArray(param, {
+        name: "",
+        type: baseType
+      }, structs, enums));
+      break;
+    case (0, _cairo.isTypeStruct)(baseType, structs):
+      parameter.forEach(it => validateStruct(it, {
+        name: input.name,
+        type: baseType
+      }, structs));
+      break;
+    case (0, _cairo.isTypeEnum)(baseType, enums):
+      parameter.forEach(it => validateEnum(it, {
+        name: input.name,
+        type: baseType
+      }));
+      break;
+    case (0, _cairo.isTypeUint)(baseType) || (0, _cairo.isTypeLiteral)(baseType):
+      parameter.forEach(param => validateUint(param, {
+        name: "",
+        type: baseType
+      }));
+      break;
+    case (0, _cairo.isTypeBool)(baseType):
+      parameter.forEach(param => validateBool(param, input));
+      break;
+    default:
+      throw new Error(`Validate Unhandled: argument ${input.name}, type ${input.type}, value ${parameter}`);
+  }
+};
+const validateNonZero = (parameter, input) => {
+  const baseType = (0, _cairo.getArrayType)(input.type);
+  (0, _assert.default)((0, _cairo.isTypeUint)(baseType) && baseType !== _uint2.CairoUint512.abiSelector || (0, _cairo.isTypeFelt)(baseType), `Validate: ${input.name} type is not authorized for NonZero type.`);
+  switch (true) {
+    case (0, _cairo.isTypeFelt)(baseType):
+      validateFelt(parameter, input);
+      (0, _assert.default)(BigInt(parameter.toString(10)) > 0, "Validate: value 0 is not authorized in NonZero felt252 type.");
+      break;
+    case (0, _cairo.isTypeUint)(baseType):
+      validateUint(parameter, {
+        name: "",
+        type: baseType
+      });
+      switch (input.type) {
+        case _types.Uint.u256:
+          (0, _assert.default)(new _uint.CairoUint256(parameter).toBigInt() > 0, "Validate: value 0 is not authorized in NonZero uint256 type.");
+          break;
+        default:
+          (0, _assert.default)((0, _num.toBigInt)(parameter) > 0, "Validate: value 0 is not authorized in NonZero uint type.");
+      }
+      break;
+    default:
+      throw new Error(`Validate Unhandled: argument ${input.name}, type ${input.type}, value ${parameter}`);
+  }
+};
+function validateFields(abiMethod, args, structs, enums) {
+  abiMethod.inputs.reduce((acc, input) => {
+    const parameter = args[acc];
+    switch (true) {
+      case (0, _cairo.isLen)(input.name):
+        return acc;
+      case (0, _cairo.isTypeFelt)(input.type):
+        validateFelt(parameter, input);
+        break;
+      case (0, _cairo.isTypeBytes31)(input.type):
+        validateBytes31(parameter, input);
+        break;
+      case (0, _cairo.isTypeUint)(input.type) || (0, _cairo.isTypeLiteral)(input.type):
+        validateUint(parameter, input);
+        break;
+      case (0, _cairo.isTypeBool)(input.type):
+        validateBool(parameter, input);
+        break;
+      case (0, _cairo.isTypeByteArray)(input.type):
+        validateByteArray(parameter, input);
+        break;
+      case (0, _cairo.isTypeArray)(input.type):
+        validateArray(parameter, input, structs, enums);
+        break;
+      case (0, _cairo.isTypeStruct)(input.type, structs):
+        validateStruct(parameter, input, structs);
+        break;
+      case (0, _cairo.isTypeEnum)(input.type, enums):
+        validateEnum(parameter, input);
+        break;
+      case (0, _cairo.isTypeTuple)(input.type):
+        validateTuple(parameter, input);
+        break;
+      case (0, _cairo.isTypeNonZero)(input.type):
+        validateNonZero(parameter, input);
+        break;
+      default:
+        throw new Error(`Validate Unhandled: argument ${input.name}, type ${input.type}, value ${parameter}`);
+    }
+    return acc + 1;
+  }, 0);
+}

package/dist/utils/calldata/validate.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Validate cairo contract method arguments
+ * Flow: Determine type from abi and than validate against parameter
+ */
+import { AbiEnums, AbiStructs, FunctionAbi } from '../../types';
+export default function validateFields(abiMethod: FunctionAbi, args: Array<any>, structs: AbiStructs, enums: AbiEnums): void;