starknet 6.9.0 → 6.10.1

package/dist/utils/calldata/enum/CairoCustomEnum.cjs

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CairoCustomEnum = void 0;
+class CairoCustomEnum {
+  /**
+   * direct readonly access to variants of the Cairo Custom Enum.
+   * @returns a value of type any
+   * @example
+   * ```typescript
+   * const successValue = myCairoEnum.variant.Success;
+   */
+  variant;
+  /**
+   * @param enumContent an object with the variants as keys and the content as value. Only one content shall be defined.
+   */
+  constructor(enumContent) {
+    const variantsList = Object.values(enumContent);
+    if (variantsList.length === 0) {
+      throw new Error("This Enum must have at least 1 variant");
+    }
+    const nbActiveVariants = variantsList.filter(content => typeof content !== "undefined").length;
+    if (nbActiveVariants !== 1) {
+      throw new Error("This Enum must have exactly one active variant");
+    }
+    this.variant = enumContent;
+  }
+  /**
+   *
+   * @returns the content of the valid variant of a Cairo custom Enum.
+   */
+  unwrap() {
+    const variants = Object.entries(this.variant);
+    const activeVariant = variants.find(item => typeof item[1] !== "undefined");
+    if (typeof activeVariant === "undefined") {
+      return void 0;
+    }
+    return activeVariant[1];
+  }
+  /**
+   *
+   * @returns the name of the valid variant of a Cairo custom Enum.
+   */
+  activeVariant() {
+    const variants = Object.entries(this.variant);
+    const activeVariant = variants.find(item => typeof item[1] !== "undefined");
+    if (typeof activeVariant === "undefined") {
+      return "";
+    }
+    return activeVariant[0];
+  }
+}
+exports.CairoCustomEnum = CairoCustomEnum;

package/dist/utils/calldata/enum/CairoCustomEnum.d.ts

@@ -0,0 +1,38 @@
+export type CairoEnumRaw = {
+    [key: string]: any;
+};
+/**
+ * Class to handle Cairo custom Enum
+ * @param enumContent object containing the variants and its content. Example :
+ *  {Success: 234, Warning: undefined, Error: undefined}.
+ *  Only one variant with a value, object, array.
+ * @returns an instance representing a Cairo custom Enum.
+ * @example
+ * ```typescript
+ * const myCairoEnum = new CairoCustomEnum( {Success: undefined, Warning: "0x7f32ea", Error: undefined})
+ * ```
+ */
+export declare class CairoCustomEnum {
+    /**
+     * direct readonly access to variants of the Cairo Custom Enum.
+     * @returns a value of type any
+     * @example
+     * ```typescript
+     * const successValue = myCairoEnum.variant.Success;
+     */
+    readonly variant: CairoEnumRaw;
+    /**
+     * @param enumContent an object with the variants as keys and the content as value. Only one content shall be defined.
+     */
+    constructor(enumContent: CairoEnumRaw);
+    /**
+     *
+     * @returns the content of the valid variant of a Cairo custom Enum.
+     */
+    unwrap(): any;
+    /**
+     *
+     * @returns the name of the valid variant of a Cairo custom Enum.
+     */
+    activeVariant(): string;
+}

package/dist/utils/calldata/enum/CairoCustomEnum.mjs

@@ -0,0 +1,50 @@
+export class CairoCustomEnum {
+  /**
+   * direct readonly access to variants of the Cairo Custom Enum.
+   * @returns a value of type any
+   * @example
+   * ```typescript
+   * const successValue = myCairoEnum.variant.Success;
+   */
+  variant;
+  /**
+   * @param enumContent an object with the variants as keys and the content as value. Only one content shall be defined.
+   */
+  constructor(enumContent) {
+    const variantsList = Object.values(enumContent);
+    if (variantsList.length === 0) {
+      throw new Error("This Enum must have at least 1 variant");
+    }
+    const nbActiveVariants = variantsList.filter(
+      (content) => typeof content !== "undefined"
+    ).length;
+    if (nbActiveVariants !== 1) {
+      throw new Error("This Enum must have exactly one active variant");
+    }
+    this.variant = enumContent;
+  }
+  /**
+   *
+   * @returns the content of the valid variant of a Cairo custom Enum.
+   */
+  unwrap() {
+    const variants = Object.entries(this.variant);
+    const activeVariant = variants.find((item) => typeof item[1] !== "undefined");
+    if (typeof activeVariant === "undefined") {
+      return void 0;
+    }
+    return activeVariant[1];
+  }
+  /**
+   *
+   * @returns the name of the valid variant of a Cairo custom Enum.
+   */
+  activeVariant() {
+    const variants = Object.entries(this.variant);
+    const activeVariant = variants.find((item) => typeof item[1] !== "undefined");
+    if (typeof activeVariant === "undefined") {
+      return "";
+    }
+    return activeVariant[0];
+  }
+}

package/dist/utils/calldata/enum/CairoOption.cjs

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CairoOptionVariant = exports.CairoOption = void 0;
+const CairoOptionVariant = exports.CairoOptionVariant = {
+  Some: 0,
+  None: 1
+};
+class CairoOption {
+  Some;
+  None;
+  constructor(variant, someContent) {
+    if (!(variant in Object.values(CairoOptionVariant))) {
+      throw new Error("Wrong variant : should be CairoOptionVariant.Some or .None.");
+    }
+    if (variant === CairoOptionVariant.Some) {
+      if (typeof someContent === "undefined") {
+        throw new Error('The creation of a Cairo Option with "Some" variant needs a content as input.');
+      }
+      this.Some = someContent;
+      this.None = void 0;
+    } else {
+      this.Some = void 0;
+      this.None = true;
+    }
+  }
+  /**
+   *
+   * @returns the content of the valid variant of a Cairo custom Enum.
+   *  If None, returns 'undefined'.
+   */
+  unwrap() {
+    if (this.None) {
+      return void 0;
+    }
+    return this.Some;
+  }
+  /**
+   *
+   * @returns true if the valid variant is 'isSome'.
+   */
+  isSome() {
+    return !(typeof this.Some === "undefined");
+  }
+  /**
+   *
+   * @returns true if the valid variant is 'isNone'.
+   */
+  isNone() {
+    return this.None === true;
+  }
+}
+exports.CairoOption = CairoOption;

package/dist/utils/calldata/enum/CairoOption.d.ts

@@ -0,0 +1,37 @@
+import { ValuesType } from '../../../types/helpers/valuesType';
+export declare const CairoOptionVariant: {
+    readonly Some: 0;
+    readonly None: 1;
+};
+export type CairoOptionVariant = ValuesType<typeof CairoOptionVariant>;
+/**
+ * Class to handle Cairo Option
+ * @param variant CairoOptionVariant.Some or CairoOptionVariant.None
+ * @param someContent value of type T.
+ * @returns an instance representing a Cairo Option.
+ * @example
+ * ```typescript
+ * const myOption = new CairoOption<BigNumberish>(CairoOptionVariant.Some, "0x54dda8");
+ * ```
+ */
+export declare class CairoOption<T> {
+    readonly Some?: T;
+    readonly None?: boolean;
+    constructor(variant: CairoOptionVariant | number, someContent?: T);
+    /**
+     *
+     * @returns the content of the valid variant of a Cairo custom Enum.
+     *  If None, returns 'undefined'.
+     */
+    unwrap(): T | undefined;
+    /**
+     *
+     * @returns true if the valid variant is 'isSome'.
+     */
+    isSome(): boolean;
+    /**
+     *
+     * @returns true if the valid variant is 'isNone'.
+     */
+    isNone(): boolean;
+}

package/dist/utils/calldata/enum/CairoOption.mjs

@@ -0,0 +1,50 @@
+export const CairoOptionVariant = {
+  Some: 0,
+  None: 1
+};
+export class CairoOption {
+  Some;
+  None;
+  constructor(variant, someContent) {
+    if (!(variant in Object.values(CairoOptionVariant))) {
+      throw new Error("Wrong variant : should be CairoOptionVariant.Some or .None.");
+    }
+    if (variant === CairoOptionVariant.Some) {
+      if (typeof someContent === "undefined") {
+        throw new Error(
+          'The creation of a Cairo Option with "Some" variant needs a content as input.'
+        );
+      }
+      this.Some = someContent;
+      this.None = void 0;
+    } else {
+      this.Some = void 0;
+      this.None = true;
+    }
+  }
+  /**
+   *
+   * @returns the content of the valid variant of a Cairo custom Enum.
+   *  If None, returns 'undefined'.
+   */
+  unwrap() {
+    if (this.None) {
+      return void 0;
+    }
+    return this.Some;
+  }
+  /**
+   *
+   * @returns true if the valid variant is 'isSome'.
+   */
+  isSome() {
+    return !(typeof this.Some === "undefined");
+  }
+  /**
+   *
+   * @returns true if the valid variant is 'isNone'.
+   */
+  isNone() {
+    return this.None === true;
+  }
+}

package/dist/utils/calldata/enum/CairoResult.cjs

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CairoResultVariant = exports.CairoResult = void 0;
+const CairoResultVariant = exports.CairoResultVariant = {
+  Ok: 0,
+  Err: 1
+};
+class CairoResult {
+  Ok;
+  Err;
+  constructor(variant, resultContent) {
+    if (!(variant in Object.values(CairoResultVariant))) {
+      throw new Error("Wrong variant : should be CairoResultVariant.Ok or .Err.");
+    }
+    if (variant === CairoResultVariant.Ok) {
+      this.Ok = resultContent;
+      this.Err = void 0;
+    } else {
+      this.Ok = void 0;
+      this.Err = resultContent;
+    }
+  }
+  /**
+   *
+   * @returns the content of the valid variant of a Cairo Result.
+   */
+  unwrap() {
+    if (typeof this.Ok !== "undefined") {
+      return this.Ok;
+    }
+    if (typeof this.Err !== "undefined") {
+      return this.Err;
+    }
+    throw new Error("Both Result.Ok and .Err are undefined. Not authorized.");
+  }
+  /**
+   *
+   * @returns true if the valid variant is 'Ok'.
+   */
+  isOk() {
+    return !(typeof this.Ok === "undefined");
+  }
+  /**
+   *
+   * @returns true if the valid variant is 'isErr'.
+   */
+  isErr() {
+    return !(typeof this.Err === "undefined");
+  }
+}
+exports.CairoResult = CairoResult;

package/dist/utils/calldata/enum/CairoResult.d.ts

@@ -0,0 +1,36 @@
+import { ValuesType } from '../../../types/helpers/valuesType';
+export declare const CairoResultVariant: {
+    readonly Ok: 0;
+    readonly Err: 1;
+};
+export type CairoResultVariant = ValuesType<typeof CairoResultVariant>;
+/**
+ * Class to handle Cairo Result
+ * @param variant CairoResultVariant.Ok or CairoResultVariant.Err
+ * @param resultContent value of type T or U.
+ * @returns an instance representing a Cairo Result.
+ * @example
+ * ```typescript
+ * const myOption = new CairoResult<BigNumberish, CustomError>(CairoResultVariant.Ok, "0x54dda8");
+ * ```
+ */
+export declare class CairoResult<T, U> {
+    readonly Ok?: T;
+    readonly Err?: U;
+    constructor(variant: CairoResultVariant | number, resultContent: T | U);
+    /**
+     *
+     * @returns the content of the valid variant of a Cairo Result.
+     */
+    unwrap(): T | U;
+    /**
+     *
+     * @returns true if the valid variant is 'Ok'.
+     */
+    isOk(): boolean;
+    /**
+     *
+     * @returns true if the valid variant is 'isErr'.
+     */
+    isErr(): boolean;
+}

package/dist/utils/calldata/enum/CairoResult.mjs

@@ -0,0 +1,47 @@
+export const CairoResultVariant = {
+  Ok: 0,
+  Err: 1
+};
+export class CairoResult {
+  Ok;
+  Err;
+  constructor(variant, resultContent) {
+    if (!(variant in Object.values(CairoResultVariant))) {
+      throw new Error("Wrong variant : should be CairoResultVariant.Ok or .Err.");
+    }
+    if (variant === CairoResultVariant.Ok) {
+      this.Ok = resultContent;
+      this.Err = void 0;
+    } else {
+      this.Ok = void 0;
+      this.Err = resultContent;
+    }
+  }
+  /**
+   *
+   * @returns the content of the valid variant of a Cairo Result.
+   */
+  unwrap() {
+    if (typeof this.Ok !== "undefined") {
+      return this.Ok;
+    }
+    if (typeof this.Err !== "undefined") {
+      return this.Err;
+    }
+    throw new Error("Both Result.Ok and .Err are undefined. Not authorized.");
+  }
+  /**
+   *
+   * @returns true if the valid variant is 'Ok'.
+   */
+  isOk() {
+    return !(typeof this.Ok === "undefined");
+  }
+  /**
+   *
+   * @returns true if the valid variant is 'isErr'.
+   */
+  isErr() {
+    return !(typeof this.Err === "undefined");
+  }
+}

package/dist/utils/calldata/enum/index.cjs

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _CairoCustomEnum = require("./CairoCustomEnum.cjs");
+Object.keys(_CairoCustomEnum).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _CairoCustomEnum[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _CairoCustomEnum[key];
+    }
+  });
+});
+var _CairoOption = require("./CairoOption.cjs");
+Object.keys(_CairoOption).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _CairoOption[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _CairoOption[key];
+    }
+  });
+});
+var _CairoResult = require("./CairoResult.cjs");
+Object.keys(_CairoResult).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _CairoResult[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _CairoResult[key];
+    }
+  });
+});

package/dist/utils/calldata/enum/index.d.ts

@@ -0,0 +1,3 @@
+export * from './CairoCustomEnum';
+export * from './CairoOption';
+export * from './CairoResult';

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

@@ -0,0 +1,3 @@
+export * from "./CairoCustomEnum.mjs";
+export * from "./CairoOption.mjs";
+export * from "./CairoResult.mjs";

package/dist/utils/calldata/formatter.cjs

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+module.exports = formatter;
+var _num = require("../num.cjs");
+var _shortString = require("../shortString.cjs");
+const guard = {
+  isBN: (data, type, key) => {
+    if (!(0, _num.isBigInt)(data[key])) throw new Error(`Data and formatter mismatch on ${key}:${type[key]}, expected response data ${key}:${data[key]} to be BN instead it is ${typeof data[key]}`);
+  },
+  unknown: (data, type, key) => {
+    throw new Error(`Unhandled formatter type on ${key}:${type[key]} for data ${key}:${data[key]}`);
+  }
+};
+function formatter(data, type, sameType) {
+  return Object.entries(data).reduce((acc, [key, value]) => {
+    const elType = sameType ?? type[key];
+    if (!(key in type) && !sameType) {
+      acc[key] = value;
+      return acc;
+    }
+    if (elType === "string") {
+      if (Array.isArray(data[key])) {
+        const arrayStr = formatter(data[key], data[key].map(_ => elType));
+        acc[key] = Object.values(arrayStr).join("");
+        return acc;
+      }
+      guard.isBN(data, type, key);
+      acc[key] = (0, _shortString.decodeShortString)(value);
+      return acc;
+    }
+    if (elType === "number") {
+      guard.isBN(data, type, key);
+      acc[key] = Number(value);
+      return acc;
+    }
+    if (typeof elType === "function") {
+      acc[key] = elType(value);
+      return acc;
+    }
+    if (Array.isArray(elType)) {
+      const arrayObj = formatter(data[key], elType, elType[0]);
+      acc[key] = Object.values(arrayObj);
+      return acc;
+    }
+    if (typeof elType === "object") {
+      acc[key] = formatter(data[key], elType);
+      return acc;
+    }
+    guard.unknown(data, type, key);
+    return acc;
+  }, {});
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Formats the given data based on the provided type definition.
+ *
+ * @param {any} data - The data to be formatted.
+ * @param {any} type - The type definition for the data.
+ * @param {any} [sameType] - The same type definition to be used (optional).
+ * @returns - The formatted data.
+ */
+export default function formatter(data: Record<string, any>, type: Record<string, any>, sameType?: any): Record<string, any>;

package/dist/utils/calldata/formatter.mjs

@@ -0,0 +1,58 @@
+import { isBigInt } from "../num.mjs";
+import { decodeShortString } from "../shortString.mjs";
+const guard = {
+  isBN: (data, type, key) => {
+    if (!isBigInt(data[key]))
+      throw new Error(
+        `Data and formatter mismatch on ${key}:${type[key]}, expected response data ${key}:${data[key]} to be BN instead it is ${typeof data[key]}`
+      );
+  },
+  unknown: (data, type, key) => {
+    throw new Error(`Unhandled formatter type on ${key}:${type[key]} for data ${key}:${data[key]}`);
+  }
+};
+export default function formatter(data, type, sameType) {
+  return Object.entries(data).reduce(
+    (acc, [key, value]) => {
+      const elType = sameType ?? type[key];
+      if (!(key in type) && !sameType) {
+        acc[key] = value;
+        return acc;
+      }
+      if (elType === "string") {
+        if (Array.isArray(data[key])) {
+          const arrayStr = formatter(
+            data[key],
+            data[key].map((_) => elType)
+          );
+          acc[key] = Object.values(arrayStr).join("");
+          return acc;
+        }
+        guard.isBN(data, type, key);
+        acc[key] = decodeShortString(value);
+        return acc;
+      }
+      if (elType === "number") {
+        guard.isBN(data, type, key);
+        acc[key] = Number(value);
+        return acc;
+      }
+      if (typeof elType === "function") {
+        acc[key] = elType(value);
+        return acc;
+      }
+      if (Array.isArray(elType)) {
+        const arrayObj = formatter(data[key], elType, elType[0]);
+        acc[key] = Object.values(arrayObj);
+        return acc;
+      }
+      if (typeof elType === "object") {
+        acc[key] = formatter(data[key], elType);
+        return acc;
+      }
+      guard.unknown(data, type, key);
+      return acc;
+    },
+    {}
+  );
+}