starknet 6.9.0 → 6.10.1

package/dist/utils/shortString.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Test if string contains only ASCII characters (string can be ascii text)
+ * @param {string} str The string to test
+ * @returns {boolean} Returns true if the string contains only ASCII characters, otherwise false
+ * @example
+ * ```typescript
+ * const result = shortString.isASCII("Hello, world!");
+ * // result = true
+ * const result = shortString.isASCII("Hello, 世界!");
+ * // result = false
+ * ```
+ */
+export declare function isASCII(str: string): boolean;
+/**
+ * Test if a string is a Cairo short string (string with less or equal 31 characters)
+ * @param {string} str the string to test
+ * @returns {boolean} Returns true if the string has less than or equal to 31 characters, otherwise false.
+ * @example
+ * ```typescript
+ * const result = shortString.isShortString("Hello, world!");
+ * // result = true
+ * ```
+ */
+export declare function isShortString(str: string): boolean;
+/**
+ * Test if string contains only numbers (string can be converted to decimal integer number)
+ * @param {string} str the string to test.
+ * @returns {boolean} Returns true if the string contains only numbers, otherwise false.
+ * @example
+ * ```typescript
+ * const result = shortString.isDecimalString("12345");
+ * // result = true
+ * const result = shortString.isDecimalString("12a45");
+ * // result = false
+ * ```
+ */
+export declare function isDecimalString(str: string): boolean;
+/**
+ * Checks if a given value is a string.
+ * @param {unknown} value the value to be checked.
+ * @return {boolean} returns true if the value is a string, false otherwise.
+ * @example
+ * ```typescript
+ * const result = shortString.isString("12345");
+ * // result = true
+ * ```
+ */
+export declare function isString(value: unknown): value is string;
+/**
+ * Test if value is a pure string text, and not a hex string or number string
+ * @param {any} val the value to test
+ * @returns {boolean} returns true if the value is a free-form string text, otherwise false
+ * @example
+ * ```typescript
+ * const result = shortString.isText("Hello, world!");
+ * // result = true
+ * const result = shortString.isText("0x7aec92f706");
+ * // result = false
+ * ```
+ */
+export declare function isText(val: any): boolean;
+/**
+ * Test if value is short text
+ * @param {any} val - The item to test
+ * @returns {boolean} Returns true if the value is a short text (string has less or equal 31 characters), otherwise false
+ * @example
+ * ```typescript
+ * const result = shortString.isShortText("Hello, world!");
+ * // result = true
+ * ```
+ */
+export declare const isShortText: (val: any) => boolean;
+/**
+ * Test if value is long text
+ * @param {any} val the value to test
+ * @returns {boolean} returns true if the value is a long text(string has more than 31 characters), otherwise false.
+ * @example
+ * ```typescript
+ * const result = shortString.isLongText("Hello, world! this is some random long string to enable you test isLongText function.");
+ * // result = true
+ * ```
+ */
+export declare const isLongText: (val: any) => boolean;
+/**
+ * Split long text (string greater than 31 characters) into short strings (string lesser or equal 31 characters)
+ * @param {string} longStr the long text (string greater than 31 characters) to split
+ * @returns {string[]} an array of short strings (string lesser or equal 31 characters).
+ * @example
+ * ```typescript
+ * const result = shortString.splitLongString("Hello, world! we just testing splitLongString function.");
+ * // result = [ 'Hello, world! we just testing s', 'plitLongString function.' ]
+ * ```
+ */
+export declare function splitLongString(longStr: string): string[];
+/**
+ * Convert an ASCII short string to a hexadecimal string.
+ * @param {string} str short string (ASCII string, 31 characters max)
+ * @returns {string} hex-string with 248 bits max
+ * @example
+ * ```typescript
+ * const result = shortString.encodeShortString("uri/pict/t38.jpg");
+ * // result = "0x7572692f706963742f7433382e6a7067"
+ * ```
+ */
+export declare function encodeShortString(str: string): string;
+/**
+ * Convert a hexadecimal or decimal string to an ASCII string.
+ * @param {string} str representing a 248 bit max number (ex. "0x1A4F64EA56" or "236942575435676423")
+ * @returns {string} short string; 31 characters max
+ * @example
+ * ```typescript
+ * const result = shortString.decodeShortString("0x7572692f706963742f7433382e6a7067");
+ * // result = "uri/pict/t38.jpg"
+ * ```
+ */
+export declare function decodeShortString(str: string): string;

package/dist/utils/shortString.mjs

@@ -0,0 +1,39 @@
+import { TEXT_TO_FELT_MAX_LEN } from "../constants.mjs";
+import { addHexPrefix, removeHexPrefix } from "./encode.mjs";
+import { isHex, isStringWholeNumber } from "./num.mjs";
+export function isASCII(str) {
+  return /^[\x00-\x7F]*$/.test(str);
+}
+export function isShortString(str) {
+  return str.length <= TEXT_TO_FELT_MAX_LEN;
+}
+export function isDecimalString(str) {
+  return /^[0-9]*$/i.test(str);
+}
+export function isString(value) {
+  return typeof value === "string";
+}
+export function isText(val) {
+  return isString(val) && !isHex(val) && !isStringWholeNumber(val);
+}
+export const isShortText = (val) => isText(val) && isShortString(val);
+export const isLongText = (val) => isText(val) && !isShortString(val);
+export function splitLongString(longStr) {
+  const regex = RegExp(`[^]{1,${TEXT_TO_FELT_MAX_LEN}}`, "g");
+  return longStr.match(regex) || [];
+}
+export function encodeShortString(str) {
+  if (!isASCII(str)) throw new Error(`${str} is not an ASCII string`);
+  if (!isShortString(str)) throw new Error(`${str} is too long`);
+  return addHexPrefix(str.replace(/./g, (char) => char.charCodeAt(0).toString(16)));
+}
+export function decodeShortString(str) {
+  if (!isASCII(str)) throw new Error(`${str} is not an ASCII string`);
+  if (isHex(str)) {
+    return removeHexPrefix(str).replace(/.{2}/g, (hex) => String.fromCharCode(parseInt(hex, 16)));
+  }
+  if (isDecimalString(str)) {
+    return decodeShortString("0X".concat(BigInt(str).toString(16)));
+  }
+  throw new Error(`${str} is not Hex or decimal`);
+}

package/dist/utils/stark.cjs

@@ -0,0 +1,137 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.compressProgram = compressProgram;
+exports.decompressProgram = decompressProgram;
+exports.estimateFeeToBounds = estimateFeeToBounds;
+exports.estimatedFeeToMaxFee = estimatedFeeToMaxFee;
+exports.formatSignature = formatSignature;
+exports.intDAM = intDAM;
+exports.makeAddress = makeAddress;
+exports.randomAddress = randomAddress;
+exports.reduceV2 = reduceV2;
+exports.signatureToDecimalArray = signatureToDecimalArray;
+exports.signatureToHexArray = signatureToHexArray;
+exports.toFeeVersion = toFeeVersion;
+exports.toTransactionVersion = toTransactionVersion;
+exports.v3Details = v3Details;
+var _starknet = require("@scure/starknet");
+var _pako = require("pako");
+var _constants = require("../constants.cjs");
+var _api = require("../types/api/index.cjs");
+var _encode = require("./encode.cjs");
+var _json = require("./json.cjs");
+var _num = require("./num.cjs");
+var _shortString = require("./shortString.cjs");
+function compressProgram(jsonProgram) {
+  const stringified = (0, _shortString.isString)(jsonProgram) ? jsonProgram : (0, _json.stringify)(jsonProgram);
+  const compressedProgram = (0, _pako.gzip)(stringified);
+  return (0, _encode.btoaUniversal)(compressedProgram);
+}
+function decompressProgram(base64) {
+  if (Array.isArray(base64)) return base64;
+  const decompressed = (0, _encode.arrayBufferToString)((0, _pako.ungzip)((0, _encode.atobUniversal)(base64)));
+  return (0, _json.parse)(decompressed);
+}
+function randomAddress() {
+  const randomKeyPair = _starknet.utils.randomPrivateKey();
+  return (0, _starknet.getStarkKey)(randomKeyPair);
+}
+function makeAddress(input) {
+  return (0, _encode.addHexPrefix)(input).toLowerCase();
+}
+function formatSignature(sig) {
+  if (!sig) throw Error("formatSignature: provided signature is undefined");
+  if (Array.isArray(sig)) {
+    return sig.map(it => (0, _num.toHex)(it));
+  }
+  try {
+    const {
+      r,
+      s
+    } = sig;
+    return [(0, _num.toHex)(r), (0, _num.toHex)(s)];
+  } catch (e) {
+    throw new Error("Signature need to be weierstrass.SignatureType or an array for custom");
+  }
+}
+function signatureToDecimalArray(sig) {
+  return (0, _num.bigNumberishArrayToDecimalStringArray)(formatSignature(sig));
+}
+function signatureToHexArray(sig) {
+  return (0, _num.bigNumberishArrayToHexadecimalStringArray)(formatSignature(sig));
+}
+function estimatedFeeToMaxFee(estimatedFee, overhead = _constants.FeeMarginPercentage.MAX_FEE) {
+  return (0, _num.addPercent)(estimatedFee, overhead);
+}
+function estimateFeeToBounds(estimate, amountOverhead = _constants.FeeMarginPercentage.L1_BOUND_MAX_AMOUNT, priceOverhead = _constants.FeeMarginPercentage.L1_BOUND_MAX_PRICE_PER_UNIT) {
+  if ((0, _num.isBigInt)(estimate)) {
+    return {
+      l2_gas: {
+        max_amount: "0x0",
+        max_price_per_unit: "0x0"
+      },
+      l1_gas: {
+        max_amount: "0x0",
+        max_price_per_unit: "0x0"
+      }
+    };
+  }
+  if (typeof estimate.gas_consumed === "undefined" || typeof estimate.gas_price === "undefined") {
+    throw Error("estimateFeeToBounds: estimate is undefined");
+  }
+  const maxUnits = estimate.data_gas_consumed !== void 0 && estimate.data_gas_price !== void 0 ? (0, _num.toHex)((0, _num.addPercent)(BigInt(estimate.overall_fee) / BigInt(estimate.gas_price), amountOverhead)) : (0, _num.toHex)((0, _num.addPercent)(estimate.gas_consumed, amountOverhead));
+  const maxUnitPrice = (0, _num.toHex)((0, _num.addPercent)(estimate.gas_price, priceOverhead));
+  return {
+    l2_gas: {
+      max_amount: "0x0",
+      max_price_per_unit: "0x0"
+    },
+    l1_gas: {
+      max_amount: maxUnits,
+      max_price_per_unit: maxUnitPrice
+    }
+  };
+}
+function intDAM(dam) {
+  if (dam === _api.EDataAvailabilityMode.L1) return _api.EDAMode.L1;
+  if (dam === _api.EDataAvailabilityMode.L2) return _api.EDAMode.L2;
+  throw Error("EDAM conversion");
+}
+function toTransactionVersion(defaultVersion, providedVersion) {
+  const providedVersion0xs = providedVersion ? (0, _num.toHex)(providedVersion) : void 0;
+  const defaultVersion0xs = (0, _num.toHex)(defaultVersion);
+  if (providedVersion && !Object.values(_api.ETransactionVersion).includes(providedVersion0xs)) {
+    throw Error(`providedVersion ${providedVersion} is not ETransactionVersion`);
+  }
+  if (!Object.values(_api.ETransactionVersion).includes(defaultVersion0xs)) {
+    throw Error(`defaultVersion ${defaultVersion} is not ETransactionVersion`);
+  }
+  return providedVersion ? providedVersion0xs : defaultVersion0xs;
+}
+function toFeeVersion(providedVersion) {
+  if (!providedVersion) return void 0;
+  const version = (0, _num.toHex)(providedVersion);
+  if (version === _api.ETransactionVersion.V0) return _api.ETransactionVersion.F0;
+  if (version === _api.ETransactionVersion.V1) return _api.ETransactionVersion.F1;
+  if (version === _api.ETransactionVersion.V2) return _api.ETransactionVersion.F2;
+  if (version === _api.ETransactionVersion.V3) return _api.ETransactionVersion.F3;
+  throw Error(`toFeeVersion: ${version} is not supported`);
+}
+function v3Details(details) {
+  return {
+    tip: details.tip || 0,
+    paymasterData: details.paymasterData || [],
+    accountDeploymentData: details.accountDeploymentData || [],
+    nonceDataAvailabilityMode: details.nonceDataAvailabilityMode || _api.EDataAvailabilityMode.L1,
+    feeDataAvailabilityMode: details.feeDataAvailabilityMode || _api.EDataAvailabilityMode.L1,
+    resourceBounds: details.resourceBounds ?? estimateFeeToBounds(_constants.ZERO)
+  };
+}
+function reduceV2(providedVersion) {
+  if (providedVersion === _api.ETransactionVersion.F2) return _api.ETransactionVersion.F1;
+  if (providedVersion === _api.ETransactionVersion.V2) return _api.ETransactionVersion.V1;
+  return providedVersion;
+}

package/dist/utils/stark.d.ts

@@ -0,0 +1,224 @@
+import type { SPEC } from 'starknet-types-07';
+import { ArraySignatureType, BigNumberish, CompressedProgram, Program, Signature, UniversalDetails } from '../types';
+import { EDAMode, EDataAvailabilityMode, ETransactionVersion, ResourceBounds } from '../types/api';
+import { FeeEstimate } from '../types/provider';
+/**
+ * Compress compiled Cairo 0 program
+ *
+ * [Reference](https://github.com/starkware-libs/cairo-lang/blob/master/src/starkware/starknet/services/api/gateway/transaction.py#L54-L58)
+ * @param {Program | string} jsonProgram Representing the compiled Cairo 0 program
+ * @return {CompressedProgram} Compressed Cairo 0 program
+ * @example
+ * ```typescript
+ * const contractCairo0 = json.parse(fs.readFileSync("./cairo0contract.json").toString("ascii"));
+ * const result = stark.compressProgram(contractCairo0);
+ * // result = "H4sIAAAAAAAAA+1dC4/bOJL+K4aBu01me7r5EEUyixzQk/TuB..."
+ * ```
+ */
+export declare function compressProgram(jsonProgram: Program | string): CompressedProgram;
+/**
+ * Decompress compressed compiled Cairo 0 program
+ * @param {CompressedProgram} base64 Compressed Cairo 0 program
+ * @returns {Object | CompressedProgram} Parsed decompressed compiled Cairo 0 program
+ * @example
+ * ```typescript
+ * const contractCairo0 = json.parse(fs.readFileSync("./cairo0contract.json").toString("ascii"));
+ * const compressedCairo0 = stark.compressProgram(contractCairo0);
+ * const result = stark.decompressProgram(compressedCairo0);
+ * // result = {
+ * //   abi: [
+ * //     {
+ * //       inputs: [Array],
+ * //       name: 'increase_balance',
+ * //       outputs: [],
+ * //       type: 'function'
+ * //     }
+ * //   ],
+ * //   entry_points_by_type: { CONSTRUCTOR: [], EXTERNAL: [ [Object], [Object] ], L1_HANDLER: [] },
+ * //   program: {
+ * //     attributes: [],
+ * //     builtins: [ 'pedersen', 'range_check' ],
+ * //     compiler_version: '0.10.2',
+ * //     data: [
+ * //       '0x480680017fff8000',
+ * // ...
+ * ```
+ */
+export declare function decompressProgram(base64: CompressedProgram): any;
+/**
+ * Random Address based on random keyPair
+ * @returns {string} an hex string of a random Starknet address
+ * @example
+ * ```typescript
+ * const result = stark.randomAddress();
+ * // result = "0x51fc8126a13cd5ddb29a71ca399cb1e814f086f5af1b502d7151c14929554f"
+ * ```
+ */
+export declare function randomAddress(): string;
+/**
+ * Lowercase and hex prefix string
+ *
+ * @deprecated Not used internally, naming is confusing based on functionality
+ */
+export declare function makeAddress(input: string): string;
+/**
+ * Format Signature to standard type (hex array)
+ * @param {Signature} [sig]
+ * @returns {ArraySignatureType} Custom hex string array
+ * @throws {Error} if sig not defined, or wrong format
+ * @example
+ * ```typescript
+ * const signature = ec.starkCurve.sign("0x12de34", "0x3487123eac");
+ * const result = stark.formatSignature(signature);
+ * // result = ['0xba8eecee2d69c417e8c6a20cf331c821f716b58ba9e47166c7476afdb38997',
+ * //  '0x69ef7438c94104839a6e2aa2385482a77399d2f46e894ae4f50ab6d69239d1c']
+ * ```
+ */
+export declare function formatSignature(sig?: Signature): ArraySignatureType;
+/**
+ * Format Signature to decimal string array
+ * @param {Signature} [sig]
+ * @returns {ArraySignatureType} Custom hex string array
+ * @throws {Error} if sig not defined, or wrong format
+ * @example
+ * ```typescript
+ * const signature = ec.starkCurve.sign("0x12de34", "0x3487123eac");
+ * const result = stark.signatureToDecimalArray(signature);
+ * // result = ['329619989660444495690615805546674399714973829707166906185976654753023887767',
+ * //  '2994745480203297689255012826403147585778741462125743754529207781488706428188']
+ * ```
+ */
+export declare function signatureToDecimalArray(sig?: Signature): ArraySignatureType;
+/**
+ * Format Signature to hex string array
+ * @param {Signature} [sig]
+ * @returns {ArraySignatureType} Custom hex string array
+ * @throws {Error} if sig not defined, or wrong format
+ * @example
+ * ```typescript
+ * const signature = ec.starkCurve.sign("0x12de34", "0x3487123eac");
+ * const result = stark.signatureToHexArray(signature);
+ * // result = ['0xba8eecee2d69c417e8c6a20cf331c821f716b58ba9e47166c7476afdb38997',
+ * //  '0x69ef7438c94104839a6e2aa2385482a77399d2f46e894ae4f50ab6d69239d1c']
+ * ```
+ */
+export declare function signatureToHexArray(sig?: Signature): ArraySignatureType;
+/**
+ * Convert estimated fee to max fee including a margin
+ * @param {BigNumberish} estimatedFee - The estimated fee
+ * @param {number} [overhead = feeMarginPercentage.MAX_FEE] - The overhead added to the gas
+ * @returns {bigint} The maximum fee with the margin
+ * @example
+ * ```typescript
+ * const result = stark.estimatedFeeToMaxFee("8982300000000", 50);
+ * // result = "13473450000000n"
+ * ```
+ */
+export declare function estimatedFeeToMaxFee(estimatedFee: BigNumberish, overhead?: number): bigint;
+/**
+ * Calculates the maximum resource bounds for fee estimation.
+ *
+ * @param {FeeEstimate | 0n} estimate The estimate for the fee. If a BigInt is provided, the returned bounds will be set to '0x0'.
+ * @param {number} [amountOverhead = feeMarginPercentage.L1_BOUND_MAX_AMOUNT] - The percentage overhead added to the gas consumed or overall fee amount.
+ * @param {number} [priceOverhead = feeMarginPercentage.L1_BOUND_MAX_PRICE_PER_UNIT] The percentage overhead added to the gas price per unit.
+ * @returns {ResourceBounds} The maximum resource bounds for fee estimation.
+ * @throws {Error} If the estimate object is undefined or does not have the required properties.
+ * @example
+ * ```typescript
+ * const feeEstimated: FeeEstimate = {
+  gas_consumed: "0x3456a",
+  gas_price: "0xa45567567567ae4",
+  overall_fee: "0x2198F463A77A899A5668",
+  unit: "WEI"
+};
+const result = stark.estimateFeeToBounds(feeEstimated, 70, 50);
+ * // result = {
+ * //   l2_gas: { max_amount: '0x0', max_price_per_unit: '0x0' },
+ * //   l1_gas: { max_amount: '0x58f9a', max_price_per_unit: '0xf6801b01b01b856' }
+ * // }
+ * ```
+ */
+export declare function estimateFeeToBounds(estimate: FeeEstimate | 0n, amountOverhead?: number, priceOverhead?: number): ResourceBounds;
+/**
+ * Converts the data availability mode from EDataAvailabilityMode to EDAMode.
+ *
+ * @param {EDataAvailabilityMode} dam The data availability mode to be converted.
+ * @return {EDAMode} The converted data availability mode.
+ * @throws {Error} If the data availability mode is not a valid value.
+ * @example
+ * ```typescript
+ * const result = stark.intDAM(RPC.EDataAvailabilityMode.L1);
+ * // result = 0
+ * ```
+ */
+export declare function intDAM(dam: EDataAvailabilityMode): EDAMode;
+/**
+ * Convert to ETransactionVersion or throw an error.
+ * Return providedVersion is specified else return defaultVersion
+ * @param {BigNumberish} defaultVersion default estimate transaction version
+ * @param {BigNumberish} [providedVersion] estimate transaction version
+ * @returns {ETransactionVersion} if providedVersion is not provided, returns the default estimate version, else return the provided version
+ * @throws {Error} if estimate transaction version or default estimate transaction version is unknown
+ * @example
+ * ```typescript
+ * const result = stark.toTransactionVersion("0x100000000000000000000000000000003", stark.toFeeVersion(2));
+ * // result = "0x100000000000000000000000000000002"
+ * ```
+ */
+export declare function toTransactionVersion(defaultVersion: BigNumberish, providedVersion?: BigNumberish): ETransactionVersion;
+/**
+ * Convert Transaction version to Fee version or throw an error
+ * @param {BigNumberish} [providedVersion] 0..3 number representing the transaction version
+ * @returns {ETransactionVersion} the fee estimation version corresponding to the transaction version provided
+ * @throws {Error} if the transaction version is unknown
+ * @example
+ * ```typescript
+ * const result = stark.toFeeVersion(2);
+ * // result = "0x100000000000000000000000000000002"
+ * ```
+ */
+export declare function toFeeVersion(providedVersion?: BigNumberish): "0x100000000000000000000000000000000" | "0x100000000000000000000000000000001" | "0x100000000000000000000000000000002" | "0x100000000000000000000000000000003" | undefined;
+/**
+ * Return provided or default v3 tx details
+ * @param {UniversalDetails} details details of the transaction
+ * @return {} an object including the V3 transaction details.
+ * @example
+ * ```typescript
+ * const detail: UniversalDetails = { tip: 3456n };
+ * const result = stark.v3Details(detail);
+ * // result = {
+ * //   tip: 3456n,
+ * //   paymasterData: [],
+ * //   accountDeploymentData: [],
+ * //   nonceDataAvailabilityMode: 'L1',
+ * //   feeDataAvailabilityMode: 'L1',
+ * //   resourceBounds: {
+ * //     l2_gas: { max_amount: '0x0', max_price_per_unit: '0x0' },
+ * //     l1_gas: { max_amount: '0x0', max_price_per_unit: '0x0' }
+ * //   }
+ * // }
+ * ```
+ */
+export declare function v3Details(details: UniversalDetails): {
+    tip: BigNumberish;
+    paymasterData: BigNumberish[];
+    accountDeploymentData: BigNumberish[];
+    nonceDataAvailabilityMode: EDataAvailabilityMode;
+    feeDataAvailabilityMode: EDataAvailabilityMode;
+    resourceBounds: SPEC.RESOURCE_BOUNDS_MAPPING;
+};
+/**
+ * It will reduce V2 to V1, else (V3) stay the same
+ * F2 -> F1
+ * V2 -> V1
+ * F3 -> F3
+ * V3 -> V3
+ * @param {ETransactionVersion} providedVersion
+ * @returns {ETransactionVersion} if v2 then returns v1. if v3 then return v3
+ * @example
+ * ```typescript
+ * const result = stark.reduceV2(constants.TRANSACTION_VERSION.V2);
+ * // result = "0x1"
+ * ```
+ */
+export declare function reduceV2(providedVersion: ETransactionVersion): ETransactionVersion;

package/dist/utils/stark.mjs

@@ -0,0 +1,109 @@
+import { getStarkKey, utils } from "@scure/starknet";
+import { gzip, ungzip } from "pako";
+import { ZERO, FeeMarginPercentage } from "../constants.mjs";
+import { EDAMode, EDataAvailabilityMode, ETransactionVersion } from "../types/api/index.mjs";
+import { addHexPrefix, arrayBufferToString, atobUniversal, btoaUniversal } from "./encode.mjs";
+import { parse, stringify } from "./json.mjs";
+import {
+  addPercent,
+  bigNumberishArrayToDecimalStringArray,
+  bigNumberishArrayToHexadecimalStringArray,
+  isBigInt,
+  toHex
+} from "./num.mjs";
+import { isString } from "./shortString.mjs";
+export function compressProgram(jsonProgram) {
+  const stringified = isString(jsonProgram) ? jsonProgram : stringify(jsonProgram);
+  const compressedProgram = gzip(stringified);
+  return btoaUniversal(compressedProgram);
+}
+export function decompressProgram(base64) {
+  if (Array.isArray(base64)) return base64;
+  const decompressed = arrayBufferToString(ungzip(atobUniversal(base64)));
+  return parse(decompressed);
+}
+export function randomAddress() {
+  const randomKeyPair = utils.randomPrivateKey();
+  return getStarkKey(randomKeyPair);
+}
+export function makeAddress(input) {
+  return addHexPrefix(input).toLowerCase();
+}
+export function formatSignature(sig) {
+  if (!sig) throw Error("formatSignature: provided signature is undefined");
+  if (Array.isArray(sig)) {
+    return sig.map((it) => toHex(it));
+  }
+  try {
+    const { r, s } = sig;
+    return [toHex(r), toHex(s)];
+  } catch (e) {
+    throw new Error("Signature need to be weierstrass.SignatureType or an array for custom");
+  }
+}
+export function signatureToDecimalArray(sig) {
+  return bigNumberishArrayToDecimalStringArray(formatSignature(sig));
+}
+export function signatureToHexArray(sig) {
+  return bigNumberishArrayToHexadecimalStringArray(formatSignature(sig));
+}
+export function estimatedFeeToMaxFee(estimatedFee, overhead = FeeMarginPercentage.MAX_FEE) {
+  return addPercent(estimatedFee, overhead);
+}
+export function estimateFeeToBounds(estimate, amountOverhead = FeeMarginPercentage.L1_BOUND_MAX_AMOUNT, priceOverhead = FeeMarginPercentage.L1_BOUND_MAX_PRICE_PER_UNIT) {
+  if (isBigInt(estimate)) {
+    return {
+      l2_gas: { max_amount: "0x0", max_price_per_unit: "0x0" },
+      l1_gas: { max_amount: "0x0", max_price_per_unit: "0x0" }
+    };
+  }
+  if (typeof estimate.gas_consumed === "undefined" || typeof estimate.gas_price === "undefined") {
+    throw Error("estimateFeeToBounds: estimate is undefined");
+  }
+  const maxUnits = estimate.data_gas_consumed !== void 0 && estimate.data_gas_price !== void 0 ? toHex(addPercent(BigInt(estimate.overall_fee) / BigInt(estimate.gas_price), amountOverhead)) : toHex(addPercent(estimate.gas_consumed, amountOverhead));
+  const maxUnitPrice = toHex(addPercent(estimate.gas_price, priceOverhead));
+  return {
+    l2_gas: { max_amount: "0x0", max_price_per_unit: "0x0" },
+    l1_gas: { max_amount: maxUnits, max_price_per_unit: maxUnitPrice }
+  };
+}
+export function intDAM(dam) {
+  if (dam === EDataAvailabilityMode.L1) return EDAMode.L1;
+  if (dam === EDataAvailabilityMode.L2) return EDAMode.L2;
+  throw Error("EDAM conversion");
+}
+export function toTransactionVersion(defaultVersion, providedVersion) {
+  const providedVersion0xs = providedVersion ? toHex(providedVersion) : void 0;
+  const defaultVersion0xs = toHex(defaultVersion);
+  if (providedVersion && !Object.values(ETransactionVersion).includes(providedVersion0xs)) {
+    throw Error(`providedVersion ${providedVersion} is not ETransactionVersion`);
+  }
+  if (!Object.values(ETransactionVersion).includes(defaultVersion0xs)) {
+    throw Error(`defaultVersion ${defaultVersion} is not ETransactionVersion`);
+  }
+  return providedVersion ? providedVersion0xs : defaultVersion0xs;
+}
+export function toFeeVersion(providedVersion) {
+  if (!providedVersion) return void 0;
+  const version = toHex(providedVersion);
+  if (version === ETransactionVersion.V0) return ETransactionVersion.F0;
+  if (version === ETransactionVersion.V1) return ETransactionVersion.F1;
+  if (version === ETransactionVersion.V2) return ETransactionVersion.F2;
+  if (version === ETransactionVersion.V3) return ETransactionVersion.F3;
+  throw Error(`toFeeVersion: ${version} is not supported`);
+}
+export function v3Details(details) {
+  return {
+    tip: details.tip || 0,
+    paymasterData: details.paymasterData || [],
+    accountDeploymentData: details.accountDeploymentData || [],
+    nonceDataAvailabilityMode: details.nonceDataAvailabilityMode || EDataAvailabilityMode.L1,
+    feeDataAvailabilityMode: details.feeDataAvailabilityMode || EDataAvailabilityMode.L1,
+    resourceBounds: details.resourceBounds ?? estimateFeeToBounds(ZERO)
+  };
+}
+export function reduceV2(providedVersion) {
+  if (providedVersion === ETransactionVersion.F2) return ETransactionVersion.F1;
+  if (providedVersion === ETransactionVersion.V2) return ETransactionVersion.V1;
+  return providedVersion;
+}