starknet 5.11.1 → 5.12.0

package/dist/index.mjs

@@ -4,73 +4,28 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/types/lib/contract/index.ts
-var EntryPointType = /* @__PURE__ */ ((EntryPointType2) => {
-  EntryPointType2["EXTERNAL"] = "EXTERNAL";
-  EntryPointType2["L1_HANDLER"] = "L1_HANDLER";
-  EntryPointType2["CONSTRUCTOR"] = "CONSTRUCTOR";
-  return EntryPointType2;
-})(EntryPointType || {});
-
-// src/types/lib/index.ts
-var TransactionStatus = /* @__PURE__ */ ((TransactionStatus2) => {
-  TransactionStatus2["NOT_RECEIVED"] = "NOT_RECEIVED";
-  TransactionStatus2["RECEIVED"] = "RECEIVED";
-  TransactionStatus2["PENDING"] = "PENDING";
-  TransactionStatus2["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
-  TransactionStatus2["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
-  TransactionStatus2["REJECTED"] = "REJECTED";
-  return TransactionStatus2;
-})(TransactionStatus || {});
-var TransactionType = /* @__PURE__ */ ((TransactionType2) => {
-  TransactionType2["INVOKE"] = "INVOKE_FUNCTION";
-  TransactionType2["DECLARE"] = "DECLARE";
-  TransactionType2["DEPLOY"] = "DEPLOY";
-  TransactionType2["DEPLOY_ACCOUNT"] = "DEPLOY_ACCOUNT";
-  return TransactionType2;
-})(TransactionType || {});
-
-// src/types/api/rpc.ts
-var RPC;
-((RPC2) => {
-  let TransactionType2;
-  ((TransactionType3) => {
-    TransactionType3["DECLARE"] = "DECLARE";
-    TransactionType3["DEPLOY"] = "DEPLOY";
-    TransactionType3["DEPLOY_ACCOUNT"] = "DEPLOY_ACCOUNT";
-    TransactionType3["INVOKE"] = "INVOKE";
-    TransactionType3["L1_HANDLER"] = "L1_HANDLER";
-  })(TransactionType2 = RPC2.TransactionType || (RPC2.TransactionType = {}));
-})(RPC || (RPC = {}));
-
-// src/utils/assert.ts
-function assert(condition, message) {
-  if (!condition) {
-    throw new Error(message || "Assertion failure");
-  }
-}
-
-// src/utils/num.ts
-var num_exports = {};
-__export(num_exports, {
-  assertInRange: () => assertInRange,
-  bigNumberishArrayToDecimalStringArray: () => bigNumberishArrayToDecimalStringArray,
-  bigNumberishArrayToHexadecimalStringArray: () => bigNumberishArrayToHexadecimalStringArray,
-  cleanHex: () => cleanHex,
-  getDecimalString: () => getDecimalString,
-  getHexString: () => getHexString,
-  getHexStringArray: () => getHexStringArray,
-  hexToBytes: () => hexToBytes,
-  hexToDecimalString: () => hexToDecimalString,
-  isBigInt: () => isBigInt,
-  isHex: () => isHex,
-  isStringWholeNumber: () => isStringWholeNumber,
-  toBigInt: () => toBigInt,
-  toCairoBool: () => toCairoBool,
-  toHex: () => toHex,
-  toHexString: () => toHexString
+// src/constants.ts
+var constants_exports = {};
+__export(constants_exports, {
+  ALPHA: () => ALPHA,
+  API_VERSION: () => API_VERSION,
+  BETA: () => BETA,
+  BaseUrl: () => BaseUrl,
+  CONSTANT_POINTS: () => CONSTANT_POINTS,
+  EC_ORDER: () => EC_ORDER,
+  FIELD_GEN: () => FIELD_GEN,
+  FIELD_PRIME: () => FIELD_PRIME,
+  FIELD_SIZE: () => FIELD_SIZE,
+  IS_BROWSER: () => IS_BROWSER,
+  MASK_250: () => MASK_250,
+  MASK_251: () => MASK_251,
+  MAX_ECDSA_VAL: () => MAX_ECDSA_VAL,
+  NetworkName: () => NetworkName,
+  StarknetChainId: () => StarknetChainId,
+  TransactionHashPrefix: () => TransactionHashPrefix,
+  UDC: () => UDC,
+  ZERO: () => ZERO
 });
-import { hexToBytes as hexToBytesNoble } from "@noble/curves/abstract/utils";
 
 // src/utils/encode.ts
 var encode_exports = {};
@@ -135,98 +90,7 @@ function utf8ToArray(str) {
   return new TextEncoder().encode(str);
 }
 
-// src/utils/num.ts
-function isHex(hex) {
-  return /^0x[0-9a-f]*$/i.test(hex);
-}
-function toBigInt(value) {
-  return BigInt(value);
-}
-function isBigInt(value) {
-  return typeof value === "bigint";
-}
-function toHex(number2) {
-  return addHexPrefix(toBigInt(number2).toString(16));
-}
-function hexToDecimalString(hex) {
-  return BigInt(addHexPrefix(hex)).toString(10);
-}
-var cleanHex = (hex) => hex.toLowerCase().replace(/^(0x)0+/, "$1");
-function assertInRange(input, lowerBound, upperBound, inputName = "") {
-  const messageSuffix = inputName === "" ? "invalid length" : `invalid ${inputName} length`;
-  const inputBigInt = BigInt(input);
-  const lowerBoundBigInt = BigInt(lowerBound);
-  const upperBoundBigInt = BigInt(upperBound);
-  assert(
-    inputBigInt >= lowerBoundBigInt && inputBigInt <= upperBoundBigInt,
-    `Message not signable, ${messageSuffix}.`
-  );
-}
-function bigNumberishArrayToDecimalStringArray(rawCalldata) {
-  return rawCalldata.map((x) => toBigInt(x).toString(10));
-}
-function bigNumberishArrayToHexadecimalStringArray(rawCalldata) {
-  return rawCalldata.map((x) => toHex(x));
-}
-var isStringWholeNumber = (value) => /^\d+$/.test(value);
-var toHexString = (value) => toHex(value);
-function getDecimalString(value) {
-  if (isHex(value)) {
-    return hexToDecimalString(value);
-  }
-  if (isStringWholeNumber(value)) {
-    return value;
-  }
-  throw new Error(`${value} need to be hex-string or whole-number-string`);
-}
-function getHexString(value) {
-  if (isHex(value)) {
-    return value;
-  }
-  if (isStringWholeNumber(value)) {
-    return toHexString(value);
-  }
-  throw new Error(`${value} need to be hex-string or whole-number-string`);
-}
-function getHexStringArray(value) {
-  return value.map((el) => getHexString(el));
-}
-var toCairoBool = (value) => (+value).toString();
-function hexToBytes(value) {
-  if (!isHex(value))
-    throw new Error(`${value} need to be a hex-string`);
-  let adaptedValue = removeHexPrefix(value);
-  if (adaptedValue.length % 2 !== 0) {
-    adaptedValue = `0${adaptedValue}`;
-  }
-  return hexToBytesNoble(adaptedValue);
-}
-
-// src/utils/selector.ts
-import { keccak } from "micro-starknet";
-
 // src/constants.ts
-var constants_exports = {};
-__export(constants_exports, {
-  ALPHA: () => ALPHA,
-  API_VERSION: () => API_VERSION,
-  BETA: () => BETA,
-  BaseUrl: () => BaseUrl,
-  CONSTANT_POINTS: () => CONSTANT_POINTS,
-  EC_ORDER: () => EC_ORDER,
-  FIELD_GEN: () => FIELD_GEN,
-  FIELD_PRIME: () => FIELD_PRIME,
-  FIELD_SIZE: () => FIELD_SIZE,
-  IS_BROWSER: () => IS_BROWSER,
-  MASK_250: () => MASK_250,
-  MASK_251: () => MASK_251,
-  MAX_ECDSA_VAL: () => MAX_ECDSA_VAL,
-  NetworkName: () => NetworkName,
-  StarknetChainId: () => StarknetChainId,
-  TransactionHashPrefix: () => TransactionHashPrefix,
-  UDC: () => UDC,
-  ZERO: () => ZERO
-});
 var ZERO = 0n;
 var MASK_250 = 2n ** 250n - 1n;
 var MASK_251 = 2n ** 251n;
@@ -2295,42 +2159,185 @@ var CONSTANT_POINTS = [
   ]
 ];
 
-// src/utils/selector.ts
-function keccakBn(value) {
-  const hexWithoutPrefix = removeHexPrefix(toHex(BigInt(value)));
-  const evenHex = hexWithoutPrefix.length % 2 === 0 ? hexWithoutPrefix : `0${hexWithoutPrefix}`;
-  return addHexPrefix(keccak(hexToBytes(addHexPrefix(evenHex))).toString(16));
-}
-function keccakHex(value) {
-  return addHexPrefix(keccak(utf8ToArray(value)).toString(16));
-}
-function starknetKeccak(value) {
-  const hash = BigInt(keccakHex(value));
-  return hash & MASK_250;
-}
-function getSelectorFromName(funcName) {
-  return toHex(starknetKeccak(funcName));
-}
-function getSelector(value) {
-  if (isHex(value)) {
-    return value;
-  }
-  if (isStringWholeNumber(value)) {
-    return toHexString(value);
+// src/types/index.ts
+var types_exports = {};
+__export(types_exports, {
+  EntryPointType: () => EntryPointType,
+  RPC: () => RPC,
+  TransactionStatus: () => TransactionStatus,
+  TransactionType: () => TransactionType
+});
+
+// src/types/lib/contract/index.ts
+var EntryPointType = /* @__PURE__ */ ((EntryPointType2) => {
+  EntryPointType2["EXTERNAL"] = "EXTERNAL";
+  EntryPointType2["L1_HANDLER"] = "L1_HANDLER";
+  EntryPointType2["CONSTRUCTOR"] = "CONSTRUCTOR";
+  return EntryPointType2;
+})(EntryPointType || {});
+
+// src/types/lib/index.ts
+var TransactionStatus = /* @__PURE__ */ ((TransactionStatus2) => {
+  TransactionStatus2["NOT_RECEIVED"] = "NOT_RECEIVED";
+  TransactionStatus2["RECEIVED"] = "RECEIVED";
+  TransactionStatus2["PENDING"] = "PENDING";
+  TransactionStatus2["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
+  TransactionStatus2["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
+  TransactionStatus2["REJECTED"] = "REJECTED";
+  return TransactionStatus2;
+})(TransactionStatus || {});
+var TransactionType = /* @__PURE__ */ ((TransactionType2) => {
+  TransactionType2["INVOKE"] = "INVOKE_FUNCTION";
+  TransactionType2["DECLARE"] = "DECLARE";
+  TransactionType2["DEPLOY"] = "DEPLOY";
+  TransactionType2["DEPLOY_ACCOUNT"] = "DEPLOY_ACCOUNT";
+  return TransactionType2;
+})(TransactionType || {});
+
+// src/types/api/rpc.ts
+var RPC;
+((RPC2) => {
+  let TransactionType2;
+  ((TransactionType3) => {
+    TransactionType3["DECLARE"] = "DECLARE";
+    TransactionType3["DEPLOY"] = "DEPLOY";
+    TransactionType3["DEPLOY_ACCOUNT"] = "DEPLOY_ACCOUNT";
+    TransactionType3["INVOKE"] = "INVOKE";
+    TransactionType3["L1_HANDLER"] = "L1_HANDLER";
+  })(TransactionType2 = RPC2.TransactionType || (RPC2.TransactionType = {}));
+})(RPC || (RPC = {}));
+
+// src/utils/assert.ts
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message || "Assertion failure");
   }
-  return getSelectorFromName(value);
 }
 
-// src/utils/shortString.ts
-var shortString_exports = {};
-__export(shortString_exports, {
-  decodeShortString: () => decodeShortString,
-  encodeShortString: () => encodeShortString,
-  isASCII: () => isASCII,
-  isDecimalString: () => isDecimalString,
-  isLongText: () => isLongText,
-  isShortString: () => isShortString,
-  isShortText: () => isShortText,
+// src/utils/num.ts
+var num_exports = {};
+__export(num_exports, {
+  assertInRange: () => assertInRange,
+  bigNumberishArrayToDecimalStringArray: () => bigNumberishArrayToDecimalStringArray,
+  bigNumberishArrayToHexadecimalStringArray: () => bigNumberishArrayToHexadecimalStringArray,
+  cleanHex: () => cleanHex,
+  getDecimalString: () => getDecimalString,
+  getHexString: () => getHexString,
+  getHexStringArray: () => getHexStringArray,
+  hexToBytes: () => hexToBytes,
+  hexToDecimalString: () => hexToDecimalString,
+  isBigInt: () => isBigInt,
+  isHex: () => isHex,
+  isStringWholeNumber: () => isStringWholeNumber,
+  toBigInt: () => toBigInt,
+  toCairoBool: () => toCairoBool,
+  toHex: () => toHex,
+  toHexString: () => toHexString
+});
+import { hexToBytes as hexToBytesNoble } from "@noble/curves/abstract/utils";
+function isHex(hex) {
+  return /^0x[0-9a-f]*$/i.test(hex);
+}
+function toBigInt(value) {
+  return BigInt(value);
+}
+function isBigInt(value) {
+  return typeof value === "bigint";
+}
+function toHex(number2) {
+  return addHexPrefix(toBigInt(number2).toString(16));
+}
+function hexToDecimalString(hex) {
+  return BigInt(addHexPrefix(hex)).toString(10);
+}
+var cleanHex = (hex) => hex.toLowerCase().replace(/^(0x)0+/, "$1");
+function assertInRange(input, lowerBound, upperBound, inputName = "") {
+  const messageSuffix = inputName === "" ? "invalid length" : `invalid ${inputName} length`;
+  const inputBigInt = BigInt(input);
+  const lowerBoundBigInt = BigInt(lowerBound);
+  const upperBoundBigInt = BigInt(upperBound);
+  assert(
+    inputBigInt >= lowerBoundBigInt && inputBigInt <= upperBoundBigInt,
+    `Message not signable, ${messageSuffix}.`
+  );
+}
+function bigNumberishArrayToDecimalStringArray(rawCalldata) {
+  return rawCalldata.map((x) => toBigInt(x).toString(10));
+}
+function bigNumberishArrayToHexadecimalStringArray(rawCalldata) {
+  return rawCalldata.map((x) => toHex(x));
+}
+var isStringWholeNumber = (value) => /^\d+$/.test(value);
+var toHexString = (value) => toHex(value);
+function getDecimalString(value) {
+  if (isHex(value)) {
+    return hexToDecimalString(value);
+  }
+  if (isStringWholeNumber(value)) {
+    return value;
+  }
+  throw new Error(`${value} need to be hex-string or whole-number-string`);
+}
+function getHexString(value) {
+  if (isHex(value)) {
+    return value;
+  }
+  if (isStringWholeNumber(value)) {
+    return toHexString(value);
+  }
+  throw new Error(`${value} need to be hex-string or whole-number-string`);
+}
+function getHexStringArray(value) {
+  return value.map((el) => getHexString(el));
+}
+var toCairoBool = (value) => (+value).toString();
+function hexToBytes(value) {
+  if (!isHex(value))
+    throw new Error(`${value} need to be a hex-string`);
+  let adaptedValue = removeHexPrefix(value);
+  if (adaptedValue.length % 2 !== 0) {
+    adaptedValue = `0${adaptedValue}`;
+  }
+  return hexToBytesNoble(adaptedValue);
+}
+
+// src/utils/selector.ts
+import { keccak } from "micro-starknet";
+function keccakBn(value) {
+  const hexWithoutPrefix = removeHexPrefix(toHex(BigInt(value)));
+  const evenHex = hexWithoutPrefix.length % 2 === 0 ? hexWithoutPrefix : `0${hexWithoutPrefix}`;
+  return addHexPrefix(keccak(hexToBytes(addHexPrefix(evenHex))).toString(16));
+}
+function keccakHex(value) {
+  return addHexPrefix(keccak(utf8ToArray(value)).toString(16));
+}
+function starknetKeccak(value) {
+  const hash = BigInt(keccakHex(value));
+  return hash & MASK_250;
+}
+function getSelectorFromName(funcName) {
+  return toHex(starknetKeccak(funcName));
+}
+function getSelector(value) {
+  if (isHex(value)) {
+    return value;
+  }
+  if (isStringWholeNumber(value)) {
+    return toHexString(value);
+  }
+  return getSelectorFromName(value);
+}
+
+// src/utils/shortString.ts
+var shortString_exports = {};
+__export(shortString_exports, {
+  decodeShortString: () => decodeShortString,
+  encodeShortString: () => encodeShortString,
+  isASCII: () => isASCII,
+  isDecimalString: () => isDecimalString,
+  isLongText: () => isLongText,
+  isShortString: () => isShortString,
+  isShortText: () => isShortText,
   isText: () => isText,
   splitLongString: () => splitLongString
 });
@@ -4956,463 +4963,169 @@ var Provider = class {
   }
 };
 
-// src/provider/interface.ts
-var ProviderInterface = class {
+// src/signer/interface.ts
+var SignerInterface = class {
 };
 
-// src/provider/index.ts
-var defaultProvider = new Provider();
-
-// src/contract/default.ts
-var splitArgsAndOptions = (args) => {
-  const options = [
-    "blockIdentifier",
-    "parseRequest",
-    "parseResponse",
-    "formatResponse",
-    "maxFee",
-    "nonce",
-    "signature",
-    "addressSalt"
-  ];
-  const lastArg = args[args.length - 1];
-  if (typeof lastArg === "object" && options.some((x) => x in lastArg)) {
-    return { args, options: args.pop() };
-  }
-  return { args };
-};
-function buildCall(contract, functionAbi) {
-  return async function(...args) {
-    const params = splitArgsAndOptions(args);
-    return contract.call(functionAbi.name, params.args, {
-      parseRequest: true,
-      parseResponse: true,
-      ...params.options
-    });
-  };
-}
-function buildInvoke(contract, functionAbi) {
-  return async function(...args) {
-    const params = splitArgsAndOptions(args);
-    return contract.invoke(functionAbi.name, params.args, {
-      parseRequest: true,
-      ...params.options
+// src/utils/transaction.ts
+var transaction_exports = {};
+__export(transaction_exports, {
+  fromCallsToExecuteCalldata: () => fromCallsToExecuteCalldata,
+  fromCallsToExecuteCalldataWithNonce: () => fromCallsToExecuteCalldataWithNonce,
+  fromCallsToExecuteCalldata_cairo1: () => fromCallsToExecuteCalldata_cairo1,
+  getExecuteCalldata: () => getExecuteCalldata,
+  transformCallsToMulticallArrays: () => transformCallsToMulticallArrays,
+  transformCallsToMulticallArrays_cairo1: () => transformCallsToMulticallArrays_cairo1
+});
+var transformCallsToMulticallArrays = (calls) => {
+  const callArray = [];
+  const calldata = [];
+  calls.forEach((call) => {
+    const data = CallData.compile(call.calldata || []);
+    callArray.push({
+      to: toBigInt(call.contractAddress).toString(10),
+      selector: toBigInt(getSelectorFromName(call.entrypoint)).toString(10),
+      data_offset: calldata.length.toString(),
+      data_len: data.length.toString()
     });
+    calldata.push(...data);
+  });
+  return {
+    callArray,
+    calldata: CallData.compile({ calldata })
   };
-}
-function buildDefault(contract, functionAbi) {
-  if (functionAbi.stateMutability === "view" || functionAbi.state_mutability === "view") {
-    return buildCall(contract, functionAbi);
+};
+var fromCallsToExecuteCalldata = (calls) => {
+  const { callArray, calldata } = transformCallsToMulticallArrays(calls);
+  const compiledCalls = CallData.compile({ callArray });
+  return [...compiledCalls, ...calldata];
+};
+var fromCallsToExecuteCalldataWithNonce = (calls, nonce) => {
+  return [...fromCallsToExecuteCalldata(calls), toBigInt(nonce).toString()];
+};
+var transformCallsToMulticallArrays_cairo1 = (calls) => {
+  const callArray = calls.map((call) => ({
+    to: toBigInt(call.contractAddress).toString(10),
+    selector: toBigInt(getSelectorFromName(call.entrypoint)).toString(10),
+    calldata: CallData.compile(call.calldata || [])
+  }));
+  return callArray;
+};
+var fromCallsToExecuteCalldata_cairo1 = (calls) => {
+  const orderCalls = calls.map((call) => ({
+    contractAddress: call.contractAddress,
+    entrypoint: call.entrypoint,
+    calldata: call.calldata
+  }));
+  return CallData.compile({ orderCalls });
+};
+var getExecuteCalldata = (calls, cairoVersion = "0") => {
+  if (cairoVersion === "1") {
+    return fromCallsToExecuteCalldata_cairo1(calls);
   }
-  return buildInvoke(contract, functionAbi);
-}
-function buildPopulate(contract, functionAbi) {
-  return function(...args) {
-    return contract.populate(functionAbi.name, args);
-  };
-}
-function buildEstimate(contract, functionAbi) {
-  return function(...args) {
-    return contract.estimate(functionAbi.name, args);
-  };
-}
-function getCalldata(args, callback) {
-  if ("__compiled__" in args)
-    return args;
-  if (Array.isArray(args[0]) && "__compiled__" in args[0])
-    return args[0];
-  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;
-    this.callData = new CallData(abi);
-    this.structs = CallData.getAbiStruct(abi);
-    this.abi = abi;
-    const options = { enumerable: true, value: {}, writable: false };
-    Object.defineProperties(this, {
-      functions: { enumerable: true, value: {}, writable: false },
-      callStatic: { enumerable: true, value: {}, writable: false },
-      populateTransaction: { enumerable: true, value: {}, writable: false },
-      estimateFee: { enumerable: true, value: {}, writable: false }
-    });
-    this.abi.forEach((abiElement) => {
-      if (abiElement.type !== "function")
-        return;
-      const signature = abiElement.name;
-      if (!this[signature]) {
-        Object.defineProperty(this, signature, {
-          ...options,
-          value: buildDefault(this, abiElement)
-        });
-      }
-      if (!this.functions[signature]) {
-        Object.defineProperty(this.functions, signature, {
-          ...options,
-          value: buildDefault(this, abiElement)
-        });
-      }
-      if (!this.callStatic[signature]) {
-        Object.defineProperty(this.callStatic, signature, {
-          ...options,
-          value: buildCall(this, abiElement)
-        });
-      }
-      if (!this.populateTransaction[signature]) {
-        Object.defineProperty(this.populateTransaction, signature, {
-          ...options,
-          value: buildPopulate(this, abiElement)
-        });
-      }
-      if (!this.estimateFee[signature]) {
-        Object.defineProperty(this.estimateFee, signature, {
-          ...options,
-          value: buildEstimate(this, abiElement)
-        });
-      }
-    });
-  }
-  attach(address) {
-    this.address = address;
-  }
-  connect(providerOrAccount) {
-    this.providerOrAccount = providerOrAccount;
+  return fromCallsToExecuteCalldata(calls);
+};
+
+// src/utils/typedData.ts
+var typedData_exports = {};
+__export(typedData_exports, {
+  encodeData: () => encodeData,
+  encodeType: () => encodeType,
+  encodeValue: () => encodeValue,
+  getDependencies: () => getDependencies,
+  getMessageHash: () => getMessageHash,
+  getStructHash: () => getStructHash,
+  getTypeHash: () => getTypeHash,
+  isMerkleTreeType: () => isMerkleTreeType,
+  prepareSelector: () => prepareSelector
+});
+
+// src/utils/merkle.ts
+var merkle_exports = {};
+__export(merkle_exports, {
+  MerkleTree: () => MerkleTree,
+  proofMerklePath: () => proofMerklePath
+});
+var MerkleTree = class {
+  constructor(leafHashes) {
+    this.branches = [];
+    this.leaves = leafHashes;
+    this.root = this.build(leafHashes);
   }
-  async deployed() {
-    if (this.deployTransactionHash) {
-      await this.providerOrAccount.waitForTransaction(this.deployTransactionHash);
-      this.deployTransactionHash = void 0;
+  build(leaves) {
+    if (leaves.length === 1) {
+      return leaves[0];
     }
-    return this;
-  }
-  async call(method, args = [], {
-    parseRequest = true,
-    parseResponse = true,
-    formatResponse = void 0,
-    blockIdentifier = void 0
-  } = {}) {
-    assert(this.address !== null, "contract is not connected to an address");
-    const calldata = getCalldata(args, () => {
-      if (parseRequest) {
-        this.callData.validate("CALL", method, args);
-        return this.callData.compile(method, args);
-      }
-      console.warn("Call skipped parsing but provided rawArgs, possible malfunction request");
-      return args;
-    });
-    return this.providerOrAccount.callContract(
-      {
-        contractAddress: this.address,
-        calldata,
-        entrypoint: method
-      },
-      blockIdentifier
-    ).then((x) => {
-      if (!parseResponse) {
-        return x.result;
-      }
-      if (formatResponse) {
-        return this.callData.format(method, x.result, formatResponse);
-      }
-      return this.callData.parse(method, x.result);
-    });
-  }
-  invoke(method, args = [], { parseRequest = true, maxFee, nonce, signature } = {}) {
-    assert(this.address !== null, "contract is not connected to an address");
-    const calldata = getCalldata(args, () => {
-      if (parseRequest) {
-        this.callData.validate("INVOKE", method, args);
-        return this.callData.compile(method, args);
-      }
-      console.warn("Invoke skipped parsing but provided rawArgs, possible malfunction request");
-      return args;
-    });
-    const invocation = {
-      contractAddress: this.address,
-      calldata,
-      entrypoint: method
-    };
-    if ("execute" in this.providerOrAccount) {
-      return this.providerOrAccount.execute(invocation, void 0, {
-        maxFee,
-        nonce
-      });
+    if (leaves.length !== this.leaves.length) {
+      this.branches.push(leaves);
     }
-    if (!nonce)
-      throw new Error(`Nonce is required when invoking a function without an account`);
-    console.warn(`Invoking ${method} without an account. This will not work on a public node.`);
-    return this.providerOrAccount.invokeFunction(
-      {
-        ...invocation,
-        signature
-      },
-      {
-        nonce
+    const newLeaves = [];
+    for (let i = 0; i < leaves.length; i += 2) {
+      if (i + 1 === leaves.length) {
+        newLeaves.push(MerkleTree.hash(leaves[i], "0x0"));
+      } else {
+        newLeaves.push(MerkleTree.hash(leaves[i], leaves[i + 1]));
       }
-    );
+    }
+    return this.build(newLeaves);
   }
-  async estimate(method, args = []) {
-    assert(this.address !== null, "contract is not connected to an address");
-    if (!getCalldata(args, () => false)) {
-      this.callData.validate("INVOKE", method, args);
+  static hash(a, b) {
+    const [aSorted, bSorted] = [toBigInt(a), toBigInt(b)].sort((x, y) => x >= y ? 1 : -1);
+    return starkCurve.pedersen(aSorted, bSorted);
+  }
+  getProof(leaf, branch = this.leaves, hashPath = []) {
+    const index = branch.indexOf(leaf);
+    if (index === -1) {
+      throw new Error("leaf not found");
     }
-    const invocation = this.populate(method, args);
-    if ("estimateInvokeFee" in this.providerOrAccount) {
-      return this.providerOrAccount.estimateInvokeFee(invocation);
+    if (branch.length === 1) {
+      return hashPath;
     }
-    throw Error("Contract must be connected to the account contract to estimate");
-  }
-  populate(method, args = []) {
-    const calldata = getCalldata(args, () => this.callData.compile(method, args));
-    return {
-      contractAddress: this.address,
-      entrypoint: method,
-      calldata
-    };
+    const isLeft = index % 2 === 0;
+    const neededBranch = (isLeft ? branch[index + 1] : branch[index - 1]) ?? "0x0";
+    const newHashPath = [...hashPath, neededBranch];
+    const currentBranchLevelIndex = this.leaves.length === branch.length ? -1 : this.branches.findIndex((b) => b.length === branch.length);
+    const nextBranch = this.branches[currentBranchLevelIndex + 1] ?? [this.root];
+    return this.getProof(
+      MerkleTree.hash(isLeft ? leaf : neededBranch, isLeft ? neededBranch : leaf),
+      nextBranch,
+      newHashPath
+    );
   }
 };
+function proofMerklePath(root, leaf, path) {
+  if (path.length === 0) {
+    return root === leaf;
+  }
+  const [next, ...rest] = path;
+  return proofMerklePath(root, MerkleTree.hash(leaf, next), rest);
+}
 
-// src/contract/interface.ts
-var ContractInterface = class {
+// src/utils/typedData.ts
+function getHex(value) {
+  try {
+    return toHex(value);
+  } catch (e) {
+    if (typeof value === "string") {
+      return toHex(encodeShortString(value));
+    }
+    throw new Error(`Invalid BigNumberish: ${value}`);
+  }
+}
+var validateTypedData = (data) => {
+  const typedData = data;
+  const valid = Boolean(typedData.types && typedData.primaryType && typedData.message);
+  return valid;
 };
-
-// src/contract/contractFactory.ts
-var ContractFactory = class {
-  constructor(compiledContract, classHash, account, abi = compiledContract.abi) {
-    this.abi = abi;
-    this.compiledContract = compiledContract;
-    this.account = account;
-    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, () => {
-      if (options.parseRequest) {
-        this.CallData.validate("DEPLOY", "constructor", param);
-        return this.CallData.compile("constructor", param);
-      }
-      console.warn("Call skipped parsing but provided rawArgs, possible malfunction request");
-      return param;
-    });
-    const {
-      deploy: { contract_address, transaction_hash }
-    } = await this.account.declareAndDeploy({
-      contract: this.compiledContract,
-      constructorCalldata,
-      salt: options.addressSalt
-    });
-    assert(Boolean(contract_address), "Deployment of the contract failed");
-    const contractInstance = new Contract(
-      this.compiledContract.abi,
-      contract_address,
-      this.account
-    );
-    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
-var SignerInterface = class {
-};
-
-// src/utils/transaction.ts
-var transaction_exports = {};
-__export(transaction_exports, {
-  fromCallsToExecuteCalldata: () => fromCallsToExecuteCalldata,
-  fromCallsToExecuteCalldataWithNonce: () => fromCallsToExecuteCalldataWithNonce,
-  fromCallsToExecuteCalldata_cairo1: () => fromCallsToExecuteCalldata_cairo1,
-  getExecuteCalldata: () => getExecuteCalldata,
-  transformCallsToMulticallArrays: () => transformCallsToMulticallArrays,
-  transformCallsToMulticallArrays_cairo1: () => transformCallsToMulticallArrays_cairo1
-});
-var transformCallsToMulticallArrays = (calls) => {
-  const callArray = [];
-  const calldata = [];
-  calls.forEach((call) => {
-    const data = CallData.compile(call.calldata || []);
-    callArray.push({
-      to: toBigInt(call.contractAddress).toString(10),
-      selector: toBigInt(getSelectorFromName(call.entrypoint)).toString(10),
-      data_offset: calldata.length.toString(),
-      data_len: data.length.toString()
-    });
-    calldata.push(...data);
-  });
-  return {
-    callArray,
-    calldata: CallData.compile({ calldata })
-  };
-};
-var fromCallsToExecuteCalldata = (calls) => {
-  const { callArray, calldata } = transformCallsToMulticallArrays(calls);
-  const compiledCalls = CallData.compile({ callArray });
-  return [...compiledCalls, ...calldata];
-};
-var fromCallsToExecuteCalldataWithNonce = (calls, nonce) => {
-  return [...fromCallsToExecuteCalldata(calls), toBigInt(nonce).toString()];
-};
-var transformCallsToMulticallArrays_cairo1 = (calls) => {
-  const callArray = calls.map((call) => ({
-    to: toBigInt(call.contractAddress).toString(10),
-    selector: toBigInt(getSelectorFromName(call.entrypoint)).toString(10),
-    calldata: CallData.compile(call.calldata || [])
-  }));
-  return callArray;
-};
-var fromCallsToExecuteCalldata_cairo1 = (calls) => {
-  const orderCalls = calls.map((call) => ({
-    contractAddress: call.contractAddress,
-    entrypoint: call.entrypoint,
-    calldata: call.calldata
-  }));
-  return CallData.compile({ orderCalls });
-};
-var getExecuteCalldata = (calls, cairoVersion = "0") => {
-  if (cairoVersion === "1") {
-    return fromCallsToExecuteCalldata_cairo1(calls);
-  }
-  return fromCallsToExecuteCalldata(calls);
-};
-
-// src/utils/typedData/index.ts
-var typedData_exports = {};
-__export(typedData_exports, {
-  encodeData: () => encodeData,
-  encodeType: () => encodeType,
-  encodeValue: () => encodeValue,
-  getDependencies: () => getDependencies,
-  getMessageHash: () => getMessageHash,
-  getStructHash: () => getStructHash,
-  getTypeHash: () => getTypeHash,
-  isMerkleTreeType: () => isMerkleTreeType,
-  prepareSelector: () => prepareSelector
-});
-
-// src/utils/merkle.ts
-var merkle_exports = {};
-__export(merkle_exports, {
-  MerkleTree: () => MerkleTree,
-  proofMerklePath: () => proofMerklePath
-});
-var MerkleTree = class {
-  constructor(leafHashes) {
-    this.branches = [];
-    this.leaves = leafHashes;
-    this.root = this.build(leafHashes);
-  }
-  build(leaves) {
-    if (leaves.length === 1) {
-      return leaves[0];
-    }
-    if (leaves.length !== this.leaves.length) {
-      this.branches.push(leaves);
-    }
-    const newLeaves = [];
-    for (let i = 0; i < leaves.length; i += 2) {
-      if (i + 1 === leaves.length) {
-        newLeaves.push(MerkleTree.hash(leaves[i], "0x0"));
-      } else {
-        newLeaves.push(MerkleTree.hash(leaves[i], leaves[i + 1]));
-      }
-    }
-    return this.build(newLeaves);
-  }
-  static hash(a, b) {
-    const [aSorted, bSorted] = [toBigInt(a), toBigInt(b)].sort((x, y) => x >= y ? 1 : -1);
-    return starkCurve.pedersen(aSorted, bSorted);
-  }
-  getProof(leaf, branch = this.leaves, hashPath = []) {
-    const index = branch.indexOf(leaf);
-    if (index === -1) {
-      throw new Error("leaf not found");
-    }
-    if (branch.length === 1) {
-      return hashPath;
-    }
-    const isLeft = index % 2 === 0;
-    const neededBranch = (isLeft ? branch[index + 1] : branch[index - 1]) ?? "0x0";
-    const newHashPath = [...hashPath, neededBranch];
-    const currentBranchLevelIndex = this.leaves.length === branch.length ? -1 : this.branches.findIndex((b) => b.length === branch.length);
-    const nextBranch = this.branches[currentBranchLevelIndex + 1] ?? [this.root];
-    return this.getProof(
-      MerkleTree.hash(isLeft ? leaf : neededBranch, isLeft ? neededBranch : leaf),
-      nextBranch,
-      newHashPath
-    );
-  }
-};
-function proofMerklePath(root, leaf, path) {
-  if (path.length === 0) {
-    return root === leaf;
-  }
-  const [next, ...rest] = path;
-  return proofMerklePath(root, MerkleTree.hash(leaf, next), rest);
-}
-
-// src/utils/typedData/utils.ts
-var validateTypedData = (data) => {
-  const typedData = data;
-  const valid = Boolean(typedData.types && typedData.primaryType && typedData.message);
-  return valid;
-};
-
-// src/utils/typedData/index.ts
-function getHex(value) {
-  try {
-    return toHex(value);
-  } catch (e) {
-    if (typeof value === "string") {
-      return toHex(encodeShortString(value));
-    }
-    throw new Error(`Invalid BigNumberish: ${value}`);
-  }
-}
-function prepareSelector(selector) {
-  return isHex(selector) ? selector : getSelectorFromName(selector);
-}
-function isMerkleTreeType(type) {
-  return type.type === "merkletree";
-}
-var getDependencies = (types, type, dependencies = []) => {
-  if (type[type.length - 1] === "*") {
-    type = type.slice(0, -1);
+function prepareSelector(selector) {
+  return isHex(selector) ? selector : getSelectorFromName(selector);
+}
+function isMerkleTreeType(type) {
+  return type.type === "merkletree";
+}
+var getDependencies = (types, type, dependencies = []) => {
+  if (type[type.length - 1] === "*") {
+    type = type.slice(0, -1);
   }
   if (dependencies.includes(type)) {
     return dependencies;
@@ -5937,187 +5650,479 @@ var Account = class extends Provider {
     const contractAddress = providedContractAddress ?? calculateContractAddressFromHash(addressSalt, classHash, compiledCalldata, 0);
     const maxFee = transactionsDetail.maxFee ?? await this.getSuggestedMaxFee(
       {
-        type: "DEPLOY_ACCOUNT" /* DEPLOY_ACCOUNT */,
-        payload: {
-          classHash,
-          constructorCalldata: compiledCalldata,
-          addressSalt,
-          contractAddress
-        }
+        type: "DEPLOY_ACCOUNT" /* DEPLOY_ACCOUNT */,
+        payload: {
+          classHash,
+          constructorCalldata: compiledCalldata,
+          addressSalt,
+          contractAddress
+        }
+      },
+      transactionsDetail
+    );
+    const signature = await this.signer.signDeployAccountTransaction({
+      classHash,
+      constructorCalldata: compiledCalldata,
+      contractAddress,
+      addressSalt,
+      chainId,
+      maxFee,
+      version,
+      nonce
+    });
+    return this.deployAccountContract(
+      { classHash, addressSalt, constructorCalldata, signature },
+      {
+        nonce,
+        maxFee,
+        version
+      }
+    );
+  }
+  async signMessage(typedData) {
+    return this.signer.signMessage(typedData, this.address);
+  }
+  async hashMessage(typedData) {
+    return getMessageHash(typedData, this.address);
+  }
+  async verifyMessageHash(hash, signature) {
+    try {
+      await this.callContract({
+        contractAddress: this.address,
+        entrypoint: "isValidSignature",
+        calldata: CallData.compile({
+          hash: toBigInt(hash).toString(),
+          signature: formatSignature(signature)
+        })
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async verifyMessage(typedData, signature) {
+    const hash = await this.hashMessage(typedData);
+    return this.verifyMessageHash(hash, signature);
+  }
+  async getSuggestedMaxFee({ type, payload }, details) {
+    let feeEstimate;
+    switch (type) {
+      case "INVOKE_FUNCTION" /* INVOKE */:
+        feeEstimate = await this.estimateInvokeFee(payload, details);
+        break;
+      case "DECLARE" /* DECLARE */:
+        feeEstimate = await this.estimateDeclareFee(payload, details);
+        break;
+      case "DEPLOY_ACCOUNT" /* DEPLOY_ACCOUNT */:
+        feeEstimate = await this.estimateAccountDeployFee(payload, details);
+        break;
+      case "DEPLOY" /* DEPLOY */:
+        feeEstimate = await this.estimateDeployFee(payload, details);
+        break;
+      default:
+        feeEstimate = { suggestedMaxFee: ZERO, overall_fee: ZERO };
+        break;
+    }
+    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);
+    const signature = await this.signer.signDeclareTransaction({
+      classHash,
+      compiledClassHash,
+      senderAddress: walletAddress,
+      chainId,
+      maxFee,
+      version,
+      nonce
+    });
+    return {
+      senderAddress: walletAddress,
+      signature,
+      contractDefinition,
+      compiledClassHash
+    };
+  }
+  async buildAccountDeployPayload({
+    classHash,
+    addressSalt = 0,
+    constructorCalldata = [],
+    contractAddress: providedContractAddress
+  }, { nonce, chainId, version, maxFee }) {
+    const compiledCalldata = CallData.compile(constructorCalldata);
+    const contractAddress = providedContractAddress ?? calculateContractAddressFromHash(addressSalt, classHash, compiledCalldata, 0);
+    const signature = await this.signer.signDeployAccountTransaction({
+      classHash,
+      contractAddress,
+      chainId,
+      maxFee,
+      version,
+      nonce,
+      addressSalt,
+      constructorCalldata: compiledCalldata
+    });
+    return {
+      classHash,
+      addressSalt,
+      constructorCalldata: compiledCalldata,
+      signature
+    };
+  }
+  buildUDCContractPayload(payload) {
+    const calls = [].concat(payload).map((it) => {
+      const {
+        classHash,
+        salt = "0",
+        unique = true,
+        constructorCalldata = []
+      } = it;
+      const compiledConstructorCallData = CallData.compile(constructorCalldata);
+      return {
+        contractAddress: UDC.ADDRESS,
+        entrypoint: UDC.ENTRYPOINT,
+        calldata: [
+          classHash,
+          salt,
+          toCairoBool(unique),
+          compiledConstructorCallData.length,
+          ...compiledConstructorCallData
+        ]
+      };
+    });
+    return calls;
+  }
+  async simulateTransaction(calls, { nonce: providedNonce, blockIdentifier, skipValidate } = {}) {
+    const transactions = Array.isArray(calls) ? calls : [calls];
+    const nonce = toBigInt(providedNonce ?? await this.getNonce());
+    const version = toBigInt(feeTransactionVersion);
+    const chainId = await this.getChainId();
+    const signerDetails = {
+      walletAddress: this.address,
+      nonce,
+      maxFee: ZERO,
+      version,
+      chainId,
+      cairoVersion: this.cairoVersion
+    };
+    const invocation = await this.buildInvocation(transactions, signerDetails);
+    const response = await super.getSimulateTransaction(
+      invocation,
+      { version, nonce },
+      blockIdentifier,
+      skipValidate
+    );
+    const suggestedMaxFee = estimatedFeeToMaxFee(response.fee_estimation.overall_fee);
+    return {
+      ...response,
+      fee_estimation: {
+        ...response.fee_estimation,
+        suggestedMaxFee
+      }
+    };
+  }
+  async getStarkName(address = this.address, StarknetIdContract2) {
+    return super.getStarkName(address, StarknetIdContract2);
+  }
+};
+
+// src/provider/interface.ts
+var ProviderInterface = class {
+};
+
+// src/provider/index.ts
+var defaultProvider = new Provider();
+
+// src/account/interface.ts
+var AccountInterface = class extends ProviderInterface {
+};
+
+// src/contract/default.ts
+var splitArgsAndOptions = (args) => {
+  const options = [
+    "blockIdentifier",
+    "parseRequest",
+    "parseResponse",
+    "formatResponse",
+    "maxFee",
+    "nonce",
+    "signature",
+    "addressSalt"
+  ];
+  const lastArg = args[args.length - 1];
+  if (typeof lastArg === "object" && options.some((x) => x in lastArg)) {
+    return { args, options: args.pop() };
+  }
+  return { args };
+};
+function buildCall(contract, functionAbi) {
+  return async function(...args) {
+    const params = splitArgsAndOptions(args);
+    return contract.call(functionAbi.name, params.args, {
+      parseRequest: true,
+      parseResponse: true,
+      ...params.options
+    });
+  };
+}
+function buildInvoke(contract, functionAbi) {
+  return async function(...args) {
+    const params = splitArgsAndOptions(args);
+    return contract.invoke(functionAbi.name, params.args, {
+      parseRequest: true,
+      ...params.options
+    });
+  };
+}
+function buildDefault(contract, functionAbi) {
+  if (functionAbi.stateMutability === "view" || functionAbi.state_mutability === "view") {
+    return buildCall(contract, functionAbi);
+  }
+  return buildInvoke(contract, functionAbi);
+}
+function buildPopulate(contract, functionAbi) {
+  return function(...args) {
+    return contract.populate(functionAbi.name, args);
+  };
+}
+function buildEstimate(contract, functionAbi) {
+  return function(...args) {
+    return contract.estimate(functionAbi.name, args);
+  };
+}
+function getCalldata(args, callback) {
+  if (Array.isArray(args) && "__compiled__" in args)
+    return args;
+  if (Array.isArray(args) && Array.isArray(args[0]) && "__compiled__" in args[0])
+    return args[0];
+  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;
+    this.callData = new CallData(abi);
+    this.structs = CallData.getAbiStruct(abi);
+    this.abi = abi;
+    const options = { enumerable: true, value: {}, writable: false };
+    Object.defineProperties(this, {
+      functions: { enumerable: true, value: {}, writable: false },
+      callStatic: { enumerable: true, value: {}, writable: false },
+      populateTransaction: { enumerable: true, value: {}, writable: false },
+      estimateFee: { enumerable: true, value: {}, writable: false }
+    });
+    this.abi.forEach((abiElement) => {
+      if (abiElement.type !== "function")
+        return;
+      const signature = abiElement.name;
+      if (!this[signature]) {
+        Object.defineProperty(this, signature, {
+          ...options,
+          value: buildDefault(this, abiElement)
+        });
+      }
+      if (!this.functions[signature]) {
+        Object.defineProperty(this.functions, signature, {
+          ...options,
+          value: buildDefault(this, abiElement)
+        });
+      }
+      if (!this.callStatic[signature]) {
+        Object.defineProperty(this.callStatic, signature, {
+          ...options,
+          value: buildCall(this, abiElement)
+        });
+      }
+      if (!this.populateTransaction[signature]) {
+        Object.defineProperty(this.populateTransaction, signature, {
+          ...options,
+          value: buildPopulate(this, abiElement)
+        });
+      }
+      if (!this.estimateFee[signature]) {
+        Object.defineProperty(this.estimateFee, signature, {
+          ...options,
+          value: buildEstimate(this, abiElement)
+        });
+      }
+    });
+  }
+  attach(address) {
+    this.address = address;
+  }
+  connect(providerOrAccount) {
+    this.providerOrAccount = providerOrAccount;
+  }
+  async deployed() {
+    if (this.deployTransactionHash) {
+      await this.providerOrAccount.waitForTransaction(this.deployTransactionHash);
+      this.deployTransactionHash = void 0;
+    }
+    return this;
+  }
+  async call(method, args = [], {
+    parseRequest = true,
+    parseResponse = true,
+    formatResponse = void 0,
+    blockIdentifier = void 0
+  } = {}) {
+    assert(this.address !== null, "contract is not connected to an address");
+    const calldata = getCalldata(args, () => {
+      if (parseRequest) {
+        this.callData.validate("CALL", method, args);
+        return this.callData.compile(method, args);
+      }
+      console.warn("Call skipped parsing but provided rawArgs, possible malfunction request");
+      return args;
+    });
+    return this.providerOrAccount.callContract(
+      {
+        contractAddress: this.address,
+        calldata,
+        entrypoint: method
+      },
+      blockIdentifier
+    ).then((x) => {
+      if (!parseResponse) {
+        return x.result;
+      }
+      if (formatResponse) {
+        return this.callData.format(method, x.result, formatResponse);
+      }
+      return this.callData.parse(method, x.result);
+    });
+  }
+  invoke(method, args = [], { parseRequest = true, maxFee, nonce, signature } = {}) {
+    assert(this.address !== null, "contract is not connected to an address");
+    const calldata = getCalldata(args, () => {
+      if (parseRequest) {
+        this.callData.validate("INVOKE", method, args);
+        return this.callData.compile(method, args);
+      }
+      console.warn("Invoke skipped parsing but provided rawArgs, possible malfunction request");
+      return args;
+    });
+    const invocation = {
+      contractAddress: this.address,
+      calldata,
+      entrypoint: method
+    };
+    if ("execute" in this.providerOrAccount) {
+      return this.providerOrAccount.execute(invocation, void 0, {
+        maxFee,
+        nonce
+      });
+    }
+    if (!nonce)
+      throw new Error(`Nonce is required when invoking a function without an account`);
+    console.warn(`Invoking ${method} without an account. This will not work on a public node.`);
+    return this.providerOrAccount.invokeFunction(
+      {
+        ...invocation,
+        signature
       },
-      transactionsDetail
-    );
-    const signature = await this.signer.signDeployAccountTransaction({
-      classHash,
-      constructorCalldata: compiledCalldata,
-      contractAddress,
-      addressSalt,
-      chainId,
-      maxFee,
-      version,
-      nonce
-    });
-    return this.deployAccountContract(
-      { classHash, addressSalt, constructorCalldata, signature },
       {
-        nonce,
-        maxFee,
-        version
+        nonce
       }
     );
   }
-  async signMessage(typedData) {
-    return this.signer.signMessage(typedData, this.address);
-  }
-  async hashMessage(typedData) {
-    return getMessageHash(typedData, this.address);
-  }
-  async verifyMessageHash(hash, signature) {
-    try {
-      await this.callContract({
-        contractAddress: this.address,
-        entrypoint: "isValidSignature",
-        calldata: CallData.compile({
-          hash: toBigInt(hash).toString(),
-          signature: formatSignature(signature)
-        })
-      });
-      return true;
-    } catch {
-      return false;
+  async estimate(method, args = []) {
+    assert(this.address !== null, "contract is not connected to an address");
+    if (!getCalldata(args, () => false)) {
+      this.callData.validate("INVOKE", method, args);
     }
-  }
-  async verifyMessage(typedData, signature) {
-    const hash = await this.hashMessage(typedData);
-    return this.verifyMessageHash(hash, signature);
-  }
-  async getSuggestedMaxFee({ type, payload }, details) {
-    let feeEstimate;
-    switch (type) {
-      case "INVOKE_FUNCTION" /* INVOKE */:
-        feeEstimate = await this.estimateInvokeFee(payload, details);
-        break;
-      case "DECLARE" /* DECLARE */:
-        feeEstimate = await this.estimateDeclareFee(payload, details);
-        break;
-      case "DEPLOY_ACCOUNT" /* DEPLOY_ACCOUNT */:
-        feeEstimate = await this.estimateAccountDeployFee(payload, details);
-        break;
-      case "DEPLOY" /* DEPLOY */:
-        feeEstimate = await this.estimateDeployFee(payload, details);
-        break;
-      default:
-        feeEstimate = { suggestedMaxFee: ZERO, overall_fee: ZERO };
-        break;
+    const invocation = this.populate(method, args);
+    if ("estimateInvokeFee" in this.providerOrAccount) {
+      return this.providerOrAccount.estimateInvokeFee(invocation);
     }
-    return feeEstimate.suggestedMaxFee;
+    throw Error("Contract must be connected to the account contract to estimate");
   }
-  /**
-   * will be renamed to buildDeclareContractTransaction
-   */
-  async buildDeclarePayload(payload, { nonce, chainId, version, walletAddress, maxFee }) {
-    const { classHash, contract, compiledClassHash } = extractContractHashes(payload);
-    const contractDefinition = parseContract(contract);
-    const signature = await this.signer.signDeclareTransaction({
-      classHash,
-      compiledClassHash,
-      senderAddress: walletAddress,
-      chainId,
-      maxFee,
-      version,
-      nonce
-    });
+  populate(method, args = []) {
+    const calldata = getCalldata(args, () => this.callData.compile(method, args));
     return {
-      senderAddress: walletAddress,
-      signature,
-      contractDefinition,
-      compiledClassHash
+      contractAddress: this.address,
+      entrypoint: method,
+      calldata
     };
   }
-  async buildAccountDeployPayload({
-    classHash,
-    addressSalt = 0,
-    constructorCalldata = [],
-    contractAddress: providedContractAddress
-  }, { nonce, chainId, version, maxFee }) {
-    const compiledCalldata = CallData.compile(constructorCalldata);
-    const contractAddress = providedContractAddress ?? calculateContractAddressFromHash(addressSalt, classHash, compiledCalldata, 0);
-    const signature = await this.signer.signDeployAccountTransaction({
-      classHash,
-      contractAddress,
-      chainId,
-      maxFee,
-      version,
-      nonce,
-      addressSalt,
-      constructorCalldata: compiledCalldata
-    });
-    return {
-      classHash,
-      addressSalt,
-      constructorCalldata: compiledCalldata,
-      signature
-    };
+};
+
+// src/contract/interface.ts
+var ContractInterface = class {
+};
+
+// src/contract/contractFactory.ts
+var ContractFactory = class {
+  constructor(compiledContract, classHash, account, abi = compiledContract.abi) {
+    this.abi = abi;
+    this.compiledContract = compiledContract;
+    this.account = account;
+    this.classHash = classHash;
+    this.CallData = new CallData(abi);
   }
-  buildUDCContractPayload(payload) {
-    const calls = [].concat(payload).map((it) => {
-      const {
-        classHash,
-        salt = "0",
-        unique = true,
-        constructorCalldata = []
-      } = it;
-      const compiledConstructorCallData = CallData.compile(constructorCalldata);
-      return {
-        contractAddress: UDC.ADDRESS,
-        entrypoint: UDC.ENTRYPOINT,
-        calldata: [
-          classHash,
-          salt,
-          toCairoBool(unique),
-          compiledConstructorCallData.length,
-          ...compiledConstructorCallData
-        ]
-      };
+  /**
+   * 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, () => {
+      if (options.parseRequest) {
+        this.CallData.validate("DEPLOY", "constructor", param);
+        return this.CallData.compile("constructor", param);
+      }
+      console.warn("Call skipped parsing but provided rawArgs, possible malfunction request");
+      return param;
     });
-    return calls;
-  }
-  async simulateTransaction(calls, { nonce: providedNonce, blockIdentifier, skipValidate } = {}) {
-    const transactions = Array.isArray(calls) ? calls : [calls];
-    const nonce = toBigInt(providedNonce ?? await this.getNonce());
-    const version = toBigInt(feeTransactionVersion);
-    const chainId = await this.getChainId();
-    const signerDetails = {
-      walletAddress: this.address,
-      nonce,
-      maxFee: ZERO,
-      version,
-      chainId,
-      cairoVersion: this.cairoVersion
-    };
-    const invocation = await this.buildInvocation(transactions, signerDetails);
-    const response = await super.getSimulateTransaction(
-      invocation,
-      { version, nonce },
-      blockIdentifier,
-      skipValidate
+    const {
+      deploy: { contract_address, transaction_hash }
+    } = await this.account.declareAndDeploy({
+      contract: this.compiledContract,
+      constructorCalldata,
+      salt: options.addressSalt
+    });
+    assert(Boolean(contract_address), "Deployment of the contract failed");
+    const contractInstance = new Contract(
+      this.compiledContract.abi,
+      contract_address,
+      this.account
     );
-    const suggestedMaxFee = estimatedFeeToMaxFee(response.fee_estimation.overall_fee);
-    return {
-      ...response,
-      fee_estimation: {
-        ...response.fee_estimation,
-        suggestedMaxFee
-      }
-    };
+    contractInstance.deployTransactionHash = transaction_hash;
+    return contractInstance;
   }
-  async getStarkName(address = this.address, StarknetIdContract2) {
-    return super.getStarkName(address, StarknetIdContract2);
+  /**
+   * Attaches to new Account
+   *
+   * @param account - new Provider or Account to attach to
+   * @returns ContractFactory
+   */
+  connect(account) {
+    this.account = account;
+    return this;
   }
-};
-
-// src/account/interface.ts
-var AccountInterface = class extends ProviderInterface {
+  /**
+   * 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/utils/address.ts
@@ -6197,6 +6202,7 @@ export {
   starknetId_exports as starknetId,
   transaction_exports as transaction,
   typedData_exports as typedData,
+  types_exports as types,
   uint256_exports as uint256,
   validateAndParseAddress,
   validateChecksumAddress