starknet 5.10.2 → 5.11.0

package/dist/index.mjs

@@ -2452,7 +2452,9 @@ var uint256 = (it) => {
   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)
   };
 };
@@ -2588,7 +2590,11 @@ function extractCairo0Tuple(type) {
 }
 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)) {
@@ -2597,6 +2603,142 @@ function extractTupleMemberTypes(type) {
   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) {
@@ -2708,8 +2850,8 @@ function parseResponseValue(responseIterator, element, structs) {
   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;
@@ -2917,6 +3059,12 @@ var CallData = class {
     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) => {
@@ -2941,14 +3089,41 @@ var CallData = class {
     }
     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 = "") => {
@@ -2983,6 +3158,12 @@ var CallData = class {
     });
     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]();
@@ -2996,13 +3177,30 @@ var CallData = class {
     }, {});
     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) => ({
@@ -3012,9 +3210,19 @@ var CallData = class {
       {}
     );
   }
+  /**
+   * 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));
@@ -3023,7 +3231,9 @@ var CallData = class {
 
 // src/utils/fetchPonyfill.ts
 import isomorphicFetch from "isomorphic-fetch";
-var fetchPonyfill_default = typeof window !== "undefined" && window.fetch || typeof global !== "undefined" && global.fetch || isomorphicFetch;
+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
+isomorphicFetch;
 
 // src/utils/hash.ts
 var hash_exports = {};
@@ -3377,6 +3587,7 @@ function parseContract(contract) {
   if (!isSierra(contract)) {
     return {
       ...parsedContract,
+      // TODO: Why do we gzip program object?
       ..."program" in parsedContract && { program: compressProgram(parsedContract.program) }
     };
   }
@@ -3629,6 +3840,7 @@ var Block = class {
       this.tag = "pending";
     }
   }
+  // TODO: fix any
   get queryIdentifier() {
     if (this.number !== null) {
       return `blockNumber=${this.number}`;
@@ -3638,6 +3850,7 @@ var Block = class {
     }
     return `blockNumber=${this.tag}`;
   }
+  // TODO: fix any
   get identifier() {
     if (this.number !== null) {
       return { block_number: this.number };
@@ -3685,17 +3898,17 @@ var RpcProvider = class {
     }
   }
   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;
@@ -3749,6 +3962,7 @@ var RpcProvider = class {
       block_id
     });
   }
+  // Methods from Interface
   async getTransaction(txHash) {
     return this.getTransactionByHash(txHash).then(this.responseParser.parseGetTransactionResponse);
   }
@@ -3790,9 +4004,9 @@ var RpcProvider = class {
         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);
@@ -3807,12 +4021,13 @@ var RpcProvider = class {
             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);
@@ -3828,9 +4043,9 @@ var RpcProvider = class {
         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);
@@ -3838,6 +4053,7 @@ var RpcProvider = class {
   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", {
@@ -3846,6 +4062,7 @@ var RpcProvider = class {
             program: contractDefinition.program,
             entry_points_by_type: contractDefinition.entry_points_by_type,
             abi: contractDefinition.abi
+            // rpc 2.0
           },
           type: RPC.TransactionType.DECLARE,
           version: "0x1",
@@ -3885,6 +4102,7 @@ var RpcProvider = class {
       }
     });
   }
+  // Methods from Interface
   async callContract(call, blockIdentifier = this.blockIdentifier) {
     const block_id = new Block(blockIdentifier).identifier;
     const result = await this.fetchEndpoint("starknet_call", {
@@ -3908,8 +4126,8 @@ var RpcProvider = class {
     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 */
@@ -3943,16 +4161,41 @@ var RpcProvider = class {
     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 });
   }
@@ -4003,6 +4246,7 @@ var SequencerAPIResponseParser = class extends ResponseParser {
       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 },
@@ -4010,6 +4254,7 @@ var SequencerAPIResponseParser = class extends ResponseParser {
       ..."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 && {
@@ -4121,6 +4366,7 @@ var SequencerAPIResponseParser = class extends ResponseParser {
       }
     };
   }
+  // TODO: Define response as new type as it diff from ContractClass
   parseSierraContractClassResponse(res) {
     return {
       ...res,
@@ -4182,9 +4428,9 @@ var SequencerProvider = class {
       );
       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) {
@@ -4250,6 +4496,7 @@ var SequencerProvider = class {
     }
     return this.headers;
   }
+  // typesafe fetch
   async fetchEndpoint(endpoint, ...[query, request]) {
     const baseUrl = this.getFetchUrl(endpoint);
     const method = this.getFetchMethod(endpoint);
@@ -4262,9 +4509,9 @@ var SequencerProvider = class {
   }
   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,
@@ -4281,7 +4528,7 @@ var SequencerProvider = class {
         }
         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))
@@ -4297,6 +4544,9 @@ var SequencerProvider = class {
       "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)
@@ -4415,7 +4665,7 @@ var SequencerProvider = class {
         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);
@@ -4430,7 +4680,7 @@ var SequencerProvider = class {
           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);
@@ -4459,7 +4709,7 @@ var SequencerProvider = class {
         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);
@@ -4490,7 +4740,7 @@ var SequencerProvider = class {
       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))
       };
     });
@@ -4505,8 +4755,8 @@ var SequencerProvider = class {
     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 */
@@ -4527,13 +4777,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 });
@@ -4556,9 +4826,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);
   }
@@ -4568,6 +4838,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 });
@@ -4752,6 +5023,13 @@ function getCalldata(args, callback) {
   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;
@@ -4914,6 +5192,13 @@ var ContractFactory = class {
     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, () => {
@@ -4940,13 +5225,26 @@ var ContractFactory = class {
     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
@@ -5525,6 +5823,14 @@ var Account = class extends Provider {
       }
     );
   }
+  /**
+   * 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 {
@@ -5705,6 +6011,9 @@ var Account = class extends Provider {
     }
     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);