starknet 6.9.0 → 6.10.1

package/dist/utils/encode.d.ts

@@ -0,0 +1,207 @@
+export declare const IS_BROWSER: boolean;
+/**
+ * Some functions recreated from https://github.com/pedrouid/enc-utils/blob/master/src/index.ts
+ * enc-utils is not a dependency to avoid using `Buffer` which only works in node and not browsers
+ */
+/**
+ * Convert array buffer to string
+ *
+ * *[internal usage]*
+ *
+ * @param {ArrayBuffer} array The ArrayBuffer to convert to string.
+ * @returns {string} The converted string.
+ *
+ * @example
+ * ```typescript
+ * const buffer = new ArrayBuffer(5);
+ * const view = new Uint8Array(buffer);
+ * [72, 101, 108, 108, 111].forEach((x, idx) => view[idx] = x);
+ * const result = encode.arrayBufferToString(buffer);
+ * // result = "Hello"
+ * ```
+ */
+export declare function arrayBufferToString(array: ArrayBuffer): string;
+/**
+ * Convert utf8-string to Uint8Array
+ *
+ * *[internal usage]*
+ *
+ * @param {string} str The UTF-8 string to convert.
+ * @returns {Uint8Array} The encoded Uint8Array.
+ *
+ * @example
+ * ```typescript
+ * const myString = 'Hi';
+ * const result = encode.utf8ToArray(myString);
+ * // result = Uint8Array(2) [ 72, 105 ]
+ * ```
+ */
+export declare function utf8ToArray(str: string): Uint8Array;
+/**
+ * Convert utf8-string to Uint8Array
+ *
+ * @deprecated equivalent to 'utf8ToArray', alias will be removed
+ */
+export declare function stringToArrayBuffer(str: string): Uint8Array;
+/**
+ * Convert string to array buffer (browser and node compatible)
+ *
+ * @param {string} a The Base64 encoded string to convert.
+ * @returns {Uint8Array} The decoded Uint8Array.
+ *
+ * @example
+ * ```typescript
+ * const base64String = 'SGVsbG8='; // 'Hello' in Base64
+ * const result = encode.atobUniversal(base64String);
+ * // result = Uint8Array(5) [ 72, 101, 108, 108, 111 ]
+ * ```
+ */
+export declare function atobUniversal(a: string): Uint8Array;
+/**
+ * Convert array buffer to string (browser and node compatible)
+ *
+ * @param {ArrayBuffer} b The Array buffer.
+ * @returns {string} The Base64 encoded string.
+ *
+ * @example
+ * ```typescript
+ * const buffer = new Uint8Array([72, 101, 108, 108, 111]); // Array with ASCII values for 'Hello'
+ * const result = encode.btoaUniversal(buffer);
+ * // result = "SGVsbG8="
+ * ```
+ */
+export declare function btoaUniversal(b: ArrayBuffer): string;
+/**
+ * Convert array buffer to hex-string
+ *
+ * @param {Uint8Array} buffer The encoded Uint8Array.
+ * @returns {string} The hex-string
+ *
+ * @example
+ * ```typescript
+ * const buffer = new Uint8Array([72, 101, 108, 108, 111]); // Array with ASCII values for 'Hello'
+ * const result = encode.buf2hex(buffer);
+ * // result = "48656c6c6f"
+ * ```
+ */
+export declare function buf2hex(buffer: Uint8Array): string;
+/**
+ * Remove hex prefix '0x' from hex-string
+ * @param hex hex-string
+ * @returns {string} The hex-string
+ *
+ * @example
+ * ```typescript
+ * const hexStringWithPrefix = '0x48656c6c6f';
+ * const result = encode.removeHexPrefix(hexStringWithPrefix);
+ * // result: "48656c6c6f"
+ * ```
+ */
+export declare function removeHexPrefix(hex: string): string;
+/**
+ * Add hex prefix '0x' to base16-string
+ * @param hex base16-string
+ * @returns {string} The hex-string
+ *
+ * @example
+ * ```typescript
+ * const plainHexString = '48656c6c6f';
+ * const result = encode.addHexPrefix(plainHexString);
+ * // result: "0x48656c6c6f"
+ * ```
+ */
+export declare function addHexPrefix(hex: string): string;
+/**
+ * Prepend string (default with '0')
+ *
+ * Pads a string to a certain length with a specific string.
+ * The padding can be applied only to the left of the input string.
+ *
+ * @param {string} str The string to pad.
+ * @param {number} length The target length for the padded string.
+ * @param {string} [padding='0'] The string to use for padding. Defaults to '0'.
+ * @returns {string} The padded string.
+ *
+ * @example
+ * ```typescript
+ * const myString = '1A3F';
+ * const result = encode.padLeft(myString, 10);
+ * // result: '0000001A3F'
+ * ```
+ */
+export declare function padLeft(str: string, length: number, padding?: string): string;
+/**
+ * Calculate byte length of string
+ *
+ * *[no internal usage]*
+ *
+ * Calculates the byte length of a string based on a specified byte size.
+ * The function rounds up the byte count to the nearest multiple of the specified byte size.
+ *
+ * @param {string} str The string whose byte length is to be calculated.
+ * @param {number} [byteSize='8'] The size of the byte block to round up to. Defaults to 8.
+ * @returns {number} The calculated byte length, rounded to the nearest multiple of byteSize.
+ *
+ * @example
+ * ```typescript
+ * const myString = 'Hello';
+ * const result = encode.calcByteLength(myString, 4);
+ * // result = 8 (rounded up to the nearest multiple of 4)
+ *
+ * ```
+ */
+export declare function calcByteLength(str: string, byteSize?: number): number;
+/**
+ * Prepend '0' to string bytes
+ *
+ * *[no internal usage]*
+ *
+ *
+ * * Prepends padding to the left of a string to ensure it matches a specific byte length.
+ * The function uses a specified padding character and rounds up the string length to the nearest multiple of `byteSize`.
+ *
+ * @param {string} str The string to be padded.
+ * @param {number} [byteSize='8'] The byte block size to which the string length should be rounded up. Defaults to 8.
+ * @param {string} [padding='0'] The character to use for padding. Defaults to '0'.
+ * @returns {string} The padded string.
+ *
+ * @example
+ * ```typescript
+ * const myString = '123';
+ * const result = encode.sanitizeBytes(myString);
+ * // result: '00000123' (padded to 8 characters)
+ * ```
+ */
+export declare function sanitizeBytes(str: string, byteSize?: number, padding?: string): string;
+/**
+ * Sanitizes a hex-string by removing any existing '0x' prefix, padding the string with '0' to ensure it has even length,
+ * and then re-adding the '0x' prefix.
+ *
+ * *[no internal usage]*
+ * @param hex hex-string
+ * @returns format: hex-string
+ *
+ * @example
+ * ```typescript
+ * const unevenHex = '0x23abc';
+ * const result = encode.sanitizeHex(unevenHex);
+ * // result = '0x023abc' (padded to ensure even length)
+ * ```
+ */
+export declare function sanitizeHex(hex: string): string;
+/**
+ * String transformation util
+ *
+ * Pascal case to screaming snake case
+ *
+ * @param {string} text The PascalCase string to convert.
+ * @returns {string} The converted snake_case string in uppercase.
+ *
+ * @example
+ * ```typescript
+ * const pascalString = 'PascalCaseExample';
+ * const result = encode.pascalToSnake(pascalString);
+ * // result: 'PASCAL_CASE_EXAMPLE'
+ * ```
+ */
+export declare const pascalToSnake: (text: string) => string;

package/dist/utils/encode.mjs

@@ -0,0 +1,56 @@
+import { base64 } from "@scure/base";
+export const IS_BROWSER = typeof window !== "undefined";
+const STRING_ZERO = "0";
+export function arrayBufferToString(array) {
+  return new Uint8Array(array).reduce((data, byte) => data + String.fromCharCode(byte), "");
+}
+export function utf8ToArray(str) {
+  return new TextEncoder().encode(str);
+}
+export function stringToArrayBuffer(str) {
+  return utf8ToArray(str);
+}
+export function atobUniversal(a) {
+  return base64.decode(a);
+}
+export function btoaUniversal(b) {
+  return base64.encode(new Uint8Array(b));
+}
+export function buf2hex(buffer) {
+  return buffer.reduce((r, x) => r + x.toString(16).padStart(2, "0"), "");
+}
+export function removeHexPrefix(hex) {
+  return hex.replace(/^0x/i, "");
+}
+export 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;
+}
+export function padLeft(str, length, padding = STRING_ZERO) {
+  return padString(str, length, true, padding);
+}
+export function calcByteLength(str, byteSize = 8) {
+  const { length } = str;
+  const remainder = length % byteSize;
+  return remainder ? (length - remainder) / byteSize * byteSize + byteSize : length;
+}
+export function sanitizeBytes(str, byteSize = 8, padding = STRING_ZERO) {
+  return padLeft(str, calcByteLength(str, byteSize), padding);
+}
+export function sanitizeHex(hex) {
+  hex = removeHexPrefix(hex);
+  hex = sanitizeBytes(hex, 2);
+  if (hex) {
+    hex = addHexPrefix(hex);
+  }
+  return hex;
+}
+export const pascalToSnake = (text) => /[a-z]/.test(text) ? text.split(/(?=[A-Z])/).join("_").toUpperCase() : text;

package/dist/utils/eth.cjs

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ethRandomPrivateKey = ethRandomPrivateKey;
+exports.validateAndParseEthAddress = validateAndParseEthAddress;
+var _secp256k = require("@noble/curves/secp256k1");
+var _encode = require("./encode.cjs");
+var _num = require("./num.cjs");
+var _constants = require("../constants.cjs");
+var _assert = _interopRequireDefault(require("./assert.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function ethRandomPrivateKey() {
+  return (0, _encode.sanitizeHex)((0, _encode.buf2hex)(_secp256k.secp256k1.utils.randomPrivateKey()));
+}
+function validateAndParseEthAddress(address) {
+  (0, _num.assertInRange)(address, _constants.ZERO, 2n ** 160n - 1n, "Ethereum Address ");
+  const result = (0, _encode.addHexPrefix)((0, _encode.removeHexPrefix)((0, _num.toHex)(address)).padStart(40, "0"));
+  (0, _assert.default)(Boolean(result.match(/^(0x)?[0-9a-f]{40}$/)), "Invalid Ethereum Address Format");
+  return result;
+}

package/dist/utils/eth.d.ts

@@ -0,0 +1,22 @@
+import type { BigNumberish } from '../types';
+/**
+ * Get random Ethereum private Key.
+ * @returns an Hex string
+ * @example
+ * ```typescript
+ * const myPK: string = randomAddress()
+ * // result = "0xf04e69ac152fba37c02929c2ae78c9a481461dda42dbc6c6e286be6eb2a8ab83"
+ * ```
+ */
+export declare function ethRandomPrivateKey(): string;
+/**
+ * Get a string formatted for an Ethereum address, without uppercase characters.
+ * @param {BigNumberish} address Address of an Ethereum account.
+ * @returns an Hex string coded on 20 bytes
+ * @example
+ * ```typescript
+ * const myEthAddress: string = validateAndParseEthAddress("0x8359E4B0152ed5A731162D3c7B0D8D56edB165")
+ * // result = "0x008359e4b0152ed5a731162d3c7b0d8d56edb165"
+ * ```
+ */
+export declare function validateAndParseEthAddress(address: BigNumberish): string;

package/dist/utils/eth.mjs

@@ -0,0 +1,14 @@
+import { secp256k1 } from "@noble/curves/secp256k1";
+import { addHexPrefix, buf2hex, removeHexPrefix, sanitizeHex } from "./encode.mjs";
+import { assertInRange, toHex } from "./num.mjs";
+import { ZERO } from "../constants.mjs";
+import assert from "./assert.mjs";
+export function ethRandomPrivateKey() {
+  return sanitizeHex(buf2hex(secp256k1.utils.randomPrivateKey()));
+}
+export function validateAndParseEthAddress(address) {
+  assertInRange(address, ZERO, 2n ** 160n - 1n, "Ethereum Address ");
+  const result = addHexPrefix(removeHexPrefix(toHex(address)).padStart(40, "0"));
+  assert(Boolean(result.match(/^(0x)?[0-9a-f]{40}$/)), "Invalid Ethereum Address Format");
+  return result;
+}

package/dist/utils/events/index.cjs

@@ -0,0 +1,144 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getAbiEvents = getAbiEvents;
+exports.isAbiEvent = isAbiEvent;
+exports.isObject = isObject;
+exports.parseEvents = parseEvents;
+exports.parseUDCEvent = parseUDCEvent;
+var _constants = require("../../constants.cjs");
+var _assert = _interopRequireDefault(require("../assert.cjs"));
+var _cairo = require("../calldata/cairo.cjs");
+var _responseParser = _interopRequireDefault(require("../calldata/responseParser.cjs"));
+var _ec = require("../ec.cjs");
+var _encode = require("../encode.cjs");
+var _num = require("../num.cjs");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function isAbiEvent(object) {
+  return object.type === "event";
+}
+function getCairo0AbiEvents(abi) {
+  return abi.filter(abiEntry => abiEntry.type === "event").reduce((acc, abiEntry) => {
+    const entryName = abiEntry.name;
+    const abiEntryMod = {
+      ...abiEntry
+    };
+    abiEntryMod.name = entryName;
+    return {
+      ...acc,
+      [(0, _encode.addHexPrefix)(_ec.starkCurve.keccak((0, _encode.utf8ToArray)(entryName)).toString(16))]: abiEntryMod
+    };
+  }, {});
+}
+function getCairo1AbiEvents(abi) {
+  const abiEventsStructs = abi.filter(obj => isAbiEvent(obj) && obj.kind === "struct");
+  const abiEventsEnums = abi.filter(obj => isAbiEvent(obj) && obj.kind === "enum");
+  const abiEventsData = abiEventsStructs.reduce((acc, event) => {
+    let nameList = [];
+    let {
+      name
+    } = event;
+    let flat = false;
+    const findName = variant => variant.type === name;
+    while (true) {
+      const eventEnum = abiEventsEnums.find(eventE => eventE.variants.some(findName));
+      if (typeof eventEnum === "undefined") break;
+      const variant = eventEnum.variants.find(findName);
+      nameList.unshift(variant.name);
+      if (variant.kind === "flat") flat = true;
+      name = eventEnum.name;
+    }
+    if (nameList.length === 0) {
+      throw new Error("inconsistency in ABI events definition.");
+    }
+    if (flat) nameList = [nameList[nameList.length - 1]];
+    const final = nameList.pop();
+    let result = {
+      [(0, _encode.addHexPrefix)(_ec.starkCurve.keccak((0, _encode.utf8ToArray)(final)).toString(16))]: event
+    };
+    while (nameList.length > 0) {
+      result = {
+        [(0, _encode.addHexPrefix)(_ec.starkCurve.keccak((0, _encode.utf8ToArray)(nameList.pop())).toString(16))]: result
+      };
+    }
+    result = {
+      ...result
+    };
+    return mergeAbiEvents(acc, result);
+  }, {});
+  return abiEventsData;
+}
+function getAbiEvents(abi) {
+  return (0, _cairo.isCairo1Abi)(abi) ? getCairo1AbiEvents(abi) : getCairo0AbiEvents(abi);
+}
+function isObject(item) {
+  return item && typeof item === "object" && !Array.isArray(item);
+}
+function mergeAbiEvents(target, source) {
+  const output = {
+    ...target
+  };
+  if (isObject(target) && isObject(source)) {
+    Object.keys(source).forEach(key => {
+      if (isObject(source[key])) {
+        if (!(key in target)) Object.assign(output, {
+          [key]: source[key]
+        });else output[key] = mergeAbiEvents(target[key], source[key]);
+      } else {
+        Object.assign(output, {
+          [key]: source[key]
+        });
+      }
+    });
+  }
+  return output;
+}
+function parseEvents(providerReceivedEvents, abiEvents, abiStructs, abiEnums) {
+  const ret = providerReceivedEvents.flat().reduce((acc, recEvent) => {
+    let abiEvent = abiEvents[recEvent.keys.shift() ?? 0];
+    if (!abiEvent) {
+      return acc;
+    }
+    while (!abiEvent.name) {
+      const hashName = recEvent.keys.shift();
+      (0, _assert.default)(!!hashName, 'Not enough data in "key" property of this event.');
+      abiEvent = abiEvent[hashName];
+    }
+    const parsedEvent = {};
+    parsedEvent[abiEvent.name] = {};
+    const keysIter = recEvent.keys[Symbol.iterator]();
+    const dataIter = recEvent.data[Symbol.iterator]();
+    const abiEventKeys = abiEvent.members?.filter(it => it.kind === "key") || abiEvent.keys;
+    const abiEventData = abiEvent.members?.filter(it => it.kind === "data") || abiEvent.data;
+    abiEventKeys.forEach(key => {
+      parsedEvent[abiEvent.name][key.name] = (0, _responseParser.default)(keysIter, key, abiStructs, abiEnums, parsedEvent[abiEvent.name]);
+    });
+    abiEventData.forEach(data => {
+      parsedEvent[abiEvent.name][data.name] = (0, _responseParser.default)(dataIter, data, abiStructs, abiEnums, parsedEvent[abiEvent.name]);
+    });
+    acc.push(parsedEvent);
+    return acc;
+  }, []);
+  return ret;
+}
+function parseUDCEvent(txReceipt) {
+  if (!txReceipt.events) {
+    throw new Error("UDC emitted event is empty");
+  }
+  const event = txReceipt.events.find(it => (0, _num.cleanHex)(it.from_address) === (0, _num.cleanHex)(_constants.UDC.ADDRESS)) || {
+    data: []
+  };
+  return {
+    transaction_hash: txReceipt.transaction_hash,
+    contract_address: event.data[0],
+    address: event.data[0],
+    deployer: event.data[1],
+    unique: event.data[2],
+    classHash: event.data[3],
+    calldata_len: event.data[4],
+    calldata: event.data.slice(5, 5 + parseInt(event.data[4], 16)),
+    salt: event.data[event.data.length - 1]
+  };
+}

package/dist/utils/events/index.d.ts

@@ -0,0 +1,84 @@
+import { Abi, AbiEnums, AbiEvents, AbiStructs, ParsedEvents, RPC, type InvokeTransactionReceiptResponse, type AbiEntry } from '../../types';
+/**
+ * Check if an ABI entry is related to events.
+ * @param {AbiEntry} object an Abi entry
+ * @returns {boolean} true if this Abi Entry is related to an event
+ * @example
+ * ```typescript
+ * // use of a transaction receipt
+ * ```
+ */
+export declare function isAbiEvent(object: AbiEntry): boolean;
+/**
+ * Retrieves the events from the given ABI (from Cairo 0 or Cairo 1 contract).
+ *
+ * Is able to handle Cairo 1 events nested in Cairo components.
+ * @param {Abi} abi - The ABI to extract events from.
+ * @return {AbiEvents} - An object containing the hashes and the definition of the events.
+ * @example
+ * ```typescript
+ * const result = events.getAbiEvents(abi);
+ * // result = {
+ * //   '0x22ea134d4126804c60797e633195f8c9aa5fd6d1567e299f4961d0e96f373ee':
+ * //    { '0x34e55c1cd55f1338241b50d352f0e91c7e4ffad0e4271d64eb347589ebdfd16': {
+ * //     kind: 'struct', type: 'event',
+ * //     name: 'ka::ExComponent::ex_logic_component::Mint',
+      
+ * //     members: [{
+ * //      name: 'spender',
+ * //      type: 'core::starknet::contract_address::ContractAddress',
+ * //      kind: 'key'},
+ * //      { name: 'value', type: 'core::integer::u256', kind: 'data' }]},
+ * // ...
+ * ```
+ */
+export declare function getAbiEvents(abi: Abi): AbiEvents;
+/**
+ * Checks if a given value is an object (Object or Array)
+ * @param {any} item the tested item
+ * @returns {boolean}
+ * @example
+ * ```typescript
+ * const result = events.isObject({event: "pending"});
+ * // result = true
+ * ```
+ */
+export declare function isObject(item: any): boolean;
+/**
+ * Parse raw events and structure them into response object based on a contract structs and defined events
+ * @param {RPC.Event[]} providerReceivedEvents Array of raw events
+ * @param {AbiEvents} abiEvents Events defined in the abi
+ * @param {AbiStructs} abiStructs Structs defined in the abi
+ * @param {AbiEnums} abiEnums Enums defined in the abi
+ * @returns {ParsedEvents} parsed events corresponding to the abi
+ * @example
+ * ```typescript
+ * const abiEvents = events.getAbiEvents(sierra.abi);
+ * const abiStructs =  CallData.getAbiStruct(sierra.abi);
+ * const abiEnums = CallData.getAbiEnum(sierra.abi);
+ * const result = events.parseEvents(myEvents, abiEvents, abiStructs, abiEnums);
+ * // result = [{test::ExCh::ex_ch::Trade: {
+      maker: 7548613724711489396448209137n,
+      taker: 6435850562375218974960297344n,
+      router_maker: 0n,
+    }}]
+ * ```
+ */
+export declare function parseEvents(providerReceivedEvents: RPC.Event[], abiEvents: AbiEvents, abiStructs: AbiStructs, abiEnums: AbiEnums): ParsedEvents;
+/**
+ * Parse Transaction Receipt Event from UDC invoke transaction and
+ * create DeployContractResponse compatible response with addition of the UDC Event data
+ *
+ * @returns DeployContractResponse | UDC Event Response data
+ */
+export declare function parseUDCEvent(txReceipt: InvokeTransactionReceiptResponse): {
+    transaction_hash: string;
+    contract_address: string;
+    address: string;
+    deployer: string;
+    unique: string;
+    classHash: string;
+    calldata_len: string;
+    calldata: string[];
+    salt: string;
+};

package/dist/utils/events/index.mjs

@@ -0,0 +1,136 @@
+import { UDC } from "../../constants.mjs";
+import assert from "../assert.mjs";
+import { isCairo1Abi } from "../calldata/cairo.mjs";
+import responseParser from "../calldata/responseParser.mjs";
+import { starkCurve } from "../ec.mjs";
+import { addHexPrefix, utf8ToArray } from "../encode.mjs";
+import { cleanHex } from "../num.mjs";
+export function isAbiEvent(object) {
+  return object.type === "event";
+}
+function getCairo0AbiEvents(abi) {
+  return abi.filter((abiEntry) => abiEntry.type === "event").reduce((acc, abiEntry) => {
+    const entryName = abiEntry.name;
+    const abiEntryMod = { ...abiEntry };
+    abiEntryMod.name = entryName;
+    return {
+      ...acc,
+      [addHexPrefix(starkCurve.keccak(utf8ToArray(entryName)).toString(16))]: abiEntryMod
+    };
+  }, {});
+}
+function getCairo1AbiEvents(abi) {
+  const abiEventsStructs = abi.filter((obj) => isAbiEvent(obj) && obj.kind === "struct");
+  const abiEventsEnums = abi.filter((obj) => isAbiEvent(obj) && obj.kind === "enum");
+  const abiEventsData = abiEventsStructs.reduce((acc, event) => {
+    let nameList = [];
+    let { name } = event;
+    let flat = false;
+    const findName = (variant) => variant.type === name;
+    while (true) {
+      const eventEnum = abiEventsEnums.find((eventE) => eventE.variants.some(findName));
+      if (typeof eventEnum === "undefined") break;
+      const variant = eventEnum.variants.find(findName);
+      nameList.unshift(variant.name);
+      if (variant.kind === "flat") flat = true;
+      name = eventEnum.name;
+    }
+    if (nameList.length === 0) {
+      throw new Error("inconsistency in ABI events definition.");
+    }
+    if (flat) nameList = [nameList[nameList.length - 1]];
+    const final = nameList.pop();
+    let result = {
+      [addHexPrefix(starkCurve.keccak(utf8ToArray(final)).toString(16))]: event
+    };
+    while (nameList.length > 0) {
+      result = {
+        [addHexPrefix(starkCurve.keccak(utf8ToArray(nameList.pop())).toString(16))]: result
+      };
+    }
+    result = { ...result };
+    return mergeAbiEvents(acc, result);
+  }, {});
+  return abiEventsData;
+}
+export function getAbiEvents(abi) {
+  return isCairo1Abi(abi) ? getCairo1AbiEvents(abi) : getCairo0AbiEvents(abi);
+}
+export function isObject(item) {
+  return item && typeof item === "object" && !Array.isArray(item);
+}
+function mergeAbiEvents(target, source) {
+  const output = { ...target };
+  if (isObject(target) && isObject(source)) {
+    Object.keys(source).forEach((key) => {
+      if (isObject(source[key])) {
+        if (!(key in target)) Object.assign(output, { [key]: source[key] });
+        else output[key] = mergeAbiEvents(target[key], source[key]);
+      } else {
+        Object.assign(output, { [key]: source[key] });
+      }
+    });
+  }
+  return output;
+}
+export function parseEvents(providerReceivedEvents, abiEvents, abiStructs, abiEnums) {
+  const ret = providerReceivedEvents.flat().reduce((acc, recEvent) => {
+    let abiEvent = abiEvents[recEvent.keys.shift() ?? 0];
+    if (!abiEvent) {
+      return acc;
+    }
+    while (!abiEvent.name) {
+      const hashName = recEvent.keys.shift();
+      assert(!!hashName, 'Not enough data in "key" property of this event.');
+      abiEvent = abiEvent[hashName];
+    }
+    const parsedEvent = {};
+    parsedEvent[abiEvent.name] = {};
+    const keysIter = recEvent.keys[Symbol.iterator]();
+    const dataIter = recEvent.data[Symbol.iterator]();
+    const abiEventKeys = abiEvent.members?.filter((it) => it.kind === "key") || abiEvent.keys;
+    const abiEventData = abiEvent.members?.filter((it) => it.kind === "data") || abiEvent.data;
+    abiEventKeys.forEach((key) => {
+      parsedEvent[abiEvent.name][key.name] = responseParser(
+        keysIter,
+        key,
+        abiStructs,
+        abiEnums,
+        parsedEvent[abiEvent.name]
+      );
+    });
+    abiEventData.forEach((data) => {
+      parsedEvent[abiEvent.name][data.name] = responseParser(
+        dataIter,
+        data,
+        abiStructs,
+        abiEnums,
+        parsedEvent[abiEvent.name]
+      );
+    });
+    acc.push(parsedEvent);
+    return acc;
+  }, []);
+  return ret;
+}
+export function parseUDCEvent(txReceipt) {
+  if (!txReceipt.events) {
+    throw new Error("UDC emitted event is empty");
+  }
+  const event = txReceipt.events.find(
+    (it) => cleanHex(it.from_address) === cleanHex(UDC.ADDRESS)
+  ) || {
+    data: []
+  };
+  return {
+    transaction_hash: txReceipt.transaction_hash,
+    contract_address: event.data[0],
+    address: event.data[0],
+    deployer: event.data[1],
+    unique: event.data[2],
+    classHash: event.data[3],
+    calldata_len: event.data[4],
+    calldata: event.data.slice(5, 5 + parseInt(event.data[4], 16)),
+    salt: event.data[event.data.length - 1]
+  };
+}