starknet 6.9.0 → 6.10.1

package/dist/utils/address.cjs

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addAddressPadding = addAddressPadding;
+exports.getChecksumAddress = getChecksumAddress;
+exports.validateAndParseAddress = validateAndParseAddress;
+exports.validateChecksumAddress = validateChecksumAddress;
+var _utils = require("@noble/curves/abstract/utils");
+var _constants = require("../constants.cjs");
+var _encode = require("./encode.cjs");
+var _hash = require("./hash/index.cjs");
+var _num = require("./num.cjs");
+function addAddressPadding(address) {
+  const hex = (0, _num.toHex)((0, _encode.addHexPrefix)(address.toString()));
+  const padded = (0, _encode.removeHexPrefix)(hex).padStart(64, "0");
+  return (0, _encode.addHexPrefix)(padded);
+}
+function validateAndParseAddress(address) {
+  const result = addAddressPadding(address);
+  if (!result.match(/^(0x)?[0-9a-fA-F]{64}$/)) {
+    throw new Error("Invalid Address Format");
+  }
+  (0, _num.assertInRange)(result, _constants.ZERO, _constants.ADDR_BOUND - 1n, "Starknet Address");
+  return result;
+}
+function getChecksumAddress(address) {
+  const chars = (0, _encode.removeHexPrefix)(validateAndParseAddress(address)).toLowerCase().split("");
+  const hex = (0, _encode.removeHexPrefix)((0, _hash.keccakBn)(address));
+  const hashed = (0, _utils.hexToBytes)(hex.padStart(64, "0"));
+  for (let i = 0; i < chars.length; i += 2) {
+    if (hashed[i >> 1] >> 4 >= 8) {
+      chars[i] = chars[i].toUpperCase();
+    }
+    if ((hashed[i >> 1] & 15) >= 8) {
+      chars[i + 1] = chars[i + 1].toUpperCase();
+    }
+  }
+  return (0, _encode.addHexPrefix)(chars.join(""));
+}
+function validateChecksumAddress(address) {
+  return getChecksumAddress(address) === address;
+}

package/dist/utils/address.d.ts

@@ -0,0 +1,55 @@
+import { BigNumberish } from '../types';
+/**
+ * Format a hex number to '0x' and 64 characters, adding leading zeros if necessary.
+ *
+ * @param {BigNumberish} address
+ * @returns {string} Hex string : 0x followed by 64 characters. No upper case characters in the response.
+ * @example
+ * ```typescript
+ * const address = "0x90591d9fa3efc87067d95a643f8455e0b8190eb8cb7bfd39e4fb7571fdf";
+ * const result = addAddressPadding(address);
+ * // result = "0x0000090591d9fa3efc87067d95a643f8455e0b8190eb8cb7bfd39e4fb7571fdf"
+ * ```
+ */
+export declare function addAddressPadding(address: BigNumberish): string;
+/**
+ * Check the validity of a Starknet address, and format it as a hex number : '0x' and 64 characters, adding leading zeros if necessary.
+ *
+ * @param {BigNumberish} address
+ * @returns {string} Hex string : 0x followed by 64 characters. No upper case characters in the response.
+ * @throws address argument must be a valid address inside the address range bound
+ * @example
+ * ```typescript
+ * const address = "0x90591d9fa3efc87067d95a643f8455e0b8190eb8cb7bfd39e4fb7571fdf";
+ * const result = validateAndParseAddress(address);
+ * // result = "0x0000090591d9fa3efc87067d95a643f8455e0b8190eb8cb7bfd39e4fb7571fdf"
+ * ```
+ */
+export declare function validateAndParseAddress(address: BigNumberish): string;
+/**
+ * Convert an address to her checksum representation which uses a specific pattern of uppercase and lowercase letters within
+ * a given address to reduce the risk of errors introduced from typing an address or cut and paste issues.
+ * @param {BigNumberish} address
+ * @returns {string} Hex string : 0x followed by 64 characters. Mix of uppercase and lowercase
+ * @example
+ * ```typescript
+ * const address = "0x90591d9fa3efc87067d95a643f8455e0b8190eb8cb7bfd39e4fb7571fdf";
+ * const result = getChecksumAddress(address);
+ * // result = "0x0000090591D9fA3EfC87067d95a643f8455E0b8190eb8Cb7bFd39e4fb7571fDF"
+ * ```
+ */
+export declare function getChecksumAddress(address: BigNumberish): string;
+/**
+ * If the casing of an address is mixed, it is a Checksum Address, which uses a specific pattern of uppercase and lowercase letters within
+ * a given address to reduce the risk of errors introduced from typing an address or cut and paste issues.
+ *
+ * @param address string
+ * @returns true if the ChecksumAddress is valid
+ * @example
+ * ```typescript
+ * const address = "0x0000090591D9fA3EfC87067d95a643f8455E0b8190eb8Cb7bFd39e4fb7571fDF";
+ * const result = validateChecksumAddress(address);
+ * // result = true
+ * ```
+ */
+export declare function validateChecksumAddress(address: string): boolean;

package/dist/utils/address.mjs

@@ -0,0 +1,35 @@
+import { hexToBytes } from "@noble/curves/abstract/utils";
+import { ADDR_BOUND, ZERO } from "../constants.mjs";
+import { addHexPrefix, removeHexPrefix } from "./encode.mjs";
+import { keccakBn } from "./hash/index.mjs";
+import { assertInRange, toHex } from "./num.mjs";
+export function addAddressPadding(address) {
+  const hex = toHex(addHexPrefix(address.toString()));
+  const padded = removeHexPrefix(hex).padStart(64, "0");
+  return addHexPrefix(padded);
+}
+export function validateAndParseAddress(address) {
+  const result = addAddressPadding(address);
+  if (!result.match(/^(0x)?[0-9a-fA-F]{64}$/)) {
+    throw new Error("Invalid Address Format");
+  }
+  assertInRange(result, ZERO, ADDR_BOUND - 1n, "Starknet Address");
+  return result;
+}
+export function getChecksumAddress(address) {
+  const chars = removeHexPrefix(validateAndParseAddress(address)).toLowerCase().split("");
+  const hex = removeHexPrefix(keccakBn(address));
+  const hashed = hexToBytes(hex.padStart(64, "0"));
+  for (let i = 0; i < chars.length; i += 2) {
+    if (hashed[i >> 1] >> 4 >= 8) {
+      chars[i] = chars[i].toUpperCase();
+    }
+    if ((hashed[i >> 1] & 15) >= 8) {
+      chars[i + 1] = chars[i + 1].toUpperCase();
+    }
+  }
+  return addHexPrefix(chars.join(""));
+}
+export function validateChecksumAddress(address) {
+  return getChecksumAddress(address) === address;
+}

package/dist/utils/assert.cjs

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+module.exports = assert;
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message || "Assertion failure");
+  }
+}

package/dist/utils/assert.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Asserts that the given condition is true, otherwise throws an error with an optional message.
+ * @param {any} condition - The condition to check.
+ * @param {string} [message] - The optional message to include in the error.
+ * @throws {Error} Throws an error if the condition is false.
+ * @example
+ * ```typescript
+ * const address = '0xa7ee790591d9fa3efc87067d95a643f8455e0b8190eb8cb7bfd39e4fb7571fdf';
+ * assert(/^(0x)?[0-9a-fA-F]{64}$/.test(address), 'Invalid address format');
+ * ```
+ */
+export default function assert(condition: boolean, message?: string): asserts condition;

package/dist/utils/assert.mjs

@@ -0,0 +1,5 @@
+export default function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message || "Assertion failure");
+  }
+}

package/dist/utils/cairoDataTypes/felt.cjs

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CairoFelt = CairoFelt;
+var _num = require("../num.cjs");
+var _shortString = require("../shortString.cjs");
+function CairoFelt(it) {
+  if ((0, _num.isBigInt)(it) || Number.isInteger(it)) {
+    return it.toString();
+  }
+  if ((0, _shortString.isString)(it)) {
+    if ((0, _num.isHex)(it)) {
+      return BigInt(it).toString();
+    }
+    if ((0, _shortString.isText)(it)) {
+      if (!(0, _shortString.isShortString)(it)) {
+        throw new Error(`${it} is a long string > 31 chars. Please split it into an array of short strings.`);
+      }
+      return BigInt((0, _shortString.encodeShortString)(it)).toString();
+    }
+    if ((0, _num.isStringWholeNumber)(it)) {
+      return it;
+    }
+  }
+  if ((0, _num.isBoolean)(it)) {
+    return `${+it}`;
+  }
+  throw new Error(`${it} can't be computed by felt()`);
+}

package/dist/utils/cairoDataTypes/felt.d.ts

@@ -0,0 +1,6 @@
+import { BigNumberish } from '../num';
+/**
+ * Create felt Cairo type (cairo type helper)
+ * @returns format: felt-string
+ */
+export declare function CairoFelt(it: BigNumberish): string;

package/dist/utils/cairoDataTypes/felt.mjs

@@ -0,0 +1,27 @@
+import { isBigInt, isBoolean, isHex, isStringWholeNumber } from "../num.mjs";
+import { encodeShortString, isShortString, isString, isText } from "../shortString.mjs";
+export function CairoFelt(it) {
+  if (isBigInt(it) || Number.isInteger(it)) {
+    return it.toString();
+  }
+  if (isString(it)) {
+    if (isHex(it)) {
+      return BigInt(it).toString();
+    }
+    if (isText(it)) {
+      if (!isShortString(it)) {
+        throw new Error(
+          `${it} is a long string > 31 chars. Please split it into an array of short strings.`
+        );
+      }
+      return BigInt(encodeShortString(it)).toString();
+    }
+    if (isStringWholeNumber(it)) {
+      return it;
+    }
+  }
+  if (isBoolean(it)) {
+    return `${+it}`;
+  }
+  throw new Error(`${it} can't be computed by felt()`);
+}

package/dist/utils/cairoDataTypes/uint256.cjs

@@ -0,0 +1,113 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UINT_256_MIN = exports.UINT_256_MAX = exports.UINT_256_LOW_MIN = exports.UINT_256_LOW_MAX = exports.UINT_256_HIGH_MIN = exports.UINT_256_HIGH_MAX = exports.UINT_128_MAX = exports.CairoUint256 = void 0;
+var _encode = require("../encode.cjs");
+var _felt = require("./felt.cjs");
+const UINT_128_MAX = exports.UINT_128_MAX = (1n << 128n) - 1n;
+const UINT_256_MAX = exports.UINT_256_MAX = (1n << 256n) - 1n;
+const UINT_256_MIN = exports.UINT_256_MIN = 0n;
+const UINT_256_LOW_MAX = exports.UINT_256_LOW_MAX = 340282366920938463463374607431768211455n;
+const UINT_256_HIGH_MAX = exports.UINT_256_HIGH_MAX = 340282366920938463463374607431768211455n;
+const UINT_256_LOW_MIN = exports.UINT_256_LOW_MIN = 0n;
+const UINT_256_HIGH_MIN = exports.UINT_256_HIGH_MIN = 0n;
+class CairoUint256 {
+  low;
+  high;
+  static abiSelector = "core::integer::u256";
+  constructor(...arr) {
+    if (typeof arr[0] === "object" && arr.length === 1 && "low" in arr[0] && "high" in arr[0]) {
+      const props = CairoUint256.validateProps(arr[0].low, arr[0].high);
+      this.low = props.low;
+      this.high = props.high;
+    } else if (arr.length === 1) {
+      const bigInt = CairoUint256.validate(arr[0]);
+      this.low = bigInt & UINT_128_MAX;
+      this.high = bigInt >> 128n;
+    } else if (arr.length === 2) {
+      const props = CairoUint256.validateProps(arr[0], arr[1]);
+      this.low = props.low;
+      this.high = props.high;
+    } else {
+      throw Error("Incorrect constructor parameters");
+    }
+  }
+  /**
+   * Validate if BigNumberish can be represented as Unit256
+   */
+  static validate(bigNumberish) {
+    const bigInt = BigInt(bigNumberish);
+    if (bigInt < UINT_256_MIN) throw Error("bigNumberish is smaller than UINT_256_MIN");
+    if (bigInt > UINT_256_MAX) throw new Error("bigNumberish is bigger than UINT_256_MAX");
+    return bigInt;
+  }
+  /**
+   * Validate if low and high can be represented as Unit256
+   */
+  static validateProps(low, high) {
+    const bigIntLow = BigInt(low);
+    const bigIntHigh = BigInt(high);
+    if (bigIntLow < UINT_256_LOW_MIN || bigIntLow > UINT_256_LOW_MAX) {
+      throw new Error("low is out of range UINT_256_LOW_MIN - UINT_256_LOW_MAX");
+    }
+    if (bigIntHigh < UINT_256_HIGH_MIN || bigIntHigh > UINT_256_HIGH_MAX) {
+      throw new Error("high is out of range UINT_256_HIGH_MIN - UINT_256_HIGH_MAX");
+    }
+    return {
+      low: bigIntLow,
+      high: bigIntHigh
+    };
+  }
+  /**
+   * Check if BigNumberish can be represented as Unit256
+   */
+  static is(bigNumberish) {
+    try {
+      CairoUint256.validate(bigNumberish);
+    } catch (error) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Check if provided abi type is this data type
+   */
+  static isAbiType(abiType) {
+    return abiType === CairoUint256.abiSelector;
+  }
+  /**
+   * Return bigint representation
+   */
+  toBigInt() {
+    return (this.high << 128n) + this.low;
+  }
+  /**
+   * Return Uint256 structure with HexString props
+   * {low: HexString, high: HexString}
+   */
+  toUint256HexString() {
+    return {
+      low: (0, _encode.addHexPrefix)(this.low.toString(16)),
+      high: (0, _encode.addHexPrefix)(this.high.toString(16))
+    };
+  }
+  /**
+   * Return Uint256 structure with DecimalString props
+   * {low: DecString, high: DecString}
+   */
+  toUint256DecimalString() {
+    return {
+      low: this.low.toString(10),
+      high: this.high.toString(10)
+    };
+  }
+  /**
+   * Return api requests representation witch is felt array
+   */
+  toApiRequest() {
+    return [(0, _felt.CairoFelt)(this.low), (0, _felt.CairoFelt)(this.high)];
+  }
+}
+exports.CairoUint256 = CairoUint256;

package/dist/utils/cairoDataTypes/uint256.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Singular class handling cairo u256 data type
+ */
+import { BigNumberish, Uint256 } from '../../types';
+export declare const UINT_128_MAX: bigint;
+export declare const UINT_256_MAX: bigint;
+export declare const UINT_256_MIN = 0n;
+export declare const UINT_256_LOW_MAX = 340282366920938463463374607431768211455n;
+export declare const UINT_256_HIGH_MAX = 340282366920938463463374607431768211455n;
+export declare const UINT_256_LOW_MIN = 0n;
+export declare const UINT_256_HIGH_MIN = 0n;
+export declare class CairoUint256 {
+    low: bigint;
+    high: bigint;
+    static abiSelector: string;
+    /**
+     * Default constructor (Lib usage)
+     * @param bigNumberish BigNumberish value representing uin256
+     */
+    constructor(bigNumberish: BigNumberish);
+    /**
+     * Direct props initialization (Api response)
+     */
+    constructor(low: BigNumberish, high: BigNumberish);
+    /**
+     * Initialization from Uint256 object
+     */
+    constructor(uint256: Uint256);
+    /**
+     * Validate if BigNumberish can be represented as Unit256
+     */
+    static validate(bigNumberish: BigNumberish): bigint;
+    /**
+     * Validate if low and high can be represented as Unit256
+     */
+    static validateProps(low: BigNumberish, high: BigNumberish): {
+        low: bigint;
+        high: bigint;
+    };
+    /**
+     * Check if BigNumberish can be represented as Unit256
+     */
+    static is(bigNumberish: BigNumberish): boolean;
+    /**
+     * Check if provided abi type is this data type
+     */
+    static isAbiType(abiType: string): boolean;
+    /**
+     * Return bigint representation
+     */
+    toBigInt(): bigint;
+    /**
+     * Return Uint256 structure with HexString props
+     * {low: HexString, high: HexString}
+     */
+    toUint256HexString(): {
+        low: string;
+        high: string;
+    };
+    /**
+     * Return Uint256 structure with DecimalString props
+     * {low: DecString, high: DecString}
+     */
+    toUint256DecimalString(): {
+        low: string;
+        high: string;
+    };
+    /**
+     * Return api requests representation witch is felt array
+     */
+    toApiRequest(): string[];
+}

package/dist/utils/cairoDataTypes/uint256.mjs

@@ -0,0 +1,103 @@
+import { addHexPrefix } from "../encode.mjs";
+import { CairoFelt } from "./felt.mjs";
+export const UINT_128_MAX = (1n << 128n) - 1n;
+export const UINT_256_MAX = (1n << 256n) - 1n;
+export const UINT_256_MIN = 0n;
+export const UINT_256_LOW_MAX = 340282366920938463463374607431768211455n;
+export const UINT_256_HIGH_MAX = 340282366920938463463374607431768211455n;
+export const UINT_256_LOW_MIN = 0n;
+export const UINT_256_HIGH_MIN = 0n;
+export class CairoUint256 {
+  low;
+  high;
+  static abiSelector = "core::integer::u256";
+  constructor(...arr) {
+    if (typeof arr[0] === "object" && arr.length === 1 && "low" in arr[0] && "high" in arr[0]) {
+      const props = CairoUint256.validateProps(arr[0].low, arr[0].high);
+      this.low = props.low;
+      this.high = props.high;
+    } else if (arr.length === 1) {
+      const bigInt = CairoUint256.validate(arr[0]);
+      this.low = bigInt & UINT_128_MAX;
+      this.high = bigInt >> 128n;
+    } else if (arr.length === 2) {
+      const props = CairoUint256.validateProps(arr[0], arr[1]);
+      this.low = props.low;
+      this.high = props.high;
+    } else {
+      throw Error("Incorrect constructor parameters");
+    }
+  }
+  /**
+   * Validate if BigNumberish can be represented as Unit256
+   */
+  static validate(bigNumberish) {
+    const bigInt = BigInt(bigNumberish);
+    if (bigInt < UINT_256_MIN) throw Error("bigNumberish is smaller than UINT_256_MIN");
+    if (bigInt > UINT_256_MAX) throw new Error("bigNumberish is bigger than UINT_256_MAX");
+    return bigInt;
+  }
+  /**
+   * Validate if low and high can be represented as Unit256
+   */
+  static validateProps(low, high) {
+    const bigIntLow = BigInt(low);
+    const bigIntHigh = BigInt(high);
+    if (bigIntLow < UINT_256_LOW_MIN || bigIntLow > UINT_256_LOW_MAX) {
+      throw new Error("low is out of range UINT_256_LOW_MIN - UINT_256_LOW_MAX");
+    }
+    if (bigIntHigh < UINT_256_HIGH_MIN || bigIntHigh > UINT_256_HIGH_MAX) {
+      throw new Error("high is out of range UINT_256_HIGH_MIN - UINT_256_HIGH_MAX");
+    }
+    return { low: bigIntLow, high: bigIntHigh };
+  }
+  /**
+   * Check if BigNumberish can be represented as Unit256
+   */
+  static is(bigNumberish) {
+    try {
+      CairoUint256.validate(bigNumberish);
+    } catch (error) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Check if provided abi type is this data type
+   */
+  static isAbiType(abiType) {
+    return abiType === CairoUint256.abiSelector;
+  }
+  /**
+   * Return bigint representation
+   */
+  toBigInt() {
+    return (this.high << 128n) + this.low;
+  }
+  /**
+   * Return Uint256 structure with HexString props
+   * {low: HexString, high: HexString}
+   */
+  toUint256HexString() {
+    return {
+      low: addHexPrefix(this.low.toString(16)),
+      high: addHexPrefix(this.high.toString(16))
+    };
+  }
+  /**
+   * Return Uint256 structure with DecimalString props
+   * {low: DecString, high: DecString}
+   */
+  toUint256DecimalString() {
+    return {
+      low: this.low.toString(10),
+      high: this.high.toString(10)
+    };
+  }
+  /**
+   * Return api requests representation witch is felt array
+   */
+  toApiRequest() {
+    return [CairoFelt(this.low), CairoFelt(this.high)];
+  }
+}

package/dist/utils/cairoDataTypes/uint512.cjs

@@ -0,0 +1,125 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UINT_512_MIN = exports.UINT_512_MAX = exports.UINT_128_MIN = exports.CairoUint512 = void 0;
+var _encode = require("../encode.cjs");
+var _felt = require("./felt.cjs");
+var _uint = require("./uint256.cjs");
+const UINT_512_MAX = exports.UINT_512_MAX = (1n << 512n) - 1n;
+const UINT_512_MIN = exports.UINT_512_MIN = 0n;
+const UINT_128_MIN = exports.UINT_128_MIN = 0n;
+class CairoUint512 {
+  limb0;
+  limb1;
+  limb2;
+  limb3;
+  static abiSelector = "core::integer::u512";
+  constructor(...arr) {
+    if (typeof arr[0] === "object" && arr.length === 1 && "limb0" in arr[0] && "limb1" in arr[0] && "limb2" in arr[0] && "limb3" in arr[0]) {
+      const props = CairoUint512.validateProps(arr[0].limb0, arr[0].limb1, arr[0].limb2, arr[0].limb3);
+      this.limb0 = props.limb0;
+      this.limb1 = props.limb1;
+      this.limb2 = props.limb2;
+      this.limb3 = props.limb3;
+    } else if (arr.length === 1) {
+      const bigInt = CairoUint512.validate(arr[0]);
+      this.limb0 = bigInt & _uint.UINT_128_MAX;
+      this.limb1 = (bigInt & _uint.UINT_128_MAX << 128n) >> 128n;
+      this.limb2 = (bigInt & _uint.UINT_128_MAX << 256n) >> 256n;
+      this.limb3 = bigInt >> 384n;
+    } else if (arr.length === 4) {
+      const props = CairoUint512.validateProps(arr[0], arr[1], arr[2], arr[3]);
+      this.limb0 = props.limb0;
+      this.limb1 = props.limb1;
+      this.limb2 = props.limb2;
+      this.limb3 = props.limb3;
+    } else {
+      throw Error("Incorrect Uint512 constructor parameters");
+    }
+  }
+  /**
+   * Validate if BigNumberish can be represented as Uint512
+   */
+  static validate(bigNumberish) {
+    const bigInt = BigInt(bigNumberish);
+    if (bigInt < UINT_512_MIN) throw Error("bigNumberish is smaller than UINT_512_MIN.");
+    if (bigInt > UINT_512_MAX) throw Error("bigNumberish is bigger than UINT_512_MAX.");
+    return bigInt;
+  }
+  /**
+   * Validate if limbs can be represented as Uint512
+   */
+  static validateProps(limb0, limb1, limb2, limb3) {
+    const l0 = BigInt(limb0);
+    const l1 = BigInt(limb1);
+    const l2 = BigInt(limb2);
+    const l3 = BigInt(limb3);
+    [l0, l1, l2, l3].forEach((value, index) => {
+      if (value < UINT_128_MIN || value > _uint.UINT_128_MAX) {
+        throw Error(`limb${index} is not in the range of a u128 number`);
+      }
+    });
+    return {
+      limb0: l0,
+      limb1: l1,
+      limb2: l2,
+      limb3: l3
+    };
+  }
+  /**
+   * Check if BigNumberish can be represented as Uint512
+   */
+  static is(bigNumberish) {
+    try {
+      CairoUint512.validate(bigNumberish);
+    } catch (error) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Check if provided abi type is this data type
+   */
+  static isAbiType(abiType) {
+    return abiType === CairoUint512.abiSelector;
+  }
+  /**
+   * Return bigint representation
+   */
+  toBigInt() {
+    return (this.limb3 << 384n) + (this.limb2 << 256n) + (this.limb1 << 128n) + this.limb0;
+  }
+  /**
+   * Return Uint512 structure with HexString props
+   * limbx: HexString
+   */
+  toUint512HexString() {
+    return {
+      limb0: (0, _encode.addHexPrefix)(this.limb0.toString(16)),
+      limb1: (0, _encode.addHexPrefix)(this.limb1.toString(16)),
+      limb2: (0, _encode.addHexPrefix)(this.limb2.toString(16)),
+      limb3: (0, _encode.addHexPrefix)(this.limb3.toString(16))
+    };
+  }
+  /**
+   * Return Uint512 structure with DecimalString props
+   * limbx DecString
+   */
+  toUint512DecimalString() {
+    return {
+      limb0: this.limb0.toString(10),
+      limb1: this.limb1.toString(10),
+      limb2: this.limb2.toString(10),
+      limb3: this.limb3.toString(10)
+    };
+  }
+  /**
+   * Return api requests representation witch is felt array
+   */
+  toApiRequest() {
+    return [(0, _felt.CairoFelt)(this.limb0), (0, _felt.CairoFelt)(this.limb1), (0, _felt.CairoFelt)(this.limb2), (0, _felt.CairoFelt)(this.limb3)];
+  }
+}
+exports.CairoUint512 = CairoUint512;