starknet 6.9.0 → 6.10.1

package/dist/utils/calldata/parser/index.mjs

@@ -0,0 +1,21 @@
+import { isCairo1Abi } from "../cairo.mjs";
+import { AbiParser1 } from "./parser-0-1.1.0.mjs";
+import { AbiParser2 } from "./parser-2.0.0.mjs";
+export function createAbiParser(abi) {
+  const version = getAbiVersion(abi);
+  if (version === 0 || version === 1) {
+    return new AbiParser1(abi);
+  }
+  if (version === 2) {
+    return new AbiParser2(abi);
+  }
+  throw Error(`Unsupported ABI version ${version}`);
+}
+export function getAbiVersion(abi) {
+  if (abi.find((it) => it.type === "interface")) return 2;
+  if (isCairo1Abi(abi)) return 1;
+  return 0;
+}
+export function isNoConstructorValid(method, argsCalldata, abiMethod) {
+  return method === "constructor" && !abiMethod && !argsCalldata.length;
+}

package/dist/utils/calldata/parser/interface.cjs

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AbiParserInterface = void 0;
+class AbiParserInterface {}
+exports.AbiParserInterface = AbiParserInterface;

package/dist/utils/calldata/parser/interface.d.ts

@@ -0,0 +1,20 @@
+import { Abi, FunctionAbi } from '../../../types';
+export declare abstract class AbiParserInterface {
+    /**
+     * Helper to calculate inputs length from abi
+     * @param abiMethod FunctionAbi
+     * @return number
+     */
+    abstract methodInputsLength(abiMethod: FunctionAbi): number;
+    /**
+     *
+     * @param name string
+     * @return FunctionAbi | undefined
+     */
+    abstract getMethod(name: string): FunctionAbi | undefined;
+    /**
+     * Return Abi in legacy format
+     * @return Abi
+     */
+    abstract getLegacyFormat(): Abi;
+}

package/dist/utils/calldata/parser/interface.mjs

@@ -0,0 +1,2 @@
+export class AbiParserInterface {
+}

package/dist/utils/calldata/parser/parser-0-1.1.0.cjs

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AbiParser1 = void 0;
+var _cairo = require("../cairo.cjs");
+class AbiParser1 {
+  abi;
+  constructor(abi) {
+    this.abi = abi;
+  }
+  /**
+   * abi method inputs length without '_len' inputs
+   * cairo 0 reducer
+   * @param abiMethod FunctionAbi
+   * @returns number
+   */
+  methodInputsLength(abiMethod) {
+    return abiMethod.inputs.reduce((acc, input) => !(0, _cairo.isLen)(input.name) ? acc + 1 : acc, 0);
+  }
+  /**
+   * get method definition from abi
+   * @param name string
+   * @returns FunctionAbi | undefined
+   */
+  getMethod(name) {
+    return this.abi.find(it => it.name === name);
+  }
+  /**
+   * Get Abi in legacy format
+   * @returns Abi
+   */
+  getLegacyFormat() {
+    return this.abi;
+  }
+}
+exports.AbiParser1 = AbiParser1;

package/dist/utils/calldata/parser/parser-0-1.1.0.d.ts

@@ -0,0 +1,24 @@
+import { Abi, FunctionAbi } from '../../../types';
+import { AbiParserInterface } from './interface';
+export declare class AbiParser1 implements AbiParserInterface {
+    abi: Abi;
+    constructor(abi: Abi);
+    /**
+     * abi method inputs length without '_len' inputs
+     * cairo 0 reducer
+     * @param abiMethod FunctionAbi
+     * @returns number
+     */
+    methodInputsLength(abiMethod: FunctionAbi): number;
+    /**
+     * get method definition from abi
+     * @param name string
+     * @returns FunctionAbi | undefined
+     */
+    getMethod(name: string): FunctionAbi | undefined;
+    /**
+     * Get Abi in legacy format
+     * @returns Abi
+     */
+    getLegacyFormat(): Abi;
+}

package/dist/utils/calldata/parser/parser-0-1.1.0.mjs

@@ -0,0 +1,31 @@
+import { isLen } from "../cairo.mjs";
+export class AbiParser1 {
+  abi;
+  constructor(abi) {
+    this.abi = abi;
+  }
+  /**
+   * abi method inputs length without '_len' inputs
+   * cairo 0 reducer
+   * @param abiMethod FunctionAbi
+   * @returns number
+   */
+  methodInputsLength(abiMethod) {
+    return abiMethod.inputs.reduce((acc, input) => !isLen(input.name) ? acc + 1 : acc, 0);
+  }
+  /**
+   * get method definition from abi
+   * @param name string
+   * @returns FunctionAbi | undefined
+   */
+  getMethod(name) {
+    return this.abi.find((it) => it.name === name);
+  }
+  /**
+   * Get Abi in legacy format
+   * @returns Abi
+   */
+  getLegacyFormat() {
+    return this.abi;
+  }
+}

package/dist/utils/calldata/parser/parser-2.0.0.cjs

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AbiParser2 = void 0;
+class AbiParser2 {
+  abi;
+  constructor(abi) {
+    this.abi = abi;
+  }
+  /**
+   * abi method inputs length
+   * @param abiMethod FunctionAbi
+   * @returns number
+   */
+  methodInputsLength(abiMethod) {
+    return abiMethod.inputs.length;
+  }
+  /**
+   * get method definition from abi
+   * @param name string
+   * @returns FunctionAbi | undefined
+   */
+  getMethod(name) {
+    const intf = this.abi.find(it => it.type === "interface");
+    return intf.items.find(it => it.name === name);
+  }
+  /**
+   * Get Abi in legacy format
+   * @returns Abi
+   */
+  getLegacyFormat() {
+    return this.abi.flatMap(e => {
+      if (e.type === "interface") {
+        return e.items;
+      }
+      return e;
+    });
+  }
+}
+exports.AbiParser2 = AbiParser2;

package/dist/utils/calldata/parser/parser-2.0.0.d.ts

@@ -0,0 +1,23 @@
+import { Abi, FunctionAbi } from '../../../types';
+import { AbiParserInterface } from './interface';
+export declare class AbiParser2 implements AbiParserInterface {
+    abi: Abi;
+    constructor(abi: Abi);
+    /**
+     * abi method inputs length
+     * @param abiMethod FunctionAbi
+     * @returns number
+     */
+    methodInputsLength(abiMethod: FunctionAbi): number;
+    /**
+     * get method definition from abi
+     * @param name string
+     * @returns FunctionAbi | undefined
+     */
+    getMethod(name: string): FunctionAbi | undefined;
+    /**
+     * Get Abi in legacy format
+     * @returns Abi
+     */
+    getLegacyFormat(): Abi;
+}

package/dist/utils/calldata/parser/parser-2.0.0.mjs

@@ -0,0 +1,37 @@
+export class AbiParser2 {
+  abi;
+  constructor(abi) {
+    this.abi = abi;
+  }
+  /**
+   * abi method inputs length
+   * @param abiMethod FunctionAbi
+   * @returns number
+   */
+  methodInputsLength(abiMethod) {
+    return abiMethod.inputs.length;
+  }
+  /**
+   * get method definition from abi
+   * @param name string
+   * @returns FunctionAbi | undefined
+   */
+  getMethod(name) {
+    const intf = this.abi.find(
+      (it) => it.type === "interface"
+    );
+    return intf.items.find((it) => it.name === name);
+  }
+  /**
+   * Get Abi in legacy format
+   * @returns Abi
+   */
+  getLegacyFormat() {
+    return this.abi.flatMap((e) => {
+      if (e.type === "interface") {
+        return e.items;
+      }
+      return e;
+    });
+  }
+}

package/dist/utils/calldata/propertyOrder.cjs

@@ -0,0 +1,159 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+module.exports = orderPropsByAbi;
+var _uint = require("../cairoDataTypes/uint256.cjs");
+var _uint2 = require("../cairoDataTypes/uint512.cjs");
+var _cairo = require("./cairo.cjs");
+var _enum = require("./enum/index.cjs");
+var _tuple = _interopRequireDefault(require("./tuple.cjs"));
+var _shortString = require("../shortString.cjs");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function errorU256(key) {
+  return Error(`Your object includes the property : ${key}, containing an Uint256 object without the 'low' and 'high' keys.`);
+}
+function errorU512(key) {
+  return Error(`Your object includes the property : ${key}, containing an Uint512 object without the 'limb0' to 'limb3' keys.`);
+}
+function orderPropsByAbi(unorderedObject, abiOfObject, structs, enums) {
+  const orderInput = (unorderedItem, abiType) => {
+    if ((0, _cairo.isTypeArray)(abiType)) {
+      return orderArray(unorderedItem, abiType);
+    }
+    if ((0, _cairo.isTypeEnum)(abiType, enums)) {
+      const abiObj = enums[abiType];
+      return orderEnum(unorderedItem, abiObj);
+    }
+    if ((0, _cairo.isTypeTuple)(abiType)) {
+      return orderTuple(unorderedItem, abiType);
+    }
+    if ((0, _cairo.isTypeEthAddress)(abiType)) {
+      return unorderedItem;
+    }
+    if ((0, _cairo.isTypeNonZero)(abiType)) {
+      return unorderedItem;
+    }
+    if ((0, _cairo.isTypeByteArray)(abiType)) {
+      return unorderedItem;
+    }
+    if ((0, _cairo.isTypeSecp256k1Point)(abiType)) {
+      return unorderedItem;
+    }
+    if (_uint.CairoUint256.isAbiType(abiType)) {
+      const u256 = unorderedItem;
+      if (typeof u256 !== "object") {
+        return u256;
+      }
+      if (!("low" in u256 && "high" in u256)) {
+        throw errorU256(abiType);
+      }
+      return {
+        low: u256.low,
+        high: u256.high
+      };
+    }
+    if (_uint2.CairoUint512.isAbiType(abiType)) {
+      const u512 = unorderedItem;
+      if (typeof u512 !== "object") {
+        return u512;
+      }
+      if (!["limb0", "limb1", "limb2", "limb3"].every(key => key in u512)) {
+        throw errorU512(abiType);
+      }
+      return {
+        limb0: u512.limb0,
+        limb1: u512.limb1,
+        limb2: u512.limb2,
+        limb3: u512.limb3
+      };
+    }
+    if ((0, _cairo.isTypeStruct)(abiType, structs)) {
+      const abiOfStruct = structs[abiType].members;
+      return orderStruct(unorderedItem, abiOfStruct);
+    }
+    return unorderedItem;
+  };
+  const orderStruct = (unorderedObject2, abiObject) => {
+    const orderedObject2 = abiObject.reduce((orderedObject, abiParam) => {
+      const setProperty = value => Object.defineProperty(orderedObject, abiParam.name, {
+        enumerable: true,
+        value: value ?? unorderedObject2[abiParam.name]
+      });
+      if (unorderedObject2[abiParam.name] === "undefined") {
+        if ((0, _cairo.isCairo1Type)(abiParam.type) || !(0, _cairo.isLen)(abiParam.name)) {
+          throw Error(`Your object needs a property with key : ${abiParam.name} .`);
+        }
+      }
+      setProperty(orderInput(unorderedObject2[abiParam.name], abiParam.type));
+      return orderedObject;
+    }, {});
+    return orderedObject2;
+  };
+  function orderArray(myArray, abiParam) {
+    const typeInArray = (0, _cairo.getArrayType)(abiParam);
+    if ((0, _shortString.isString)(myArray)) {
+      return myArray;
+    }
+    return myArray.map(myElem => orderInput(myElem, typeInArray));
+  }
+  function orderTuple(unorderedObject2, abiParam) {
+    const typeList = (0, _tuple.default)(abiParam);
+    const orderedObject2 = typeList.reduce((orderedObject, abiTypeCairoX, index) => {
+      const myObjKeys = Object.keys(unorderedObject2);
+      const setProperty = value => Object.defineProperty(orderedObject, index.toString(), {
+        enumerable: true,
+        value: value ?? unorderedObject2[myObjKeys[index]]
+      });
+      const abiType = abiTypeCairoX?.type ? abiTypeCairoX.type : abiTypeCairoX;
+      setProperty(orderInput(unorderedObject2[myObjKeys[index]], abiType));
+      return orderedObject;
+    }, {});
+    return orderedObject2;
+  }
+  const orderEnum = (unorderedObject2, abiObject) => {
+    if ((0, _cairo.isTypeResult)(abiObject.name)) {
+      const unorderedResult = unorderedObject2;
+      const resultOkType = abiObject.name.substring(abiObject.name.indexOf("<") + 1, abiObject.name.lastIndexOf(","));
+      const resultErrType = abiObject.name.substring(abiObject.name.indexOf(",") + 1, abiObject.name.lastIndexOf(">"));
+      if (unorderedResult.isOk()) {
+        return new _enum.CairoResult(_enum.CairoResultVariant.Ok, orderInput(unorderedObject2.unwrap(), resultOkType));
+      }
+      return new _enum.CairoResult(_enum.CairoResultVariant.Err, orderInput(unorderedObject2.unwrap(), resultErrType));
+    }
+    if ((0, _cairo.isTypeOption)(abiObject.name)) {
+      const unorderedOption = unorderedObject2;
+      const resultSomeType = abiObject.name.substring(abiObject.name.indexOf("<") + 1, abiObject.name.lastIndexOf(">"));
+      if (unorderedOption.isSome()) {
+        return new _enum.CairoOption(_enum.CairoOptionVariant.Some, orderInput(unorderedOption.unwrap(), resultSomeType));
+      }
+      return new _enum.CairoOption(_enum.CairoOptionVariant.None, {});
+    }
+    const unorderedCustomEnum = unorderedObject2;
+    const variants = Object.entries(unorderedCustomEnum.variant);
+    const newEntries = variants.map(variant => {
+      if (typeof variant[1] === "undefined") {
+        return variant;
+      }
+      const variantType = abiObject.type.substring(abiObject.type.lastIndexOf("<") + 1, abiObject.type.lastIndexOf(">"));
+      if (variantType === "()") {
+        return variant;
+      }
+      return [variant[0], orderInput(unorderedCustomEnum.unwrap(), variantType)];
+    });
+    return new _enum.CairoCustomEnum(Object.fromEntries(newEntries));
+  };
+  const finalOrderedObject = abiOfObject.reduce((orderedObject, abiParam) => {
+    const setProperty = value => Object.defineProperty(orderedObject, abiParam.name, {
+      enumerable: true,
+      value
+    });
+    if ((0, _cairo.isLen)(abiParam.name) && !(0, _cairo.isCairo1Type)(abiParam.type)) {
+      return orderedObject;
+    }
+    setProperty(orderInput(unorderedObject[abiParam.name], abiParam.type));
+    return orderedObject;
+  }, {});
+  return finalOrderedObject;
+}

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

@@ -0,0 +1,2 @@
+import { AbiEntry, AbiEnums, AbiStructs, RawArgsObject } from '../../types';
+export default function orderPropsByAbi(unorderedObject: RawArgsObject, abiOfObject: AbiEntry[], structs: AbiStructs, enums: AbiEnums): object;

package/dist/utils/calldata/propertyOrder.mjs

@@ -0,0 +1,189 @@
+import { CairoUint256 } from "../cairoDataTypes/uint256.mjs";
+import { CairoUint512 } from "../cairoDataTypes/uint512.mjs";
+import {
+  getArrayType,
+  isCairo1Type,
+  isLen,
+  isTypeArray,
+  isTypeByteArray,
+  isTypeEnum,
+  isTypeEthAddress,
+  isTypeNonZero,
+  isTypeOption,
+  isTypeResult,
+  isTypeSecp256k1Point,
+  isTypeStruct,
+  isTypeTuple
+} from "./cairo.mjs";
+import {
+  CairoCustomEnum,
+  CairoOption,
+  CairoOptionVariant,
+  CairoResult,
+  CairoResultVariant
+} from "./enum/index.mjs";
+import extractTupleMemberTypes from "./tuple.mjs";
+import { isString } from "../shortString.mjs";
+function errorU256(key) {
+  return Error(
+    `Your object includes the property : ${key}, containing an Uint256 object without the 'low' and 'high' keys.`
+  );
+}
+function errorU512(key) {
+  return Error(
+    `Your object includes the property : ${key}, containing an Uint512 object without the 'limb0' to 'limb3' keys.`
+  );
+}
+export default function orderPropsByAbi(unorderedObject, abiOfObject, structs, enums) {
+  const orderInput = (unorderedItem, abiType) => {
+    if (isTypeArray(abiType)) {
+      return orderArray(unorderedItem, abiType);
+    }
+    if (isTypeEnum(abiType, enums)) {
+      const abiObj = enums[abiType];
+      return orderEnum(unorderedItem, abiObj);
+    }
+    if (isTypeTuple(abiType)) {
+      return orderTuple(unorderedItem, abiType);
+    }
+    if (isTypeEthAddress(abiType)) {
+      return unorderedItem;
+    }
+    if (isTypeNonZero(abiType)) {
+      return unorderedItem;
+    }
+    if (isTypeByteArray(abiType)) {
+      return unorderedItem;
+    }
+    if (isTypeSecp256k1Point(abiType)) {
+      return unorderedItem;
+    }
+    if (CairoUint256.isAbiType(abiType)) {
+      const u256 = unorderedItem;
+      if (typeof u256 !== "object") {
+        return u256;
+      }
+      if (!("low" in u256 && "high" in u256)) {
+        throw errorU256(abiType);
+      }
+      return { low: u256.low, high: u256.high };
+    }
+    if (CairoUint512.isAbiType(abiType)) {
+      const u512 = unorderedItem;
+      if (typeof u512 !== "object") {
+        return u512;
+      }
+      if (!["limb0", "limb1", "limb2", "limb3"].every((key) => key in u512)) {
+        throw errorU512(abiType);
+      }
+      return { limb0: u512.limb0, limb1: u512.limb1, limb2: u512.limb2, limb3: u512.limb3 };
+    }
+    if (isTypeStruct(abiType, structs)) {
+      const abiOfStruct = structs[abiType].members;
+      return orderStruct(unorderedItem, abiOfStruct);
+    }
+    return unorderedItem;
+  };
+  const orderStruct = (unorderedObject2, abiObject) => {
+    const orderedObject2 = abiObject.reduce((orderedObject, abiParam) => {
+      const setProperty = (value) => Object.defineProperty(orderedObject, abiParam.name, {
+        enumerable: true,
+        value: value ?? unorderedObject2[abiParam.name]
+      });
+      if (unorderedObject2[abiParam.name] === "undefined") {
+        if (isCairo1Type(abiParam.type) || !isLen(abiParam.name)) {
+          throw Error(`Your object needs a property with key : ${abiParam.name} .`);
+        }
+      }
+      setProperty(orderInput(unorderedObject2[abiParam.name], abiParam.type));
+      return orderedObject;
+    }, {});
+    return orderedObject2;
+  };
+  function orderArray(myArray, abiParam) {
+    const typeInArray = getArrayType(abiParam);
+    if (isString(myArray)) {
+      return myArray;
+    }
+    return myArray.map((myElem) => orderInput(myElem, typeInArray));
+  }
+  function orderTuple(unorderedObject2, abiParam) {
+    const typeList = extractTupleMemberTypes(abiParam);
+    const orderedObject2 = typeList.reduce((orderedObject, abiTypeCairoX, index) => {
+      const myObjKeys = Object.keys(unorderedObject2);
+      const setProperty = (value) => Object.defineProperty(orderedObject, index.toString(), {
+        enumerable: true,
+        value: value ?? unorderedObject2[myObjKeys[index]]
+      });
+      const abiType = abiTypeCairoX?.type ? abiTypeCairoX.type : abiTypeCairoX;
+      setProperty(orderInput(unorderedObject2[myObjKeys[index]], abiType));
+      return orderedObject;
+    }, {});
+    return orderedObject2;
+  }
+  const orderEnum = (unorderedObject2, abiObject) => {
+    if (isTypeResult(abiObject.name)) {
+      const unorderedResult = unorderedObject2;
+      const resultOkType = abiObject.name.substring(
+        abiObject.name.indexOf("<") + 1,
+        abiObject.name.lastIndexOf(",")
+      );
+      const resultErrType = abiObject.name.substring(
+        abiObject.name.indexOf(",") + 1,
+        abiObject.name.lastIndexOf(">")
+      );
+      if (unorderedResult.isOk()) {
+        return new CairoResult(
+          CairoResultVariant.Ok,
+          orderInput(unorderedObject2.unwrap(), resultOkType)
+        );
+      }
+      return new CairoResult(
+        CairoResultVariant.Err,
+        orderInput(unorderedObject2.unwrap(), resultErrType)
+      );
+    }
+    if (isTypeOption(abiObject.name)) {
+      const unorderedOption = unorderedObject2;
+      const resultSomeType = abiObject.name.substring(
+        abiObject.name.indexOf("<") + 1,
+        abiObject.name.lastIndexOf(">")
+      );
+      if (unorderedOption.isSome()) {
+        return new CairoOption(
+          CairoOptionVariant.Some,
+          orderInput(unorderedOption.unwrap(), resultSomeType)
+        );
+      }
+      return new CairoOption(CairoOptionVariant.None, {});
+    }
+    const unorderedCustomEnum = unorderedObject2;
+    const variants = Object.entries(unorderedCustomEnum.variant);
+    const newEntries = variants.map((variant) => {
+      if (typeof variant[1] === "undefined") {
+        return variant;
+      }
+      const variantType = abiObject.type.substring(
+        abiObject.type.lastIndexOf("<") + 1,
+        abiObject.type.lastIndexOf(">")
+      );
+      if (variantType === "()") {
+        return variant;
+      }
+      return [variant[0], orderInput(unorderedCustomEnum.unwrap(), variantType)];
+    });
+    return new CairoCustomEnum(Object.fromEntries(newEntries));
+  };
+  const finalOrderedObject = abiOfObject.reduce((orderedObject, abiParam) => {
+    const setProperty = (value) => Object.defineProperty(orderedObject, abiParam.name, {
+      enumerable: true,
+      value
+    });
+    if (isLen(abiParam.name) && !isCairo1Type(abiParam.type)) {
+      return orderedObject;
+    }
+    setProperty(orderInput(unorderedObject[abiParam.name], abiParam.type));
+    return orderedObject;
+  }, {});
+  return finalOrderedObject;
+}