starknet 6.9.0 → 6.10.1

package/dist/utils/calldata/validate.mjs

@@ -0,0 +1,315 @@
+import {
+  Literal,
+  Uint
+} from "../../types/index.mjs";
+import assert from "../assert.mjs";
+import { CairoUint256 } from "../cairoDataTypes/uint256.mjs";
+import { CairoUint512 } from "../cairoDataTypes/uint512.mjs";
+import { isBigInt, isBoolean, isHex, isNumber, toBigInt } from "../num.mjs";
+import { isLongText, isString } from "../shortString.mjs";
+import {
+  getArrayType,
+  isLen,
+  isTypeArray,
+  isTypeBool,
+  isTypeByteArray,
+  isTypeBytes31,
+  isTypeEnum,
+  isTypeFelt,
+  isTypeLiteral,
+  isTypeNonZero,
+  isTypeOption,
+  isTypeResult,
+  isTypeStruct,
+  isTypeTuple,
+  isTypeUint
+} from "./cairo.mjs";
+const validateFelt = (parameter, input) => {
+  assert(
+    isString(parameter) || isNumber(parameter) || isBigInt(parameter),
+    `Validate: arg ${input.name} should be a felt typed as (String, Number or BigInt)`
+  );
+  if (isString(parameter) && !isHex(parameter)) return;
+  const param = BigInt(parameter.toString(10));
+  assert(
+    // 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) => {
+  assert(isString(parameter), `Validate: arg ${input.name} should be a string.`);
+  assert(
+    parameter.length < 32,
+    `Validate: arg ${input.name} cairo typed ${input.type} should be a string of less than 32 characters.`
+  );
+};
+const validateByteArray = (parameter, input) => {
+  assert(isString(parameter), `Validate: arg ${input.name} should be a string.`);
+};
+const validateUint = (parameter, input) => {
+  if (isNumber(parameter)) {
+    assert(
+      parameter <= Number.MAX_SAFE_INTEGER,
+      `Validation: Parameter is to large to be typed as Number use (BigInt or String)`
+    );
+  }
+  assert(
+    isString(parameter) || isNumber(parameter) || 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 Uint.u256:
+      param = new CairoUint256(parameter).toBigInt();
+      break;
+    case Uint.u512:
+      param = new CairoUint512(parameter).toBigInt();
+      break;
+    default:
+      param = toBigInt(parameter);
+  }
+  switch (input.type) {
+    case Uint.u8:
+      assert(
+        param >= 0n && param <= 255n,
+        `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0 - 255]`
+      );
+      break;
+    case Uint.u16:
+      assert(
+        param >= 0n && param <= 65535n,
+        `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 65535]`
+      );
+      break;
+    case Uint.u32:
+      assert(
+        param >= 0n && param <= 4294967295n,
+        `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 4294967295]`
+      );
+      break;
+    case Uint.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 Uint.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 Uint.u256:
+      assert(
+        param >= 0n && param <= 2n ** 256n - 1n,
+        `Validate: arg ${input.name} is ${input.type} 0 - 2^256-1`
+      );
+      break;
+    case Uint.u512:
+      assert(CairoUint512.is(param), `Validate: arg ${input.name} is ${input.type} 0 - 2^512-1`);
+      break;
+    case Literal.ClassHash:
+      assert(
+        // 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 Literal.ContractAddress:
+      assert(
+        // 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 Literal.Secp256k1Point: {
+      assert(
+        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) => {
+  assert(
+    isBoolean(parameter),
+    `Validate: arg ${input.name} of cairo type ${input.type} should be type (Boolean)`
+  );
+};
+const validateStruct = (parameter, input, structs) => {
+  if (input.type === Uint.u256 || input.type === Uint.u512) {
+    validateUint(parameter, input);
+    return;
+  }
+  if (input.type === "core::starknet::eth_address::EthAddress") {
+    assert(
+      typeof parameter !== "object",
+      `EthAddress type is waiting a BigNumberish. Got ${parameter}`
+    );
+    const param = BigInt(parameter.toString(10));
+    assert(
+      // 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;
+  }
+  assert(
+    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 }) => {
+    assert(
+      Object.keys(parameter).includes(name),
+      `Validate: arg ${input.name} should have a property ${name}`
+    );
+  });
+};
+const validateEnum = (parameter, input) => {
+  assert(
+    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 (isTypeOption(input.type) && keys.includes("isSome") && keys.includes("isNone")) {
+    return;
+  }
+  if (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) => {
+  assert(
+    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 = getArrayType(input.type);
+  if (isTypeFelt(baseType) && isLongText(parameter)) {
+    return;
+  }
+  assert(Array.isArray(parameter), `Validate: arg ${input.name} should be an Array`);
+  switch (true) {
+    case isTypeFelt(baseType):
+      parameter.forEach((param) => validateFelt(param, input));
+      break;
+    case isTypeTuple(baseType):
+      parameter.forEach((it) => validateTuple(it, { name: input.name, type: baseType }));
+      break;
+    case isTypeArray(baseType):
+      parameter.forEach(
+        (param) => validateArray(param, { name: "", type: baseType }, structs, enums)
+      );
+      break;
+    case isTypeStruct(baseType, structs):
+      parameter.forEach(
+        (it) => validateStruct(it, { name: input.name, type: baseType }, structs)
+      );
+      break;
+    case isTypeEnum(baseType, enums):
+      parameter.forEach((it) => validateEnum(it, { name: input.name, type: baseType }));
+      break;
+    case (isTypeUint(baseType) || isTypeLiteral(baseType)):
+      parameter.forEach((param) => validateUint(param, { name: "", type: baseType }));
+      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}`
+      );
+  }
+};
+const validateNonZero = (parameter, input) => {
+  const baseType = getArrayType(input.type);
+  assert(
+    isTypeUint(baseType) && baseType !== CairoUint512.abiSelector || isTypeFelt(baseType),
+    `Validate: ${input.name} type is not authorized for NonZero type.`
+  );
+  switch (true) {
+    case isTypeFelt(baseType):
+      validateFelt(parameter, input);
+      assert(
+        BigInt(parameter.toString(10)) > 0,
+        "Validate: value 0 is not authorized in NonZero felt252 type."
+      );
+      break;
+    case isTypeUint(baseType):
+      validateUint(parameter, { name: "", type: baseType });
+      switch (input.type) {
+        case Uint.u256:
+          assert(
+            new CairoUint256(parameter).toBigInt() > 0,
+            "Validate: value 0 is not authorized in NonZero uint256 type."
+          );
+          break;
+        default:
+          assert(
+            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}`
+      );
+  }
+};
+export default function validateFields(abiMethod, args, structs, enums) {
+  abiMethod.inputs.reduce((acc, input) => {
+    const parameter = args[acc];
+    switch (true) {
+      case isLen(input.name):
+        return acc;
+      case isTypeFelt(input.type):
+        validateFelt(parameter, input);
+        break;
+      case isTypeBytes31(input.type):
+        validateBytes31(parameter, input);
+        break;
+      case (isTypeUint(input.type) || isTypeLiteral(input.type)):
+        validateUint(parameter, input);
+        break;
+      case isTypeBool(input.type):
+        validateBool(parameter, input);
+        break;
+      case isTypeByteArray(input.type):
+        validateByteArray(parameter, input);
+        break;
+      case isTypeArray(input.type):
+        validateArray(parameter, input, structs, enums);
+        break;
+      case isTypeStruct(input.type, structs):
+        validateStruct(parameter, input, structs);
+        break;
+      case isTypeEnum(input.type, enums):
+        validateEnum(parameter, input);
+        break;
+      case isTypeTuple(input.type):
+        validateTuple(parameter, input);
+        break;
+      case 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/contract.cjs

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.contractClassResponseToLegacyCompiledContract = contractClassResponseToLegacyCompiledContract;
+exports.extractContractHashes = extractContractHashes;
+exports.isSierra = isSierra;
+var _hash = require("./hash/index.cjs");
+var _json = require("./json.cjs");
+var _stark = require("./stark.cjs");
+var _shortString = require("./shortString.cjs");
+function isSierra(contract) {
+  const compiledContract = (0, _shortString.isString)(contract) ? (0, _json.parse)(contract) : contract;
+  return "sierra_program" in compiledContract;
+}
+function extractContractHashes(payload) {
+  const response = {
+    ...payload
+  };
+  if (isSierra(payload.contract)) {
+    if (!payload.compiledClassHash && payload.casm) {
+      response.compiledClassHash = (0, _hash.computeCompiledClassHash)(payload.casm);
+    }
+    if (!response.compiledClassHash) throw new Error("Extract compiledClassHash failed, provide (CairoAssembly).casm file or compiledClassHash");
+  }
+  response.classHash = payload.classHash ?? (0, _hash.computeContractClassHash)(payload.contract);
+  if (!response.classHash) throw new Error("Extract classHash failed, provide (CompiledContract).json file or classHash");
+  return response;
+}
+function contractClassResponseToLegacyCompiledContract(ccr) {
+  if (isSierra(ccr)) {
+    throw Error("ContractClassResponse need to be LegacyContractClass (cairo0 response class)");
+  }
+  const contract = ccr;
+  return {
+    ...contract,
+    program: (0, _stark.decompressProgram)(contract.program)
+  };
+}

package/dist/utils/contract.d.ts

@@ -0,0 +1,37 @@
+import { ContractClassResponse } from '../types';
+import { CairoContract, CompiledSierra, LegacyCompiledContract, SierraContractClass } from '../types/lib/contract/index';
+import { CompleteDeclareContractPayload, DeclareContractPayload } from '../types/lib/index';
+/**
+ * Checks if a given contract is in Sierra (Safe Intermediate Representation) format.
+ *
+ * @param {CairoContract | string} contract - The contract to check. Can be either a CairoContract object or a string representation of the contract.
+ * @return {boolean} - Returns true if the contract is a Sierra contract, otherwise false.
+ * @example
+ * ```typescript
+ * const result = isSierra(contract);
+ * // result = true | false
+ * ```
+ */
+export declare function isSierra(contract: CairoContract | string): contract is SierraContractClass | CompiledSierra;
+/**
+ * Extracts contract hashes from `DeclareContractPayload`.
+ *
+ * @param {DeclareContractPayload} payload - The payload containing contract information.
+ * @return {CompleteDeclareContractPayload} - The `CompleteDeclareContractPayload` with extracted contract hashes.
+ * @throws {Error} - If extraction of compiledClassHash or classHash fails.
+ * @example
+ * ```typescript
+ * const result = extractContractHashes(contract);
+ * // result = {
+ * //   contract: ...,
+ * //   classHash: ...,
+ * //   casm: ...,
+ * //   compiledClassHash: ...,
+ * // }
+ * ```
+ */
+export declare function extractContractHashes(payload: DeclareContractPayload): CompleteDeclareContractPayload;
+/**
+ * Helper to redeclare response Cairo0 contract
+ */
+export declare function contractClassResponseToLegacyCompiledContract(ccr: ContractClassResponse): LegacyCompiledContract;

package/dist/utils/contract.mjs

@@ -0,0 +1,31 @@
+import { computeCompiledClassHash, computeContractClassHash } from "./hash/index.mjs";
+import { parse } from "./json.mjs";
+import { decompressProgram } from "./stark.mjs";
+import { isString } from "./shortString.mjs";
+export function isSierra(contract) {
+  const compiledContract = isString(contract) ? parse(contract) : contract;
+  return "sierra_program" in compiledContract;
+}
+export function extractContractHashes(payload) {
+  const response = { ...payload };
+  if (isSierra(payload.contract)) {
+    if (!payload.compiledClassHash && payload.casm) {
+      response.compiledClassHash = computeCompiledClassHash(payload.casm);
+    }
+    if (!response.compiledClassHash)
+      throw new Error(
+        "Extract compiledClassHash failed, provide (CairoAssembly).casm file or compiledClassHash"
+      );
+  }
+  response.classHash = payload.classHash ?? computeContractClassHash(payload.contract);
+  if (!response.classHash)
+    throw new Error("Extract classHash failed, provide (CompiledContract).json file or classHash");
+  return response;
+}
+export function contractClassResponseToLegacyCompiledContract(ccr) {
+  if (isSierra(ccr)) {
+    throw Error("ContractClassResponse need to be LegacyContractClass (cairo0 response class)");
+  }
+  const contract = ccr;
+  return { ...contract, program: decompressProgram(contract.program) };
+}

package/dist/utils/ec.cjs

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.weierstrass = exports.starkCurve = void 0;
+var _starkCurve = _interopRequireWildcard(require("@scure/starknet"));
+exports.starkCurve = _starkCurve;
+var _weierstrass = _interopRequireWildcard(require("@noble/curves/abstract/weierstrass"));
+exports.weierstrass = _weierstrass;
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }

package/dist/utils/ec.d.ts

@@ -0,0 +1,2 @@
+export * as starkCurve from '@scure/starknet';
+export * as weierstrass from '@noble/curves/abstract/weierstrass';

package/dist/utils/ec.mjs

@@ -0,0 +1,2 @@
+export * as starkCurve from "@scure/starknet";
+export * as weierstrass from "@noble/curves/abstract/weierstrass";

package/dist/utils/encode.cjs

@@ -0,0 +1,78 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.IS_BROWSER = void 0;
+exports.addHexPrefix = addHexPrefix;
+exports.arrayBufferToString = arrayBufferToString;
+exports.atobUniversal = atobUniversal;
+exports.btoaUniversal = btoaUniversal;
+exports.buf2hex = buf2hex;
+exports.calcByteLength = calcByteLength;
+exports.padLeft = padLeft;
+exports.pascalToSnake = void 0;
+exports.removeHexPrefix = removeHexPrefix;
+exports.sanitizeBytes = sanitizeBytes;
+exports.sanitizeHex = sanitizeHex;
+exports.stringToArrayBuffer = stringToArrayBuffer;
+exports.utf8ToArray = utf8ToArray;
+var _base = require("@scure/base");
+const IS_BROWSER = exports.IS_BROWSER = typeof window !== "undefined";
+const STRING_ZERO = "0";
+function arrayBufferToString(array) {
+  return new Uint8Array(array).reduce((data, byte) => data + String.fromCharCode(byte), "");
+}
+function utf8ToArray(str) {
+  return new TextEncoder().encode(str);
+}
+function stringToArrayBuffer(str) {
+  return utf8ToArray(str);
+}
+function atobUniversal(a) {
+  return _base.base64.decode(a);
+}
+function btoaUniversal(b) {
+  return _base.base64.encode(new Uint8Array(b));
+}
+function buf2hex(buffer) {
+  return buffer.reduce((r, x) => r + x.toString(16).padStart(2, "0"), "");
+}
+function removeHexPrefix(hex) {
+  return hex.replace(/^0x/i, "");
+}
+function addHexPrefix(hex) {
+  return `0x${removeHexPrefix(hex)}`;
+}
+function padString(str, length, left, padding = STRING_ZERO) {
+  const diff = length - str.length;
+  let result = str;
+  if (diff > 0) {
+    const pad = padding.repeat(diff);
+    result = left ? pad + str : str + pad;
+  }
+  return result;
+}
+function padLeft(str, length, padding = STRING_ZERO) {
+  return padString(str, length, true, padding);
+}
+function calcByteLength(str, byteSize = 8) {
+  const {
+    length
+  } = str;
+  const remainder = length % byteSize;
+  return remainder ? (length - remainder) / byteSize * byteSize + byteSize : length;
+}
+function sanitizeBytes(str, byteSize = 8, padding = STRING_ZERO) {
+  return padLeft(str, calcByteLength(str, byteSize), padding);
+}
+function sanitizeHex(hex) {
+  hex = removeHexPrefix(hex);
+  hex = sanitizeBytes(hex, 2);
+  if (hex) {
+    hex = addHexPrefix(hex);
+  }
+  return hex;
+}
+const pascalToSnake = text => /[a-z]/.test(text) ? text.split(/(?=[A-Z])/).join("_").toUpperCase() : text;
+exports.pascalToSnake = pascalToSnake;