starknet 5.10.2 → 5.11.0

package/dist/index.global.js

@@ -25,6 +25,10 @@ var starknet = (() => {
     return to;
   };
   var __toESM = (mod3, isNodeMode, target) => (target = mod3 != null ? __create(__getProtoOf(mod3)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
     isNodeMode || !mod3 || !mod3.__esModule ? __defProp(target, "default", { value: mod3, enumerable: true }) : target,
     mod3
   ));
@@ -272,10 +276,10 @@ var starknet = (() => {
       if (options.cache === "no-store" || options.cache === "no-cache") {
         var reParamSearch = /([?&])_=[^&]*/;
         if (reParamSearch.test(this.url)) {
-          this.url = this.url.replace(reParamSearch, "$1_=" + new Date().getTime());
+          this.url = this.url.replace(reParamSearch, "$1_=" + (/* @__PURE__ */ new Date()).getTime());
         } else {
           var reQueryString = /\?/;
-          this.url += (reQueryString.test(this.url) ? "&" : "?") + "_=" + new Date().getTime();
+          this.url += (reQueryString.test(this.url) ? "&" : "?") + "_=" + (/* @__PURE__ */ new Date()).getTime();
         }
       }
     }
@@ -1238,6 +1242,7 @@ var starknet = (() => {
     return result;
   }
   var Hash = class {
+    // Safe version that clones internal state
     clone() {
       return this._cloneInto();
     }
@@ -1329,6 +1334,7 @@ var starknet = (() => {
     B.fill(0);
   }
   var Keccak = class extends Hash {
+    // NOTE: we accept arguments in bytes instead of bits here.
     constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
       super();
       this.blockLen = blockLen;
@@ -1640,6 +1646,7 @@ var starknet = (() => {
       const { A, B, C, D, E, F, G, H } = this;
       return [A, B, C, D, E, F, G, H];
     }
+    // prettier-ignore
     set(A, B, C, D, E, F, G, H) {
       this.A = A | 0;
       this.B = B | 0;
@@ -2131,6 +2138,7 @@ var starknet = (() => {
       mul: (lhs, rhs) => mod(lhs * rhs, ORDER),
       pow: (num, power) => FpPow(f, num, power),
       div: (lhs, rhs) => mod(lhs * invert(rhs, ORDER), ORDER),
+      // Same as above, but doesn't normalize
       sqrN: (num) => num * num,
       addN: (lhs, rhs) => lhs + rhs,
       subN: (lhs, rhs) => lhs - rhs,
@@ -2138,6 +2146,8 @@ var starknet = (() => {
       inv: (num) => invert(num, ORDER),
       sqrt: redef.sqrt || ((n) => sqrtP(f, n)),
       invertBatch: (lst) => FpInvertBatch(f, lst),
+      // TODO: do we really need constant cmov?
+      // We don't have const-time bigints anyway, so probably will be not very useful
       cmov: (a, b, c) => c ? b : a,
       toBytes: (num) => isLE2 ? numberToBytesLE2(num, BYTES) : numberToBytesBE2(num, BYTES),
       fromBytes: (bytes2) => {
@@ -2257,6 +2267,7 @@ var starknet = (() => {
     };
     return {
       constTimeNegate,
+      // non-const time multiplication ladder
       unsafeLadder(elm, n) {
         let p = c.ZERO;
         let d = elm;
@@ -2268,6 +2279,16 @@ var starknet = (() => {
         }
         return p;
       },
+      /**
+       * Creates a wNAF precomputation window. Used for caching.
+       * Default window size is set by `utils.precompute()` and is equal to 8.
+       * Number of precomputed points depends on the curve size:
+       * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:
+       * - 𝑊 is the window size
+       * - 𝑛 is the bitlength of the curve order.
+       * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.
+       * @returns precomputed point tables flattened to a single array
+       */
       precomputeWindow(elm, W) {
         const { windows, windowSize } = opts(W);
         const points = [];
@@ -2284,6 +2305,13 @@ var starknet = (() => {
         }
         return points;
       },
+      /**
+       * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.
+       * @param W window size
+       * @param precomputes precomputed tables
+       * @param n scalar (we don't check here, but should be less than curve order)
+       * @returns real and fake (for const-time) points
+       */
       wNAF(W, precomputes, n) {
         const { windows, windowSize } = opts(W);
         let p = c.ZERO;
@@ -2370,6 +2398,7 @@ var starknet = (() => {
   }
   var { bytesToNumberBE: b2n, hexToBytes: h2b } = utils_exports2;
   var DER = {
+    // asn.1 DER encoding utils
     Err: class DERErr extends Error {
       constructor(m = "") {
         super(m);
@@ -2490,6 +2519,8 @@ var starknet = (() => {
         if (pz == null || !Fp.isValid(pz))
           throw new Error("z required");
       }
+      // Does not validate if the point is on-curve.
+      // Use fromHex instead, or call assertValidity() later.
       static fromAffine(p) {
         const { x, y } = p || {};
         if (!p || !Fp.isValid(x) || !Fp.isValid(y))
@@ -2507,22 +2538,35 @@ var starknet = (() => {
       get y() {
         return this.toAffine().y;
       }
+      /**
+       * Takes a bunch of Projective Points but executes only one
+       * inversion on all of them. Inversion is very slow operation,
+       * so this improves performance massively.
+       * Optimization: converts a list of projective points to a list of identical points with Z=1.
+       */
       static normalizeZ(points) {
         const toInv = Fp.invertBatch(points.map((p) => p.pz));
         return points.map((p, i) => p.toAffine(toInv[i])).map(Point.fromAffine);
       }
+      /**
+       * Converts hash string or Uint8Array to Point.
+       * @param hex short/long ECDSA hex
+       */
       static fromHex(hex) {
         const P = Point.fromAffine(fromBytes(ensureBytes2("pointHex", hex)));
         P.assertValidity();
         return P;
       }
+      // Multiplies generator point by privateKey.
       static fromPrivateKey(privateKey) {
         return Point.BASE.multiply(normPrivateKeyToScalar(privateKey));
       }
+      // "Private method", don't use it directly
       _setWindowSize(windowSize) {
         this._WINDOW_SIZE = windowSize;
         pointPrecomputes.delete(this);
       }
+      // A point on curve is valid if it conforms to equation.
       assertValidity() {
         if (this.is0()) {
           if (CURVE2.allowInfinityPoint)
@@ -2545,6 +2589,9 @@ var starknet = (() => {
           return !Fp.isOdd(y);
         throw new Error("Field doesn't support isOdd");
       }
+      /**
+       * Compare one point to another.
+       */
       equals(other) {
         assertPrjPoint(other);
         const { px: X1, py: Y1, pz: Z1 } = this;
@@ -2553,9 +2600,16 @@ var starknet = (() => {
         const U2 = Fp.eql(Fp.mul(Y1, Z2), Fp.mul(Y2, Z1));
         return U1 && U2;
       }
+      /**
+       * Flips point to one corresponding to (x, -y) in Affine coordinates.
+       */
       negate() {
         return new Point(this.px, Fp.neg(this.py), this.pz);
       }
+      // Renes-Costello-Batina exception-free doubling formula.
+      // There is 30% faster Jacobian formula, but it is not complete.
+      // https://eprint.iacr.org/2015/1060, algorithm 3
+      // Cost: 8M + 3S + 3*a + 2*b3 + 15add.
       double() {
         const { a, b } = CURVE2;
         const b3 = Fp.mul(b, _3n2);
@@ -2594,6 +2648,10 @@ var starknet = (() => {
         Z3 = Fp.add(Z3, Z3);
         return new Point(X3, Y3, Z3);
       }
+      // Renes-Costello-Batina exception-free addition formula.
+      // There is 30% faster Jacobian formula, but it is not complete.
+      // https://eprint.iacr.org/2015/1060, algorithm 1
+      // Cost: 12M + 0S + 3*a + 3*b3 + 23add.
       add(other) {
         assertPrjPoint(other);
         const { px: X1, py: Y1, pz: Z1 } = this;
@@ -2655,6 +2713,11 @@ var starknet = (() => {
           return comp.map((p, i) => p.toAffine(toInv[i])).map(Point.fromAffine);
         });
       }
+      /**
+       * Non-constant-time multiplication. Uses double-and-add algorithm.
+       * It's faster, but should only be used when you don't care about
+       * an exposed private key e.g. sig verification, which works over *public* keys.
+       */
       multiplyUnsafe(n) {
         const I = Point.ZERO;
         if (n === _0n6)
@@ -2685,6 +2748,15 @@ var starknet = (() => {
         k2p = new Point(Fp.mul(k2p.px, endo.beta), k2p.py, k2p.pz);
         return k1p.add(k2p);
       }
+      /**
+       * Constant time multiplication.
+       * Uses wNAF method. Windowed method may be 10% faster,
+       * but takes 2x longer to generate and consumes 2x memory.
+       * Uses precomputes when available.
+       * Uses endomorphism for Koblitz curves.
+       * @param scalar by which the point would be multiplied
+       * @returns New point
+       */
       multiply(scalar) {
         assertGE(scalar);
         let n = scalar;
@@ -2706,12 +2778,21 @@ var starknet = (() => {
         }
         return Point.normalizeZ([point, fake])[0];
       }
+      /**
+       * Efficiently calculate `aP + bQ`. Unsafe, can expose private key, if used incorrectly.
+       * Not using Strauss-Shamir trick: precomputation tables are faster.
+       * The trick could be useful if both P and Q are not G (not in our case).
+       * @returns non-zero affine point
+       */
       multiplyAndAddUnsafe(Q, a, b) {
         const G = Point.BASE;
         const mul = (P, a2) => a2 === _0n6 || a2 === _1n6 || !P.equals(G) ? P.multiplyUnsafe(a2) : P.multiply(a2);
         const sum = mul(this, a).add(mul(Q, b));
         return sum.is0() ? void 0 : sum;
       }
+      // Converts Projective point to affine (x, y) coordinates.
+      // Can accept precomputed Z^-1 - for example, from invertBatch.
+      // (x, y, z) ∋ (x=x/z, y=y/z)
       toAffine(iz) {
         const { px: x, py: y, pz: z } = this;
         const is0 = this.is0();
@@ -2841,11 +2922,14 @@ var starknet = (() => {
         this.recovery = recovery;
         this.assertValidity();
       }
+      // pair (bytes of r, bytes of s)
       static fromCompact(hex) {
         const l = CURVE2.nByteLength;
         hex = ensureBytes2("compactSignature", hex, l * 2);
         return new Signature3(slcNum(hex, 0, l), slcNum(hex, l, 2 * l));
       }
+      // DER encoded ECDSA signature
+      // https://bitcoin.stackexchange.com/questions/57644/what-are-the-parts-of-a-bitcoin-transaction-input-script
       static fromDER(hex) {
         const { r, s } = DER.toSig(ensureBytes2("DER", hex));
         return new Signature3(r, s);
@@ -2878,18 +2962,21 @@ var starknet = (() => {
         Q.assertValidity();
         return Q;
       }
+      // Signatures should be low-s, to prevent malleability.
       hasHighS() {
         return isBiggerThanHalfOrder(this.s);
       }
       normalizeS() {
         return this.hasHighS() ? new Signature3(this.r, modN(-this.s), this.recovery) : this;
       }
+      // DER-encoded
       toDERRawBytes() {
         return hexToBytes3(this.toDERHex());
       }
       toDERHex() {
         return DER.hexFromSig({ r: this.r, s: this.s });
       }
+      // padded bytes of r, then padded bytes of s
       toCompactRawBytes() {
         return hexToBytes3(this.toCompactHex());
       }
@@ -2907,11 +2994,23 @@ var starknet = (() => {
         }
       },
       normPrivateKeyToScalar,
+      /**
+       * Produces cryptographically secure private key from random of size (nBitLength+64)
+       * as per FIPS 186 B.4.1 with modulo bias being neglible.
+       */
       randomPrivateKey: () => {
         const rand = CURVE2.randomBytes(Fp.BYTES + 8);
         const num = hashToPrivateScalar(rand, CURVE_ORDER2);
         return numberToBytesBE2(num, CURVE2.nByteLength);
       },
+      /**
+       * Creates precompute table for an arbitrary EC point. Makes point "cached".
+       * Allows to massively speed-up `point.multiply(scalar)`.
+       * @returns cached point
+       * @example
+       * const fast = utils.precompute(8, ProjectivePoint.fromHex(someonesPubKey));
+       * fast.multiply(privKey); // much faster ECDH now
+       */
       precompute(windowSize = 8, point = Point.BASE) {
         point._setWindowSize(windowSize);
         point.multiply(BigInt(3));
@@ -3007,7 +3106,6 @@ var starknet = (() => {
     }
     Point.BASE._setWindowSize(8);
     function verify2(signature, msgHash, publicKey, opts = defaultVerOpts) {
-      var _a;
       const sg = signature;
       msgHash = ensureBytes2("msgHash", msgHash);
       publicKey = ensureBytes2("publicKey", publicKey);
@@ -3046,7 +3144,7 @@ var starknet = (() => {
       const is = invN(s);
       const u1 = modN(h * is);
       const u2 = modN(r * is);
-      const R = (_a = Point.BASE.multiplyAndAddUnsafe(P, u1, u2)) == null ? void 0 : _a.toAffine();
+      const R = Point.BASE.multiplyAndAddUnsafe(P, u1, u2)?.toAffine();
       if (!R)
         return false;
       const v = modN(R.x);
@@ -5631,7 +5729,9 @@ var starknet = (() => {
     if (!isUint256(bn))
       throw new Error("Number is too large");
     return {
+      // eslint-disable-next-line no-bitwise
       low: (bn & UINT_128_MAX).toString(10),
+      // eslint-disable-next-line no-bitwise
       high: (bn >> 128n).toString(10)
     };
   };
@@ -5767,7 +5867,11 @@ var starknet = (() => {
   }
   function extractCairo1Tuple(type) {
     const cleanType = type.replace(/\s/g, "").slice(1, -1);
-    return cleanType.split(",");
+    const { subTuple, result } = parseSubTuple(cleanType);
+    const recomposed = result.split(",").map((it) => {
+      return subTuple.length ? it.replace(" ", subTuple.shift()) : it;
+    });
+    return recomposed;
   }
   function extractTupleMemberTypes(type) {
     if (isCairo1Type(type)) {
@@ -5776,6 +5880,142 @@ var starknet = (() => {
     return extractCairo0Tuple(type);
   }
 
+  // src/utils/calldata/propertyOrder.ts
+  function errorU256(key) {
+    return Error(
+      `Your object includes the property : ${key}, containing an Uint256 object without the 'low' and 'high' keys.`
+    );
+  }
+  function orderPropsByAbi(unorderedObject, abiOfObject, structs) {
+    const orderStruct = (unorderedObject2, abiObject) => {
+      const orderedObject2 = abiObject.reduce((orderedObject, abiParam) => {
+        const setProperty = (value) => Object.defineProperty(orderedObject, abiParam.name, {
+          enumerable: true,
+          value: value ?? unorderedObject2[abiParam.name]
+        });
+        if (unorderedObject2[abiParam.name] === "undefined") {
+          if (isCairo1Type(abiParam.type) || !isLen(abiParam.name)) {
+            throw Error(`Your object needs a property with key : ${abiParam.name} .`);
+          }
+        }
+        switch (true) {
+          case isTypeStruct(abiParam.type, structs):
+            setProperty(
+              orderStruct(
+                unorderedObject2[abiParam.name],
+                structs[abiParam.type].members
+              )
+            );
+            break;
+          case isTypeUint256(abiParam.type): {
+            const u256 = unorderedObject2[abiParam.name];
+            if (typeof u256 !== "object") {
+              setProperty();
+              break;
+            }
+            if (!("low" in u256 && "high" in u256)) {
+              throw errorU256(abiParam.name);
+            }
+            setProperty({ low: u256.low, high: u256.high });
+            break;
+          }
+          case isTypeTuple(abiParam.type):
+            setProperty(orderTuple(unorderedObject2[abiParam.name], abiParam));
+            break;
+          case isTypeArray(abiParam.type):
+            setProperty(orderArray(unorderedObject2[abiParam.name], abiParam));
+            break;
+          case (!isCairo1Type(abiParam.type) && isLen(abiParam.name)):
+            break;
+          default:
+            setProperty();
+        }
+        return orderedObject;
+      }, {});
+      return orderedObject2;
+    };
+    function orderArray(myArray, abiParam) {
+      const typeInArray = getArrayType(abiParam.type);
+      if (typeof myArray === "string") {
+        return myArray;
+      }
+      switch (true) {
+        case typeInArray in structs:
+          return myArray.map((myObj) => orderStruct(myObj, structs[typeInArray].members));
+        case typeInArray === "core::integer::u256":
+          return myArray.map((u256) => {
+            if (typeof u256 !== "object") {
+              return u256;
+            }
+            if (!("low" in u256 && "high" in u256)) {
+              throw errorU256(abiParam.name);
+            }
+            return { low: u256.low, high: u256.high };
+          });
+        case isTypeTuple(typeInArray):
+          return myArray.map((myElem) => orderTuple(myElem, { name: "0", type: typeInArray }));
+        case isTypeArray(typeInArray):
+          return myArray.map((myElem) => orderArray(myElem, { name: "0", type: typeInArray }));
+        default:
+          return myArray;
+      }
+    }
+    function orderTuple(unorderedObject2, abiParam) {
+      const typeList = extractTupleMemberTypes(abiParam.type);
+      const orderedObject2 = typeList.reduce((orderedObject, abiTypeCairoX, index) => {
+        const myObjKeys = Object.keys(unorderedObject2);
+        const setProperty = (value) => Object.defineProperty(orderedObject, index.toString(), {
+          enumerable: true,
+          value: value ?? unorderedObject2[myObjKeys[index]]
+        });
+        const abiType = abiTypeCairoX?.type ? abiTypeCairoX.type : abiTypeCairoX;
+        switch (true) {
+          case isTypeStruct(abiType, structs):
+            setProperty(
+              orderStruct(
+                unorderedObject2[myObjKeys[index]],
+                structs[abiType].members
+              )
+            );
+            break;
+          case isTypeUint256(abiType): {
+            const u256 = unorderedObject2[myObjKeys[index]];
+            if (typeof u256 !== "object") {
+              setProperty();
+              break;
+            }
+            if (!("low" in u256 && "high" in u256)) {
+              throw errorU256(abiParam.name);
+            }
+            setProperty({ low: u256.low, high: u256.high });
+            break;
+          }
+          case isTypeTuple(abiType):
+            setProperty(
+              orderTuple(unorderedObject2[myObjKeys[index]], {
+                name: "0",
+                type: abiType
+              })
+            );
+            break;
+          case isTypeArray(abiType):
+            setProperty(
+              orderArray(unorderedObject2[myObjKeys[index]], {
+                name: "0",
+                type: abiType
+              })
+            );
+            break;
+          default:
+            setProperty();
+        }
+        return orderedObject;
+      }, {});
+      return orderedObject2;
+    }
+    return orderStruct(unorderedObject, abiOfObject);
+  }
+
   // src/utils/calldata/requestParser.ts
   function parseBaseTypes(type, val) {
     switch (true) {
@@ -5887,8 +6127,8 @@ var starknet = (() => {
     if (isTypeTuple(element.type)) {
       const memberTypes = extractTupleMemberTypes(element.type);
       return memberTypes.reduce((acc, it, idx) => {
-        const name = (it == null ? void 0 : it.name) ? it.name : idx;
-        const type = (it == null ? void 0 : it.type) ? it.type : it;
+        const name = it?.name ? it.name : idx;
+        const type = it?.type ? it.type : it;
         const el = { name, type };
         acc[name] = parseResponseValue(responseIterator, el, structs);
         return acc;
@@ -6096,6 +6336,12 @@ var starknet = (() => {
       this.abi = abi;
       this.structs = CallData.getAbiStruct(abi);
     }
+    /**
+     * Validate arguments passed to the method as corresponding to the ones in the abi
+     * @param type string - type of the method
+     * @param method string - name of the method
+     * @param args ArgsOrCalldata - arguments that are passed to the method
+     */
     validate(type, method, args = []) {
       if (type !== "DEPLOY") {
         const invocableFunctionNames = this.abi.filter((abi) => {
@@ -6120,14 +6366,41 @@ var starknet = (() => {
       }
       validateFields(abiMethod, args, this.structs);
     }
-    compile(method, args) {
+    /**
+     * Compile contract callData with abi
+     * Parse the calldata by using input fields from the abi for that method
+     * @param method string - method name
+     * @param args RawArgs - arguments passed to the method. Can be an array of arguments (in the order of abi definition), or an object constructed in conformity with abi (in this case, the parameter can be in a wrong order).
+     * @return Calldata - parsed arguments in format that contract is expecting
+     * @example
+     * ```typescript
+     * const calldata = myCallData.compile("constructor",["0x34a",[1,3n]]);
+     * ```
+     * ```typescript
+     * const calldata2 = myCallData.compile("constructor",{list:[1,3n],balance:"0x34"}); // wrong order is valid
+     * ```
+     */
+    compile(method, argsCalldata) {
+      const abiMethod = this.abi.find((abi) => abi.name === method);
+      let args;
+      if (Array.isArray(argsCalldata)) {
+        args = argsCalldata;
+      } else {
+        const orderedObject = orderPropsByAbi(argsCalldata, abiMethod.inputs, this.structs);
+        args = Object.values(orderedObject);
+        validateFields(abiMethod, args, this.structs);
+      }
       const argsIterator = args[Symbol.iterator]();
-      const { inputs } = this.abi.find((abi) => abi.name === method);
-      return inputs.reduce(
+      return abiMethod.inputs.reduce(
         (acc, input) => isLen(input.name) ? acc : acc.concat(parseCalldataField(argsIterator, input, this.structs)),
         []
       );
     }
+    /**
+     * Compile contract callData without abi
+     * @param rawArgs RawArgs representing cairo method arguments or string array of compiled data
+     * @returns Calldata
+     */
     static compile(rawArgs) {
       const createTree = (obj) => {
         const getEntries = (o, prefix = "") => {
@@ -6162,6 +6435,12 @@ var starknet = (() => {
       });
       return callTreeArray;
     }
+    /**
+     * Parse elements of the response array and structuring them into response object
+     * @param method string - method name
+     * @param response string[] - response from the method
+     * @return Result - parsed response corresponding to the abi
+     */
     parse(method, response) {
       const { outputs } = this.abi.find((abi) => abi.name === method);
       const responseIterator = response.flat()[Symbol.iterator]();
@@ -6175,13 +6454,30 @@ var starknet = (() => {
       }, {});
       return Object.keys(parsed).length === 1 && 0 in parsed ? parsed[0] : parsed;
     }
+    /**
+     * Format cairo method response data to native js values based on provided format schema
+     * @param method string - cairo method name
+     * @param response string[] - cairo method response
+     * @param format object - formatter object schema
+     * @returns Result - parsed and formatted response object
+     */
     format(method, response, format) {
       const parsed = this.parse(method, response);
       return formatter(parsed, format);
     }
+    /**
+     * Helper to calculate inputs from abi
+     * @param inputs AbiEntry
+     * @returns number
+     */
     static abiInputsLength(inputs) {
       return inputs.reduce((acc, input) => !isLen(input.name) ? acc + 1 : acc, 0);
     }
+    /**
+     * Helper to extract structs from abi
+     * @param abi Abi
+     * @returns AbiStructs - structs from abi
+     */
     static getAbiStruct(abi) {
       return abi.filter((abiEntry) => abiEntry.type === "struct").reduce(
         (acc, abiEntry) => ({
@@ -6191,9 +6487,19 @@ var starknet = (() => {
         {}
       );
     }
+    /**
+     * Helper: Compile HexCalldata | RawCalldata | RawArgs
+     * @param rawCalldata HexCalldata | RawCalldata | RawArgs
+     * @returns Calldata
+     */
     static toCalldata(rawCalldata = []) {
       return CallData.compile(rawCalldata);
     }
+    /**
+     * Helper: Convert raw to HexCalldata
+     * @param raw HexCalldata | RawCalldata | RawArgs
+     * @returns HexCalldata
+     */
     static toHex(raw = []) {
       const calldata = CallData.compile(raw);
       return calldata.map((it) => toHex(it));
@@ -6202,7 +6508,9 @@ var starknet = (() => {
 
   // src/utils/fetchPonyfill.ts
   var import_isomorphic_fetch = __toESM(require_fetch_npm_browserify());
-  var fetchPonyfill_default = typeof window !== "undefined" && window.fetch || typeof global !== "undefined" && global.fetch || import_isomorphic_fetch.default;
+  var fetchPonyfill_default = typeof window !== "undefined" && window.fetch || // use buildin fetch in browser if available
+  typeof global !== "undefined" && global.fetch || // use buildin fetch in node, react-native and service worker if available
+  import_isomorphic_fetch.default;
 
   // src/utils/hash.ts
   var hash_exports = {};
@@ -6358,6 +6666,7 @@ var starknet = (() => {
     };
     return {
       constTimeNegate,
+      // non-const time multiplication ladder
       unsafeLadder(elm, n) {
         let p = c.ZERO;
         let d = elm;
@@ -6369,6 +6678,16 @@ var starknet = (() => {
         }
         return p;
       },
+      /**
+       * Creates a wNAF precomputation window. Used for caching.
+       * Default window size is set by `utils.precompute()` and is equal to 8.
+       * Number of precomputed points depends on the curve size:
+       * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:
+       * - 𝑊 is the window size
+       * - 𝑛 is the bitlength of the curve order.
+       * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.
+       * @returns precomputed point tables flattened to a single array
+       */
       precomputeWindow(elm, W) {
         const { windows, windowSize } = opts(W);
         const points = [];
@@ -6385,6 +6704,13 @@ var starknet = (() => {
         }
         return points;
       },
+      /**
+       * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.
+       * @param W window size
+       * @param precomputes precomputed tables
+       * @param n scalar (we don't check here, but should be less than curve order)
+       * @returns real and fake (for const-time) points
+       */
       wNAF(W, precomputes, n) {
         const { windows, windowSize } = opts(W);
         let p = c.ZERO;
@@ -6467,6 +6793,7 @@ var starknet = (() => {
   }
   var { bytesToNumberBE: b2n2, hexToBytes: h2b2 } = utils_exports;
   var DER2 = {
+    // asn.1 DER encoding utils
     Err: class DERErr2 extends Error {
       constructor(m = "") {
         super(m);
@@ -6570,6 +6897,8 @@ var starknet = (() => {
         if (pz == null || !Fp.isValid(pz))
           throw new Error("z required");
       }
+      // Does not validate if the point is on-curve.
+      // Use fromHex instead, or call assertValidity() later.
       static fromAffine(p) {
         const { x, y } = p || {};
         if (!p || !Fp.isValid(x) || !Fp.isValid(y))
@@ -6587,22 +6916,35 @@ var starknet = (() => {
       get y() {
         return this.toAffine().y;
       }
+      /**
+       * Takes a bunch of Projective Points but executes only one
+       * inversion on all of them. Inversion is very slow operation,
+       * so this improves performance massively.
+       * Optimization: converts a list of projective points to a list of identical points with Z=1.
+       */
       static normalizeZ(points) {
         const toInv = Fp.invertBatch(points.map((p) => p.pz));
         return points.map((p, i) => p.toAffine(toInv[i])).map(Point.fromAffine);
       }
+      /**
+       * Converts hash string or Uint8Array to Point.
+       * @param hex short/long ECDSA hex
+       */
       static fromHex(hex) {
         const P = Point.fromAffine(CURVE2.fromBytes(ensureBytes("pointHex", hex)));
         P.assertValidity();
         return P;
       }
+      // Multiplies generator point by privateKey.
       static fromPrivateKey(privateKey) {
         return Point.BASE.multiply(normPrivateKeyToScalar(privateKey));
       }
+      // "Private method", don't use it directly
       _setWindowSize(windowSize) {
         this._WINDOW_SIZE = windowSize;
         pointPrecomputes.delete(this);
       }
+      // A point on curve is valid if it conforms to equation.
       assertValidity() {
         if (this.is0()) {
           if (CURVE2.allowInfinityPoint)
@@ -6625,6 +6967,9 @@ var starknet = (() => {
           return !Fp.isOdd(y);
         throw new Error("Field doesn't support isOdd");
       }
+      /**
+       * Compare one point to another.
+       */
       equals(other) {
         assertPrjPoint(other);
         const { px: X1, py: Y1, pz: Z1 } = this;
@@ -6633,9 +6978,16 @@ var starknet = (() => {
         const U2 = Fp.eql(Fp.mul(Y1, Z2), Fp.mul(Y2, Z1));
         return U1 && U2;
       }
+      /**
+       * Flips point to one corresponding to (x, -y) in Affine coordinates.
+       */
       negate() {
         return new Point(this.px, Fp.neg(this.py), this.pz);
       }
+      // Renes-Costello-Batina exception-free doubling formula.
+      // There is 30% faster Jacobian formula, but it is not complete.
+      // https://eprint.iacr.org/2015/1060, algorithm 3
+      // Cost: 8M + 3S + 3*a + 2*b3 + 15add.
       double() {
         const { a, b } = CURVE2;
         const b3 = Fp.mul(b, 3n);
@@ -6674,6 +7026,10 @@ var starknet = (() => {
         Z3 = Fp.add(Z3, Z3);
         return new Point(X3, Y3, Z3);
       }
+      // Renes-Costello-Batina exception-free addition formula.
+      // There is 30% faster Jacobian formula, but it is not complete.
+      // https://eprint.iacr.org/2015/1060, algorithm 1
+      // Cost: 12M + 0S + 3*a + 3*b3 + 23add.
       add(other) {
         assertPrjPoint(other);
         const { px: X1, py: Y1, pz: Z1 } = this;
@@ -6735,6 +7091,11 @@ var starknet = (() => {
           return comp.map((p, i) => p.toAffine(toInv[i])).map(Point.fromAffine);
         });
       }
+      /**
+       * Non-constant-time multiplication. Uses double-and-add algorithm.
+       * It's faster, but should only be used when you don't care about
+       * an exposed private key e.g. sig verification, which works over *public* keys.
+       */
       multiplyUnsafe(n) {
         const I = Point.ZERO;
         if (n === _0n9)
@@ -6765,6 +7126,15 @@ var starknet = (() => {
         k2p = new Point(Fp.mul(k2p.px, endo.beta), k2p.py, k2p.pz);
         return k1p.add(k2p);
       }
+      /**
+       * Constant time multiplication.
+       * Uses wNAF method. Windowed method may be 10% faster,
+       * but takes 2x longer to generate and consumes 2x memory.
+       * Uses precomputes when available.
+       * Uses endomorphism for Koblitz curves.
+       * @param scalar by which the point would be multiplied
+       * @returns New point
+       */
       multiply(scalar) {
         assertGE(scalar);
         let n = scalar;
@@ -6786,12 +7156,21 @@ var starknet = (() => {
         }
         return Point.normalizeZ([point, fake])[0];
       }
+      /**
+       * Efficiently calculate `aP + bQ`. Unsafe, can expose private key, if used incorrectly.
+       * Not using Strauss-Shamir trick: precomputation tables are faster.
+       * The trick could be useful if both P and Q are not G (not in our case).
+       * @returns non-zero affine point
+       */
       multiplyAndAddUnsafe(Q, a, b) {
         const G = Point.BASE;
         const mul = (P, a2) => a2 === _0n9 || a2 === _1n9 || !P.equals(G) ? P.multiplyUnsafe(a2) : P.multiply(a2);
         const sum = mul(this, a).add(mul(Q, b));
         return sum.is0() ? void 0 : sum;
       }
+      // Converts Projective point to affine (x, y) coordinates.
+      // Can accept precomputed Z^-1 - for example, from invertBatch.
+      // (x, y, z) ∋ (x=x/z, y=y/z)
       toAffine(iz) {
         const { px: x, py: y, pz: z } = this;
         const is0 = this.is0();
@@ -6921,11 +7300,14 @@ var starknet = (() => {
         this.recovery = recovery;
         this.assertValidity();
       }
+      // pair (bytes of r, bytes of s)
       static fromCompact(hex) {
         const l = CURVE2.nByteLength;
         hex = ensureBytes("compactSignature", hex, l * 2);
         return new Signature3(slcNum(hex, 0, l), slcNum(hex, l, 2 * l));
       }
+      // DER encoded ECDSA signature
+      // https://bitcoin.stackexchange.com/questions/57644/what-are-the-parts-of-a-bitcoin-transaction-input-script
       static fromDER(hex) {
         const { r, s } = DER2.toSig(ensureBytes("DER", hex));
         return new Signature3(r, s);
@@ -6958,18 +7340,21 @@ var starknet = (() => {
         Q.assertValidity();
         return Q;
       }
+      // Signatures should be low-s, to prevent malleability.
       hasHighS() {
         return isBiggerThanHalfOrder(this.s);
       }
       normalizeS() {
         return this.hasHighS() ? new Signature3(this.r, modN(-this.s), this.recovery) : this;
       }
+      // DER-encoded
       toDERRawBytes() {
         return hexToBytes(this.toDERHex());
       }
       toDERHex() {
         return DER2.hexFromSig({ r: this.r, s: this.s });
       }
+      // padded bytes of r, then padded bytes of s
       toCompactRawBytes() {
         return hexToBytes(this.toCompactHex());
       }
@@ -6987,11 +7372,23 @@ var starknet = (() => {
         }
       },
       normPrivateKeyToScalar,
+      /**
+       * Produces cryptographically secure private key from random of size (nBitLength+64)
+       * as per FIPS 186 B.4.1 with modulo bias being neglible.
+       */
       randomPrivateKey: () => {
         const rand = CURVE2.randomBytes(Fp.BYTES + 8);
         const num = hashToPrivateScalar2(rand, CURVE_ORDER2);
         return numberToBytesBE(num, CURVE2.nByteLength);
       },
+      /**
+       * Creates precompute table for an arbitrary EC point. Makes point "cached".
+       * Allows to massively speed-up `point.multiply(scalar)`.
+       * @returns cached point
+       * @example
+       * const fast = utils.precompute(8, ProjectivePoint.fromHex(someonesPubKey));
+       * fast.multiply(privKey); // much faster ECDH now
+       */
       precompute(windowSize = 8, point = Point.BASE) {
         point._setWindowSize(windowSize);
         point.multiply(BigInt(3));
@@ -7087,7 +7484,6 @@ var starknet = (() => {
     }
     Point.BASE._setWindowSize(8);
     function verify2(signature, msgHash, publicKey, opts = defaultVerOpts) {
-      var _a;
       const sg = signature;
       msgHash = ensureBytes("msgHash", msgHash);
       publicKey = ensureBytes("publicKey", publicKey);
@@ -7126,7 +7522,7 @@ var starknet = (() => {
       const is = invN(s);
       const u1 = modN(h * is);
       const u2 = modN(r * is);
-      const R = (_a = Point.BASE.multiplyAndAddUnsafe(P, u1, u2)) == null ? void 0 : _a.toAffine();
+      const R = Point.BASE.multiplyAndAddUnsafe(P, u1, u2)?.toAffine();
       if (!R)
         return false;
       const v = modN(R.x);
@@ -7385,11 +7781,17 @@ var starknet = (() => {
         }
         throw new Error("Cannot safely convert to number: " + "the value '".concat(this.value, "' would ").concat(unsafeReason, " and become ").concat(parseFloat(this.value)));
       }
+      /**
+       * Get the value of the LosslessNumber as string.
+       */
     }, {
       key: "toString",
       value: function toString2() {
         return this.value;
       }
+      // Note: we do NOT implement a .toJSON() method, and you should not implement
+      // or use that, it cannot safely turn the numeric value in the string into
+      // stringified JSON since it has to be parsed into a number first.
     }]);
     return LosslessNumber2;
   }();
@@ -7760,6 +8162,7 @@ var starknet = (() => {
     n: "\n",
     r: "\r",
     t: "	"
+    // note that \u is handled separately in parseString()
   };
   var codeBackslash = 92;
   var codeOpeningBrace = 123;
@@ -8281,9 +8684,18 @@ var starknet = (() => {
   var REP_3_6 = 16;
   var REPZ_3_10 = 17;
   var REPZ_11_138 = 18;
-  var extra_lbits = new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0]);
-  var extra_dbits = new Uint8Array([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13]);
-  var extra_blbits = new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7]);
+  var extra_lbits = (
+    /* extra bits for each length code */
+    new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0])
+  );
+  var extra_dbits = (
+    /* extra bits for each distance code */
+    new Uint8Array([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13])
+  );
+  var extra_blbits = (
+    /* extra bits for each bit length code */
+    new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7])
+  );
   var bl_order = new Uint8Array([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
   var DIST_CODE_LEN = 512;
   var static_ltree = new Array((L_CODES$1 + 2) * 2);
@@ -8333,7 +8745,12 @@ var starknet = (() => {
     }
   };
   var send_code = (s, c, tree) => {
-    send_bits(s, tree[c * 2], tree[c * 2 + 1]);
+    send_bits(
+      s,
+      tree[c * 2],
+      tree[c * 2 + 1]
+      /*.Len*/
+    );
   };
   var bi_reverse = (code, len) => {
     let res = 0;
@@ -8614,19 +9031,44 @@ var starknet = (() => {
     }
     node = elems;
     do {
-      n = s.heap[1];
-      s.heap[1] = s.heap[s.heap_len--];
-      pqdownheap(s, tree, 1);
-      m = s.heap[1];
+      n = s.heap[
+        1
+        /*SMALLEST*/
+      ];
+      s.heap[
+        1
+        /*SMALLEST*/
+      ] = s.heap[s.heap_len--];
+      pqdownheap(
+        s,
+        tree,
+        1
+        /*SMALLEST*/
+      );
+      m = s.heap[
+        1
+        /*SMALLEST*/
+      ];
       s.heap[--s.heap_max] = n;
       s.heap[--s.heap_max] = m;
       tree[node * 2] = tree[n * 2] + tree[m * 2];
       s.depth[node] = (s.depth[n] >= s.depth[m] ? s.depth[n] : s.depth[m]) + 1;
       tree[n * 2 + 1] = tree[m * 2 + 1] = node;
-      s.heap[1] = node++;
-      pqdownheap(s, tree, 1);
+      s.heap[
+        1
+        /*SMALLEST*/
+      ] = node++;
+      pqdownheap(
+        s,
+        tree,
+        1
+        /*SMALLEST*/
+      );
     } while (s.heap_len >= 2);
-    s.heap[--s.heap_max] = s.heap[1];
+    s.heap[--s.heap_max] = s.heap[
+      1
+      /*SMALLEST*/
+    ];
     gen_bitlen(s, desc);
     gen_codes(tree, max_code, s.bl_count);
   };
@@ -8891,16 +9333,26 @@ var starknet = (() => {
   var crc32_1 = crc32;
   var messages = {
     2: "need dictionary",
+    /* Z_NEED_DICT       2  */
     1: "stream end",
+    /* Z_STREAM_END      1  */
     0: "",
+    /* Z_OK              0  */
     "-1": "file error",
+    /* Z_ERRNO         (-1) */
     "-2": "stream error",
+    /* Z_STREAM_ERROR  (-2) */
     "-3": "data error",
+    /* Z_DATA_ERROR    (-3) */
     "-4": "insufficient memory",
+    /* Z_MEM_ERROR     (-4) */
     "-5": "buffer error",
+    /* Z_BUF_ERROR     (-5) */
     "-6": "incompatible version"
+    /* Z_VERSION_ERROR (-6) */
   };
   var constants$2 = {
+    /* Allowed flush values; see deflate() and inflate() below for details */
     Z_NO_FLUSH: 0,
     Z_PARTIAL_FLUSH: 1,
     Z_SYNC_FLUSH: 2,
@@ -8908,6 +9360,9 @@ var starknet = (() => {
     Z_FINISH: 4,
     Z_BLOCK: 5,
     Z_TREES: 6,
+    /* Return codes for the compression/decompression functions. Negative values
+    * are errors, positive values are used for special but normal events.
+    */
     Z_OK: 0,
     Z_STREAM_END: 1,
     Z_NEED_DICT: 2,
@@ -8916,6 +9371,8 @@ var starknet = (() => {
     Z_DATA_ERROR: -3,
     Z_MEM_ERROR: -4,
     Z_BUF_ERROR: -5,
+    //Z_VERSION_ERROR: -6,
+    /* compression levels */
     Z_NO_COMPRESSION: 0,
     Z_BEST_SPEED: 1,
     Z_BEST_COMPRESSION: 9,
@@ -8925,10 +9382,14 @@ var starknet = (() => {
     Z_RLE: 3,
     Z_FIXED: 4,
     Z_DEFAULT_STRATEGY: 0,
+    /* Possible values of the data_type field (though see inflate()) */
     Z_BINARY: 0,
     Z_TEXT: 1,
+    //Z_ASCII:                1, // = Z_TEXT (deprecated)
     Z_UNKNOWN: 2,
+    /* The deflate compression method */
     Z_DEFLATED: 8
+    //Z_NULL:                 null // Use -1 or null inline, depending on var type
   };
   var { _tr_init, _tr_stored_block, _tr_flush_block, _tr_tally, _tr_align } = trees;
   var {
@@ -9523,16 +9984,27 @@ var starknet = (() => {
     this.func = func;
   }
   var configuration_table = [
+    /*      good lazy nice chain */
     new Config(0, 0, 0, 0, deflate_stored),
+    /* 0 store only */
     new Config(4, 4, 8, 4, deflate_fast),
+    /* 1 max speed, no lazy matches */
     new Config(4, 5, 16, 8, deflate_fast),
+    /* 2 */
     new Config(4, 6, 32, 32, deflate_fast),
+    /* 3 */
     new Config(4, 4, 16, 16, deflate_slow),
+    /* 4 lazy matches */
     new Config(8, 16, 32, 32, deflate_slow),
+    /* 5 */
     new Config(8, 16, 128, 128, deflate_slow),
+    /* 6 */
     new Config(8, 32, 128, 256, deflate_slow),
+    /* 7 */
     new Config(32, 128, 258, 1024, deflate_slow),
+    /* 8 */
     new Config(32, 258, 258, 4096, deflate_slow)
+    /* 9 max compression */
   ];
   var lm_init = (s) => {
     s.window_size = 2 * s.w_size;
@@ -9619,7 +10091,9 @@ var starknet = (() => {
       return 1;
     }
     const s = strm.state;
-    if (!s || s.strm !== strm || s.status !== INIT_STATE && s.status !== GZIP_STATE && s.status !== EXTRA_STATE && s.status !== NAME_STATE && s.status !== COMMENT_STATE && s.status !== HCRC_STATE && s.status !== BUSY_STATE && s.status !== FINISH_STATE) {
+    if (!s || s.strm !== strm || s.status !== INIT_STATE && //#ifdef GZIP
+    s.status !== GZIP_STATE && //#endif
+    s.status !== EXTRA_STATE && s.status !== NAME_STATE && s.status !== COMMENT_STATE && s.status !== HCRC_STATE && s.status !== BUSY_STATE && s.status !== FINISH_STATE) {
       return 1;
     }
     return 0;
@@ -9636,7 +10110,11 @@ var starknet = (() => {
     if (s.wrap < 0) {
       s.wrap = -s.wrap;
     }
-    s.status = s.wrap === 2 ? GZIP_STATE : s.wrap ? INIT_STATE : BUSY_STATE;
+    s.status = //#ifdef GZIP
+    s.wrap === 2 ? GZIP_STATE : (
+      //#endif
+      s.wrap ? INIT_STATE : BUSY_STATE
+    );
     strm.adler = s.wrap === 2 ? 0 : 1;
     s.last_flush = -2;
     _tr_init(s);
@@ -10621,6 +11099,7 @@ var starknet = (() => {
   var LENS$1 = 1;
   var DISTS$1 = 2;
   var lbase = new Uint16Array([
+    /* Length codes 257..285 base */
     3,
     4,
     5,
@@ -10654,6 +11133,7 @@ var starknet = (() => {
     0
   ]);
   var lext = new Uint8Array([
+    /* Length codes 257..285 extra */
     16,
     16,
     16,
@@ -10687,6 +11167,7 @@ var starknet = (() => {
     78
   ]);
   var dbase = new Uint16Array([
+    /* Distance codes 0..29 base */
     1,
     2,
     3,
@@ -10721,6 +11202,7 @@ var starknet = (() => {
     0
   ]);
   var dext = new Uint8Array([
+    /* Distance codes 0..29 extra */
     16,
     16,
     16,
@@ -11184,7 +11666,10 @@ var starknet = (() => {
     const hbuf = new Uint8Array(4);
     let opts;
     let n;
-    const order = new Uint8Array([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+    const order = (
+      /* permutation of code lengths */
+      new Uint8Array([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15])
+    );
     if (inflateStateCheck(strm) || !strm.output || !strm.input && strm.avail_in !== 0) {
       return Z_STREAM_ERROR$1;
     }
@@ -11235,7 +11720,8 @@ var starknet = (() => {
             if (state.head) {
               state.head.done = false;
             }
-            if (!(state.wrap & 1) || (((hold & 255) << 8) + (hold >> 8)) % 31) {
+            if (!(state.wrap & 1) || /* check if zlib header allowed */
+            (((hold & 255) << 8) + (hold >> 8)) % 31) {
               strm.msg = "incorrect header check";
               state.mode = BAD;
               break;
@@ -11377,8 +11863,11 @@ var starknet = (() => {
                   state.head.extra.set(
                     input.subarray(
                       next,
+                      // extra field is limited to 65536 bytes
+                      // - no need for additional size check
                       next + copy
                     ),
+                    /*len + copy > state.head.extra_max - len ? state.head.extra_max : copy,*/
                     len
                   );
                 }
@@ -11993,7 +12482,8 @@ var starknet = (() => {
               strm.total_out += _out;
               state.total += _out;
               if (state.wrap & 4 && _out) {
-                strm.adler = state.check = state.flags ? crc32_1(state.check, output2, _out, put - _out) : adler32_1(state.check, output2, _out, put - _out);
+                strm.adler = state.check = /*UPDATE_CHECK(state.check, put - _out, _out);*/
+                state.flags ? crc32_1(state.check, output2, _out, put - _out) : adler32_1(state.check, output2, _out, put - _out);
               }
               _out = left;
               if (state.wrap & 4 && (state.flags ? hold : zswap32(hold)) !== state.check) {
@@ -12053,7 +12543,8 @@ var starknet = (() => {
     strm.total_out += _out;
     state.total += _out;
     if (state.wrap & 4 && _out) {
-      strm.adler = state.check = state.flags ? crc32_1(state.check, output2, _out, strm.next_out - _out) : adler32_1(state.check, output2, _out, strm.next_out - _out);
+      strm.adler = state.check = /*UPDATE_CHECK(state.check, strm.next_out - _out, _out);*/
+      state.flags ? crc32_1(state.check, output2, _out, strm.next_out - _out) : adler32_1(state.check, output2, _out, strm.next_out - _out);
     }
     strm.data_type = state.bits + (state.last ? 64 : 0) + (state.mode === TYPE ? 128 : 0) + (state.mode === LEN_ || state.mode === COPY_ ? 256 : 0);
     if ((_in === 0 && _out === 0 || flush === Z_FINISH$1) && ret === Z_OK$1) {
@@ -12382,6 +12873,7 @@ var starknet = (() => {
     if (!isSierra(contract)) {
       return {
         ...parsedContract,
+        // TODO: Why do we gzip program object?
         ..."program" in parsedContract && { program: compressProgram(parsedContract.program) }
       };
     }
@@ -12634,6 +13126,7 @@ var starknet = (() => {
         this.tag = "pending";
       }
     }
+    // TODO: fix any
     get queryIdentifier() {
       if (this.number !== null) {
         return `blockNumber=${this.number}`;
@@ -12643,6 +13136,7 @@ var starknet = (() => {
       }
       return `blockNumber=${this.tag}`;
     }
+    // TODO: fix any
     get identifier() {
       if (this.number !== null) {
         return { block_number: this.number };
@@ -12690,17 +13184,17 @@ var starknet = (() => {
       }
     }
     async fetchEndpoint(method, params) {
-      var _a;
       try {
         const rawResult = await this.fetch(method, params);
         const { error, result } = await rawResult.json();
         this.errorHandler(error);
         return result;
       } catch (error) {
-        this.errorHandler((_a = error == null ? void 0 : error.response) == null ? void 0 : _a.data);
+        this.errorHandler(error?.response?.data);
         throw error;
       }
     }
+    // Methods from Interface
     async getChainId() {
       this.chainId ?? (this.chainId = await this.fetchEndpoint("starknet_chainId"));
       return this.chainId;
@@ -12754,6 +13248,7 @@ var starknet = (() => {
         block_id
       });
     }
+    // Methods from Interface
     async getTransaction(txHash) {
       return this.getTransactionByHash(txHash).then(this.responseParser.parseGetTransactionResponse);
     }
@@ -12795,9 +13290,9 @@ var starknet = (() => {
           sender_address: invocation.contractAddress,
           calldata: CallData.toHex(invocation.calldata),
           signature: signatureToHexArray(invocation.signature),
-          version: toHex((invocationDetails == null ? void 0 : invocationDetails.version) || 0),
+          version: toHex(invocationDetails?.version || 0),
           nonce: toHex(invocationDetails.nonce),
-          max_fee: toHex((invocationDetails == null ? void 0 : invocationDetails.maxFee) || 0)
+          max_fee: toHex(invocationDetails?.maxFee || 0)
         },
         block_id
       }).then(this.responseParser.parseFeeEstimateResponse);
@@ -12812,12 +13307,13 @@ var starknet = (() => {
               program: contractDefinition.program,
               entry_points_by_type: contractDefinition.entry_points_by_type,
               abi: contractDefinition.abi
+              // rpc 2.0
             },
             sender_address: senderAddress,
             signature: signatureToHexArray(signature),
-            version: toHex((details == null ? void 0 : details.version) || 0),
+            version: toHex(details?.version || 0),
             nonce: toHex(details.nonce),
-            max_fee: toHex((details == null ? void 0 : details.maxFee) || 0)
+            max_fee: toHex(details?.maxFee || 0)
           },
           block_id
         }).then(this.responseParser.parseFeeEstimateResponse);
@@ -12833,9 +13329,9 @@ var starknet = (() => {
           class_hash: toHex(classHash),
           contract_address_salt: toHex(addressSalt || 0),
           signature: signatureToHexArray(signature),
-          version: toHex((details == null ? void 0 : details.version) || 0),
+          version: toHex(details?.version || 0),
           nonce: toHex(details.nonce),
-          max_fee: toHex((details == null ? void 0 : details.maxFee) || 0)
+          max_fee: toHex(details?.maxFee || 0)
         },
         block_id
       }).then(this.responseParser.parseFeeEstimateResponse);
@@ -12843,6 +13339,7 @@ var starknet = (() => {
     async getEstimateFeeBulk(_invocations, _blockIdentifier = this.blockIdentifier) {
       throw new Error("RPC does not implement getInvokeEstimateFeeBulk function");
     }
+    // TODO: Revisit after Pathfinder release with JSON-RPC v0.2.1 RPC Spec
     async declareContract({ contractDefinition, signature, senderAddress }, details) {
       if ("program" in contractDefinition) {
         return this.fetchEndpoint("starknet_addDeclareTransaction", {
@@ -12851,6 +13348,7 @@ var starknet = (() => {
               program: contractDefinition.program,
               entry_points_by_type: contractDefinition.entry_points_by_type,
               abi: contractDefinition.abi
+              // rpc 2.0
             },
             type: RPC.TransactionType.DECLARE,
             version: "0x1",
@@ -12890,6 +13388,7 @@ var starknet = (() => {
         }
       });
     }
+    // Methods from Interface
     async callContract(call, blockIdentifier = this.blockIdentifier) {
       const block_id = new Block(blockIdentifier).identifier;
       const result = await this.fetchEndpoint("starknet_call", {
@@ -12913,8 +13412,8 @@ var starknet = (() => {
       let { retries } = this;
       let onchain = false;
       let txReceipt = {};
-      const retryInterval = (options == null ? void 0 : options.retryInterval) ?? 8e3;
-      const successStates = (options == null ? void 0 : options.successStates) ?? [
+      const retryInterval = options?.retryInterval ?? 8e3;
+      const successStates = options?.successStates ?? [
         "ACCEPTED_ON_L1" /* ACCEPTED_ON_L1 */,
         "ACCEPTED_ON_L2" /* ACCEPTED_ON_L2 */,
         "PENDING" /* PENDING */
@@ -12948,16 +13447,41 @@ var starknet = (() => {
       await wait(retryInterval);
       return txReceipt;
     }
+    /**
+     * Gets the transaction count from a block.
+     *
+     *
+     * @param blockIdentifier
+     * @returns Number of transactions
+     */
     async getTransactionCount(blockIdentifier = this.blockIdentifier) {
       const block_id = new Block(blockIdentifier).identifier;
       return this.fetchEndpoint("starknet_getBlockTransactionCount", { block_id });
     }
+    /**
+     * Gets the latest block number
+     *
+     *
+     * @returns Number of the latest block
+     */
     async getBlockNumber() {
       return this.fetchEndpoint("starknet_blockNumber");
     }
+    /**
+     * Gets syncing status of the node
+     *
+     *
+     * @returns Object with the stats data
+     */
     async getSyncingStats() {
       return this.fetchEndpoint("starknet_syncing");
     }
+    /**
+     * Gets all the events filtered
+     *
+     *
+     * @returns events and the pagination of the events
+     */
     async getEvents(eventFilter) {
       return this.fetchEndpoint("starknet_getEvents", { filter: eventFilter });
     }
@@ -13008,6 +13532,7 @@ var starknet = (() => {
         transaction_hash: res.transaction_hash,
         status: res.status,
         messages_sent: res.l2_to_l1_messages,
+        // TODO: parse
         events: res.events,
         ..."block_hash" in res && { block_hash: res.block_hash },
         ..."block_number" in res && { block_number: res.block_number },
@@ -13015,6 +13540,7 @@ var starknet = (() => {
         ..."transaction_index" in res && { transaction_index: res.transaction_index },
         ..."execution_resources" in res && { execution_resources: res.execution_resources },
         ..."l1_to_l2_consumed_message" in res && {
+          // eslint-disable-next-line @typescript-eslint/dot-notation
           l1_to_l2_consumed_message: res["l1_to_l2_consumed_message"]
         },
         ..."transaction_failure_reason" in res && {
@@ -13126,6 +13652,7 @@ var starknet = (() => {
         }
       };
     }
+    // TODO: Define response as new type as it diff from ContractClass
     parseSierraContractClassResponse(res) {
       return {
         ...res,
@@ -13187,9 +13714,9 @@ var starknet = (() => {
         );
         this.gatewayUrl = buildUrl(this.baseUrl, "gateway", optionsOrProvider.gatewayUrl);
       }
-      this.chainId = (optionsOrProvider == null ? void 0 : optionsOrProvider.chainId) ?? SequencerProvider.getChainIdFromBaseUrl(this.baseUrl);
+      this.chainId = optionsOrProvider?.chainId ?? SequencerProvider.getChainIdFromBaseUrl(this.baseUrl);
       this.headers = optionsOrProvider.headers;
-      this.blockIdentifier = (optionsOrProvider == null ? void 0 : optionsOrProvider.blockIdentifier) || defaultOptions2.blockIdentifier;
+      this.blockIdentifier = optionsOrProvider?.blockIdentifier || defaultOptions2.blockIdentifier;
     }
     static getNetworkFromName(name) {
       switch (name) {
@@ -13255,6 +13782,7 @@ var starknet = (() => {
       }
       return this.headers;
     }
+    // typesafe fetch
     async fetchEndpoint(endpoint, ...[query, request]) {
       const baseUrl = this.getFetchUrl(endpoint);
       const method = this.getFetchMethod(endpoint);
@@ -13267,9 +13795,9 @@ var starknet = (() => {
     }
     async fetch(endpoint, options) {
       const url = buildUrl(this.baseUrl, "", endpoint);
-      const method = (options == null ? void 0 : options.method) ?? "GET";
+      const method = options?.method ?? "GET";
       const headers = this.getHeaders(method);
-      const body = stringify2(options == null ? void 0 : options.body);
+      const body = stringify2(options?.body);
       try {
         const response = await fetchPonyfill_default(url, {
           method,
@@ -13286,7 +13814,7 @@ var starknet = (() => {
           }
           throw new GatewayError(responseBody.message, responseBody.code);
         }
-        const parseChoice = (options == null ? void 0 : options.parseAlwaysAsBigInt) ? parseAlwaysAsBig : parse2;
+        const parseChoice = options?.parseAlwaysAsBigInt ? parseAlwaysAsBig : parse2;
         return parseChoice(textResponse);
       } catch (error) {
         if (error instanceof Error && !(error instanceof LibraryError))
@@ -13302,6 +13830,9 @@ var starknet = (() => {
         "call_contract",
         { blockIdentifier },
         {
+          // TODO - determine best choice once both are fully supported in devnet
+          // signature: [],
+          // sender_address: contractAddress,
           contract_address: contractAddress,
           entry_point_selector: getSelectorFromName(entryPointSelector),
           calldata: CallData.compile(calldata)
@@ -13420,7 +13951,7 @@ var starknet = (() => {
           sender_address: invocation.contractAddress,
           calldata: CallData.compile(invocation.calldata ?? []),
           signature: signatureToDecimalArray(invocation.signature),
-          version: toHex((invocationDetails == null ? void 0 : invocationDetails.version) || 1),
+          version: toHex(invocationDetails?.version || 1),
           nonce: toHex(invocationDetails.nonce)
         }
       ).then(this.responseParser.parseFeeEstimateResponse);
@@ -13435,7 +13966,7 @@ var starknet = (() => {
             sender_address: senderAddress,
             contract_class: contractDefinition,
             signature: signatureToDecimalArray(signature),
-            version: toHex((details == null ? void 0 : details.version) || toBigInt(feeTransactionVersion)),
+            version: toHex(details?.version || toBigInt(feeTransactionVersion)),
             nonce: toHex(details.nonce)
           }
         ).then(this.responseParser.parseFeeEstimateResponse);
@@ -13464,7 +13995,7 @@ var starknet = (() => {
           constructor_calldata: CallData.compile(constructorCalldata || []),
           contract_address_salt: toHex(addressSalt || 0),
           signature: signatureToDecimalArray(signature),
-          version: toHex((details == null ? void 0 : details.version) || 0),
+          version: toHex(details?.version || 0),
           nonce: toHex(details.nonce)
         }
       ).then(this.responseParser.parseFeeEstimateResponse);
@@ -13495,7 +14026,7 @@ var starknet = (() => {
         return {
           ...res,
           signature: bigNumberishArrayToDecimalStringArray(formatSignature(invocation.signature)),
-          version: toHex(toBigInt((invocation == null ? void 0 : invocation.version) || 1)),
+          version: toHex(toBigInt(invocation?.version || 1)),
           nonce: toHex(toBigInt(invocation.nonce))
         };
       });
@@ -13510,8 +14041,8 @@ var starknet = (() => {
       const errorStates = ["REJECTED" /* REJECTED */, "NOT_RECEIVED" /* NOT_RECEIVED */];
       let onchain = false;
       let res;
-      const retryInterval = (options == null ? void 0 : options.retryInterval) ?? 8e3;
-      const successStates = (options == null ? void 0 : options.successStates) ?? [
+      const retryInterval = options?.retryInterval ?? 8e3;
+      const successStates = options?.successStates ?? [
         "ACCEPTED_ON_L1" /* ACCEPTED_ON_L1 */,
         "ACCEPTED_ON_L2" /* ACCEPTED_ON_L2 */,
         "PENDING" /* PENDING */
@@ -13532,13 +14063,33 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
       const txReceipt = await this.getTransactionReceipt(txHash);
       return txReceipt;
     }
+    /**
+     * Gets the status of a transaction.
+     *
+     * [Reference](https://github.com/starkware-libs/cairo-lang/blob/f464ec4797361b6be8989e36e02ec690e74ef285/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L48-L52)
+     *
+     * @param txHash
+     * @returns the transaction status object \{ block_number, tx_status: NOT_RECEIVED | RECEIVED | PENDING | REJECTED | ACCEPTED_ONCHAIN \}
+     */
     async getTransactionStatus(txHash) {
       const txHashHex = toHex(txHash);
       return this.fetchEndpoint("get_transaction_status", { transactionHash: txHashHex });
     }
+    /**
+     * Gets the smart contract address on the goerli testnet.
+     *
+     * [Reference](https://github.com/starkware-libs/cairo-lang/blob/f464ec4797361b6be8989e36e02ec690e74ef285/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L13-L15)
+     * @returns starknet smart contract addresses
+     */
     async getContractAddresses() {
       return this.fetchEndpoint("get_contract_addresses");
     }
+    /**
+     * Gets the transaction trace from a tx id.
+     *
+     * @param txHash
+     * @returns the transaction trace
+     */
     async getTransactionTrace(txHash) {
       const txHashHex = toHex(txHash);
       return this.fetchEndpoint("get_transaction_trace", { transactionHash: txHashHex });
@@ -13561,9 +14112,9 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
           sender_address: invocation.contractAddress,
           calldata: CallData.compile(invocation.calldata ?? []),
           signature: signatureToDecimalArray(invocation.signature),
-          version: toHex((invocationDetails == null ? void 0 : invocationDetails.version) || 1),
+          version: toHex(invocationDetails?.version || 1),
           nonce: toHex(invocationDetails.nonce),
-          max_fee: toHex((invocationDetails == null ? void 0 : invocationDetails.maxFee) || 0)
+          max_fee: toHex(invocationDetails?.maxFee || 0)
         }
       ).then(this.responseParser.parseFeeSimulateTransactionResponse);
     }
@@ -13573,6 +14124,7 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
         this.responseParser.parseGetStateUpdateResponse
       );
     }
+    // consider adding an optional trace retrieval parameter to the getBlock method
     async getBlockTraces(blockIdentifier = this.blockIdentifier) {
       const args = new Block(blockIdentifier).sequencerIdentifier;
       return this.fetchEndpoint("get_block_traces", { ...args });
@@ -13757,6 +14309,13 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
     return callback();
   }
   var Contract = class {
+    /**
+     * Contract class to handle contract methods
+     *
+     * @param abi - Abi of the contract object
+     * @param address (optional) - address to connect to
+     * @param providerOrAccount (optional) - Provider or Account to attach to
+     */
     constructor(abi, address, providerOrAccount = defaultProvider) {
       this.address = address && address.toLowerCase();
       this.providerOrAccount = providerOrAccount;
@@ -13919,6 +14478,13 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
       this.classHash = classHash;
       this.CallData = new CallData(abi);
     }
+    /**
+     * Deploys contract and returns new instance of the Contract
+     *
+     * @param args - Array of the constructor arguments for deployment
+     * @param options (optional) Object - parseRequest, parseResponse, addressSalt
+     * @returns deployed Contract
+     */
     async deploy(...args) {
       const { args: param, options = { parseRequest: true } } = splitArgsAndOptions(args);
       const constructorCalldata = getCalldata(param, () => {
@@ -13945,13 +14511,26 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
       contractInstance.deployTransactionHash = transaction_hash;
       return contractInstance;
     }
+    /**
+     * Attaches to new Account
+     *
+     * @param account - new Provider or Account to attach to
+     * @returns ContractFactory
+     */
     connect(account) {
       this.account = account;
       return this;
     }
+    /**
+     * Attaches current abi and account to the new address
+     *
+     * @param address - Contract address
+     * @returns Contract
+     */
     attach(address) {
       return new Contract(this.abi, address, this.account);
     }
+    // ethers.js' getDeployTransaction cant be supported as it requires the account or signer to return a signed transaction which is not possible with the current implementation
   };
 
   // src/signer/interface.ts
@@ -14530,6 +15109,14 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
         }
       );
     }
+    /**
+     * First check if contract is already declared, if not declare it
+     * If contract already declared returned transaction_hash is ''.
+     * Method will pass even if contract is already declared
+     * @param payload DeclareContractPayload
+     * @param transactionsDetail (optional) InvocationsDetails = \{\}
+     * @returns DeclareContractResponse
+     */
     async declareIfNot(payload, transactionsDetail = {}) {
       const declareContractPayload = extractContractHashes(payload);
       try {
@@ -14710,6 +15297,9 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
       }
       return feeEstimate.suggestedMaxFee;
     }
+    /**
+     * will be renamed to buildDeclareContractTransaction
+     */
     async buildDeclarePayload(payload, { nonce, chainId, version, walletAddress, maxFee }) {
       const { classHash, contract, compiledClassHash } = extractContractHashes(payload);
       const contractDefinition = parseContract(contract);
@@ -14849,7 +15439,45 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
   var number2 = num_exports;
   return __toCommonJS(src_exports);
 })();
-/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-/*! pako 2.1.0 https://github.com/nodeca/pako @license (MIT AND Zlib) */
+/*! Bundled license information:
+
+@noble/curves/esm/abstract/utils.js:
+  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+
+@noble/hashes/esm/utils.js:
+  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+
+@noble/curves/esm/abstract/utils.js:
+  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+
+@noble/curves/esm/abstract/modular.js:
+  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+
+@noble/curves/esm/abstract/poseidon.js:
+  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+
+@noble/curves/esm/abstract/curve.js:
+  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+
+@noble/curves/esm/abstract/weierstrass.js:
+  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+
+@noble/curves/esm/_shortw_utils.js:
+  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+
+@noble/curves/esm/abstract/modular.js:
+  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+
+@noble/curves/esm/abstract/curve.js:
+  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+
+@noble/curves/esm/abstract/weierstrass.js:
+  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+
+@noble/curves/esm/abstract/poseidon.js:
+  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+
+pako/dist/pako.esm.mjs:
+  (*! pako 2.1.0 https://github.com/nodeca/pako @license (MIT AND Zlib) *)
+*/
 //# sourceMappingURL=index.global.js.map