starknet 5.5.0 → 5.6.0

package/dist/index.mjs

@@ -2229,6 +2229,26 @@ var CONSTANT_POINTS = [
   ]
 ];
 
+// src/utils/calldata/cairo.ts
+var cairo_exports = {};
+__export(cairo_exports, {
+  Uint: () => Uint,
+  felt: () => felt,
+  getArrayType: () => getArrayType,
+  isCairo1Type: () => isCairo1Type,
+  isLen: () => isLen,
+  isTypeArray: () => isTypeArray,
+  isTypeBool: () => isTypeBool,
+  isTypeContractAddress: () => isTypeContractAddress,
+  isTypeFelt: () => isTypeFelt,
+  isTypeNamedTuple: () => isTypeNamedTuple,
+  isTypeStruct: () => isTypeStruct,
+  isTypeTuple: () => isTypeTuple,
+  isTypeUint: () => isTypeUint,
+  tuple: () => tuple,
+  uint256: () => uint256
+});
+
 // src/utils/num.ts
 var num_exports = {};
 __export(num_exports, {
@@ -2385,8 +2405,8 @@ __export(uint256_exports, {
   isUint256: () => isUint256,
   uint256ToBN: () => uint256ToBN
 });
-function uint256ToBN(uint256) {
-  return (toBigInt(uint256.high) << 128n) + toBigInt(uint256.low);
+function uint256ToBN(uint2562) {
+  return (toBigInt(uint2562.high) << 128n) + toBigInt(uint2562.low);
 }
 var UINT_128_MAX = (1n << 128n) - 1n;
 var UINT_256_MAX = (1n << 256n) - 1n;
@@ -2404,13 +2424,41 @@ function bnToUint256(bignumber) {
 }
 
 // src/utils/calldata/cairo.ts
+var Uint = /* @__PURE__ */ ((Uint2) => {
+  Uint2["u8"] = "core::integer::u8";
+  Uint2["u16"] = "core::integer::u16";
+  Uint2["u32"] = "core::integer::u32";
+  Uint2["u64"] = "core::integer::u64";
+  Uint2["u128"] = "core::integer::u128";
+  Uint2["u256"] = "core::integer::u256";
+  return Uint2;
+})(Uint || {});
 var isLen = (name) => /_len$/.test(name);
-var isTypeFelt = (type) => type === "felt";
-var isTypeFeltArray = (type) => type === "felt*";
-var isTypeArray = (type) => /\*/.test(type);
+var isTypeFelt = (type) => type === "felt" || type === "core::felt252";
+var isTypeArray = (type) => /\*/.test(type) || type.includes("core::array::Array::");
 var isTypeTuple = (type) => /^\(.*\)$/i.test(type);
 var isTypeNamedTuple = (type) => /\(.*\)/i.test(type) && type.includes(":");
 var isTypeStruct = (type, structs) => type in structs;
+var isTypeUint = (type) => Object.values(Uint).includes(type);
+var isTypeBool = (type) => type === "core::bool";
+var isTypeContractAddress = (type) => type === "core::starknet::contract_address::ContractAddress";
+var isCairo1Type = (type) => type.includes("core::");
+var getArrayType = (type) => {
+  if (isCairo1Type(type)) {
+    return type.substring(type.indexOf("<") + 1, type.indexOf(">"));
+  }
+  return type.replace("*", "");
+};
+var uint256 = (it) => {
+  const bn = BigInt(it);
+  if (!isUint256(bn))
+    throw new Error("Number is too large");
+  return {
+    low: (bn & UINT_128_MAX).toString(10),
+    high: (bn >> 128n).toString(10)
+  };
+};
+var tuple = (...args) => ({ ...args });
 function felt(it) {
   if (isBigInt(it) || typeof it === "number" && Number.isInteger(it)) {
     return it.toString();
@@ -4201,7 +4249,7 @@ function parseSubTuple(s) {
     result
   };
 }
-function extractTupleMemberTypes(type) {
+function extractCairo0Tuple(type) {
   const cleanType = type.replace(/\s/g, "").slice(1, -1);
   const { subTuple, result } = parseSubTuple(cleanType);
   let recomposed = result.split(",").map((it) => {
@@ -4214,6 +4262,16 @@ function extractTupleMemberTypes(type) {
   }
   return recomposed;
 }
+function extractCairo1Tuple(type) {
+  const cleanType = type.replace(/\s/g, "").slice(1, -1);
+  return cleanType.split(",");
+}
+function extractTupleMemberTypes(type) {
+  if (isCairo1Type(type)) {
+    return extractCairo1Tuple(type);
+  }
+  return extractCairo0Tuple(type);
+}
 
 // src/utils/calldata/requestParser.ts
 function parseTuple(element, typeStr) {
@@ -4272,16 +4330,21 @@ function parseCalldataField(argsIterator, input, structs) {
       }
       const result = [];
       result.push(felt(value.length));
+      const arrayType = getArrayType(input.type);
       return value.reduce((acc, el) => {
-        if (isTypeFeltArray(type)) {
+        if (isTypeFelt(arrayType) || isTypeUint(arrayType) || isTypeContractAddress(arrayType)) {
           acc.push(felt(el));
+        } else if (isTypeBool(arrayType) && typeof el === "boolean") {
+          acc.push(el.toString());
         } else {
-          acc.push(...parseCalldataValue(el, type.replace("*", ""), structs));
+          acc.push(...parseCalldataValue(el, arrayType, structs));
         }
         return acc;
       }, result);
     case (isTypeStruct(type, structs) || isTypeTuple(type)):
       return parseCalldataValue(value, type, structs);
+    case isTypeBool(type):
+      return value;
     default:
       return felt(value);
   }
@@ -4314,8 +4377,20 @@ function responseParser(responseIterator, output, structs, parsedResult) {
     case isLen(name):
       temp = responseIterator.next().value;
       return BigInt(temp);
+    case isTypeBool(type):
+      temp = responseIterator.next().value;
+      return Boolean(BigInt(temp));
     case isTypeArray(type):
       const parsedDataArr = [];
+      if (isCairo1Type(type)) {
+        responseIterator.next();
+        let it = responseIterator.next();
+        while (!it.done) {
+          parsedDataArr.push(BigInt(it.value));
+          it = responseIterator.next();
+        }
+        return parsedDataArr;
+      }
       if (parsedResult && parsedResult[`${name}_len`]) {
         const arrLen = parsedResult[`${name}_len`];
         while (parsedDataArr.length < arrLen) {
@@ -4337,7 +4412,66 @@ function responseParser(responseIterator, output, structs, parsedResult) {
 var validateFelt = (parameter, input) => {
   assert(
     typeof parameter === "string" || typeof parameter === "number" || typeof parameter === "bigint",
-    `Validate: arg ${input.name} should be a felt (string, number, BigNumber)`
+    `Validate: arg ${input.name} should be a felt typed as (String, Number or BigInt)`
+  );
+};
+var validateUint = (parameter, input) => {
+  if (typeof parameter === "number") {
+    assert(
+      parameter <= Number.MAX_SAFE_INTEGER,
+      `Validation: Parameter is to large to be typed as Number use (BigInt or String)`
+    );
+  }
+  assert(
+    typeof parameter === "string" || typeof parameter === "number" || typeof parameter === "bigint",
+    `Validate: arg ${input.name} of cairo type ${input.type} should be type (String, Number or BigInt)`
+  );
+  const param = toBigInt(parameter);
+  switch (input.type) {
+    case "core::integer::u8" /* u8 */:
+      assert(
+        param >= 0n && param <= 255n,
+        `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0 - 255]`
+      );
+      break;
+    case "core::integer::u16" /* u16 */:
+      assert(
+        param >= 0n && param <= 65535n,
+        `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 65535]`
+      );
+      break;
+    case "core::integer::u32" /* u32 */:
+      assert(
+        param >= 0n && param <= 4294967295n,
+        `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 4294967295]`
+      );
+      break;
+    case "core::integer::u64" /* u64 */:
+      assert(
+        param >= 0n && param <= 2n ** 64n - 1n,
+        `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^64-1]`
+      );
+      break;
+    case "core::integer::u128" /* u128 */:
+      assert(
+        param >= 0n && param <= 2n ** 128n - 1n,
+        `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^128-1]`
+      );
+      break;
+    case "core::integer::u256" /* u256 */:
+      assert(
+        param >= 0n && param <= 2n ** 256n - 1n,
+        `Validate: arg ${input.name} is ${input.type} 0 - 2^256-1`
+      );
+      break;
+    default:
+      break;
+  }
+};
+var validateBool = (parameter, input) => {
+  assert(
+    typeof parameter === "boolean",
+    `Validate: arg ${input.name} of cairo type ${input.type} should be type (Boolean)`
   );
 };
 var validateStruct = (parameter, input, structs) => {
@@ -4359,7 +4493,7 @@ var validateTuple = (parameter, input) => {
   );
 };
 var validateArray = (parameter, input, structs) => {
-  const baseType = input.type.replace("*", "");
+  const baseType = getArrayType(input.type);
   if (isTypeFelt(baseType) && isLongText(parameter))
     return;
   assert(Array.isArray(parameter), `Validate: arg ${input.name} should be an Array`);
@@ -4375,6 +4509,12 @@ var validateArray = (parameter, input, structs) => {
         (it) => validateStruct(it, { name: input.name, type: baseType }, structs)
       );
       break;
+    case isTypeUint(baseType):
+      parameter.forEach((param) => validateUint(param, input));
+      break;
+    case isTypeBool(baseType):
+      parameter.forEach((param) => validateBool(param, input));
+      break;
     default:
       throw new Error(
         `Validate Unhandled: argument ${input.name}, type ${input.type}, value ${parameter}`
@@ -4390,6 +4530,14 @@ function validateFields(abiMethod, args, structs) {
       case isTypeFelt(input.type):
         validateFelt(parameter, input);
         break;
+      case isTypeUint(input.type):
+        validateUint(parameter, input);
+        break;
+      case isTypeBool(input.type):
+        validateBool(parameter, input);
+        break;
+      case isTypeContractAddress(input.type):
+        break;
       case isTypeStruct(input.type, structs):
         validateStruct(parameter, input, structs);
         break;
@@ -4478,13 +4626,15 @@ var CallData = class {
   parse(method, response) {
     const { outputs } = this.abi.find((abi) => abi.name === method);
     const responseIterator = response.flat()[Symbol.iterator]();
-    return outputs.flat().reduce((acc, output) => {
-      acc[output.name] = responseParser(responseIterator, output, this.structs, acc);
-      if (acc[output.name] && acc[`${output.name}_len`]) {
-        delete acc[`${output.name}_len`];
+    const parsed = outputs.flat().reduce((acc, output, idx) => {
+      const propName = output.name ?? idx;
+      acc[propName] = responseParser(responseIterator, output, this.structs, acc);
+      if (acc[propName] && acc[`${propName}_len`]) {
+        delete acc[`${propName}_len`];
       }
       return acc;
     }, {});
+    return Object.keys(parsed).length === 1 && 0 in parsed ? parsed[0] : parsed;
   }
   format(method, response, format) {
     const parsed = this.parse(method, response);
@@ -4556,13 +4706,20 @@ function buildEstimate(contract, functionAbi) {
     return contract.estimate(functionAbi.name, args);
   };
 }
+var detectCairoVersion = (abi) => {
+  if (!abi)
+    return "0";
+  return abi.find((it) => "state_mutability" in it) ? "1" : "0";
+};
 var Contract = class {
-  constructor(abi, address, providerOrAccount = defaultProvider) {
+  constructor(abi, address, providerOrAccount = defaultProvider, cairoVersion = detectCairoVersion(abi)) {
+    this.version = "0";
     this.address = address && address.toLowerCase();
     this.providerOrAccount = providerOrAccount;
     this.callData = new CallData(abi);
     this.structs = CallData.getAbiStruct(abi);
     this.abi = abi;
+    this.version = cairoVersion;
     const options = { enumerable: true, value: {}, writable: false };
     Object.defineProperties(this, {
       functions: { enumerable: true, value: {}, writable: false },
@@ -5664,6 +5821,7 @@ export {
   TransactionType,
   addAddressPadding,
   buildUrl,
+  cairo_exports as cairo,
   constants_exports as constants,
   defaultProvider,
   ec_exports as ec,