starknet 5.24.4 → 5.25.0

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [5.25.0](https://github.com/starknet-io/starknet.js/compare/v5.24.5...v5.25.0) (2023-12-18)
+
+### Features
+
+- sepolia ([26d7044](https://github.com/starknet-io/starknet.js/commit/26d70446edd7c098b7f257d9242cc9d9d220b11e))
+
+## [5.24.5](https://github.com/starknet-io/starknet.js/compare/v5.24.4...v5.24.5) (2023-12-10)
+
+### Bug Fixes
+
+- apply bound for contract address from hash calculation ([6d8c291](https://github.com/starknet-io/starknet.js/commit/6d8c291bce130d7b00ae6d81aff071c4986f04af))
+- **Calldata.compile:** do not split long `entrypoint` names before calling `getSelectorFromName` ([89715da](https://github.com/starknet-io/starknet.js/commit/89715da3fdb4b497cc5771eb83a88460007740b6))
+- prioritize error states in waitForTransaction evaluation ([ac54404](https://github.com/starknet-io/starknet.js/commit/ac544045e2079b68042d850a09b203fc5536c0d0))
+
 ## [5.24.4](https://github.com/starknet-io/starknet.js/compare/v5.24.3...v5.24.4) (2023-12-06)
 
 ### Bug Fixes

package/README.md

@@ -64,6 +64,8 @@ If you consider to contribute to this project please read [CONTRIBUTING.md](http
 
 Special thanks to all the [contributors](https://github.com/starknet-io/starknet.js/graphs/contributors), especially to:
 
+- Sean ([@0xs34n](https://github.com/0xs34n)), the original creator of Straknet.js!
+
 - Janek ([@janek26](https://github.com/janek26)) and Dhruv ([@dhruvkelawala](https://github.com/dhruvkelawala)) from [Argent](https://github.com/argentlabs)
 
 - Toni ([@tabaktoni](https://github.com/tabaktoni)) and Ivan ([@ivpavici](https://github.com/ivpavici)) from [SpaceShard](https://www.spaceshard.io/)

package/dist/index.d.ts

@@ -128,19 +128,23 @@ declare const BN_FEE_TRANSACTION_VERSION_1: bigint;
 declare const BN_FEE_TRANSACTION_VERSION_2: bigint;
 declare const ZERO = 0n;
 declare const MASK_250: bigint;
-declare const MASK_251: bigint;
 declare const API_VERSION = 0n;
+declare const MAX_STORAGE_ITEM_SIZE = 256n;
+declare const ADDR_BOUND: bigint;
 declare enum BaseUrl {
     SN_MAIN = "https://alpha-mainnet.starknet.io",
-    SN_GOERLI = "https://alpha4.starknet.io"
+    SN_GOERLI = "https://alpha4.starknet.io",
+    SN_SEPOLIA = "https://alpha-sepolia.starknet.io"
 }
 declare enum NetworkName {
     SN_MAIN = "SN_MAIN",
-    SN_GOERLI = "SN_GOERLI"
+    SN_GOERLI = "SN_GOERLI",
+    SN_SEPOLIA = "SN_SEPOLIA"
 }
 declare enum StarknetChainId {
     SN_MAIN = "0x534e5f4d41494e",
-    SN_GOERLI = "0x534e5f474f45524c49"
+    SN_GOERLI = "0x534e5f474f45524c49",
+    SN_SEPOLIA = "0x534e5f5345504f4c4941"
 }
 declare enum TransactionHashPrefix {
     DECLARE = "0x6465636c617265",
@@ -153,9 +157,14 @@ declare const UDC: {
     ADDRESS: string;
     ENTRYPOINT: string;
 };
-declare const RPC_GOERLI_NODES: string[];
-declare const RPC_MAINNET_NODES: string[];
+declare const RPC_DEFAULT_VERSION = "v0_5";
+declare const RPC_NODES: {
+    SN_GOERLI: string[];
+    SN_MAIN: string[];
+    SN_SEPOLIA: string[];
+};
 
+declare const constants_ADDR_BOUND: typeof ADDR_BOUND;
 declare const constants_API_VERSION: typeof API_VERSION;
 declare const constants_BN_FEE_TRANSACTION_VERSION_1: typeof BN_FEE_TRANSACTION_VERSION_1;
 declare const constants_BN_FEE_TRANSACTION_VERSION_2: typeof BN_FEE_TRANSACTION_VERSION_2;
@@ -167,11 +176,11 @@ declare const constants_HEX_STR_TRANSACTION_VERSION_1: typeof HEX_STR_TRANSACTIO
 declare const constants_HEX_STR_TRANSACTION_VERSION_2: typeof HEX_STR_TRANSACTION_VERSION_2;
 declare const constants_IS_BROWSER: typeof IS_BROWSER;
 declare const constants_MASK_250: typeof MASK_250;
-declare const constants_MASK_251: typeof MASK_251;
+declare const constants_MAX_STORAGE_ITEM_SIZE: typeof MAX_STORAGE_ITEM_SIZE;
 type constants_NetworkName = NetworkName;
 declare const constants_NetworkName: typeof NetworkName;
-declare const constants_RPC_GOERLI_NODES: typeof RPC_GOERLI_NODES;
-declare const constants_RPC_MAINNET_NODES: typeof RPC_MAINNET_NODES;
+declare const constants_RPC_DEFAULT_VERSION: typeof RPC_DEFAULT_VERSION;
+declare const constants_RPC_NODES: typeof RPC_NODES;
 type constants_StarknetChainId = StarknetChainId;
 declare const constants_StarknetChainId: typeof StarknetChainId;
 declare const constants_TEXT_TO_FELT_MAX_LEN: typeof TEXT_TO_FELT_MAX_LEN;
@@ -181,6 +190,7 @@ declare const constants_UDC: typeof UDC;
 declare const constants_ZERO: typeof ZERO;
 declare namespace constants {
   export {
+    constants_ADDR_BOUND as ADDR_BOUND,
     constants_API_VERSION as API_VERSION,
     constants_BN_FEE_TRANSACTION_VERSION_1 as BN_FEE_TRANSACTION_VERSION_1,
     constants_BN_FEE_TRANSACTION_VERSION_2 as BN_FEE_TRANSACTION_VERSION_2,
@@ -191,10 +201,10 @@ declare namespace constants {
     constants_HEX_STR_TRANSACTION_VERSION_2 as HEX_STR_TRANSACTION_VERSION_2,
     constants_IS_BROWSER as IS_BROWSER,
     constants_MASK_250 as MASK_250,
-    constants_MASK_251 as MASK_251,
+    constants_MAX_STORAGE_ITEM_SIZE as MAX_STORAGE_ITEM_SIZE,
     constants_NetworkName as NetworkName,
-    constants_RPC_GOERLI_NODES as RPC_GOERLI_NODES,
-    constants_RPC_MAINNET_NODES as RPC_MAINNET_NODES,
+    constants_RPC_DEFAULT_VERSION as RPC_DEFAULT_VERSION,
+    constants_RPC_NODES as RPC_NODES,
     constants_StarknetChainId as StarknetChainId,
     constants_TEXT_TO_FELT_MAX_LEN as TEXT_TO_FELT_MAX_LEN,
     constants_TransactionHashPrefix as TransactionHashPrefix,
@@ -710,6 +720,7 @@ type RpcProviderOptions = {
     blockIdentifier?: BlockIdentifier;
     chainId?: StarknetChainId;
     default?: boolean;
+    rpcVersion?: 'v0_5' | 'v0_6';
 };
 type SequencerHttpMethod = 'POST' | 'GET';
 type SequencerProviderOptions = {
@@ -3583,7 +3594,7 @@ declare class SequencerProvider implements ProviderInterface {
     private chainId;
     private responseParser;
     constructor(optionsOrProvider?: SequencerProviderOptions);
-    protected static getNetworkFromName(name: NetworkName | StarknetChainId): BaseUrl;
+    protected static getNetworkFromName(name: NetworkName | StarknetChainId): BaseUrl.SN_MAIN | BaseUrl.SN_GOERLI;
     protected static getChainIdFromBaseUrl(baseUrl: string): StarknetChainId;
     private getFetchUrl;
     private getFetchMethod;
@@ -3659,7 +3670,13 @@ declare class SequencerProvider implements ProviderInterface {
     buildTransaction(invocation: AccountInvocationItem, versionType?: 'fee' | 'transaction'): AccountTransactionItem;
 }
 
-declare const getDefaultNodeUrl: (networkName?: NetworkName, mute?: boolean) => string;
+/**
+ * Return randomly select available public node
+ * @param networkName NetworkName
+ * @param mute mute public node warning
+ * @returns default node url
+ */
+declare const getDefaultNodeUrl: (networkName?: NetworkName, mute?: boolean, version?: 'v0_5' | 'v0_6') => string;
 declare class RpcProvider implements ProviderInterface {
     nodeUrl: string;
     headers: object;

package/dist/index.global.js

@@ -362,7 +362,7 @@ var starknet = (() => {
           statusText: xhr.statusText,
           headers: parseHeaders(xhr.getAllResponseHeaders() || "")
         };
-        if (request.url.startsWith("file://") && (xhr.status < 200 || xhr.status > 599)) {
+        if (request.url.indexOf("file://") === 0 && (xhr.status < 200 || xhr.status > 599)) {
           options.status = 200;
         } else {
           options.status = xhr.status;
@@ -536,6 +536,7 @@ var starknet = (() => {
       };
       Response.error = function() {
         var response = new Response(null, { status: 200, statusText: "" });
+        response.ok = false;
         response.status = 0;
         response.type = "error";
         return response;
@@ -720,6 +721,7 @@ var starknet = (() => {
   // src/constants.ts
   var constants_exports = {};
   __export(constants_exports, {
+    ADDR_BOUND: () => ADDR_BOUND,
     API_VERSION: () => API_VERSION,
     BN_FEE_TRANSACTION_VERSION_1: () => BN_FEE_TRANSACTION_VERSION_1,
     BN_FEE_TRANSACTION_VERSION_2: () => BN_FEE_TRANSACTION_VERSION_2,
@@ -730,10 +732,10 @@ var starknet = (() => {
     HEX_STR_TRANSACTION_VERSION_2: () => HEX_STR_TRANSACTION_VERSION_2,
     IS_BROWSER: () => IS_BROWSER,
     MASK_250: () => MASK_250,
-    MASK_251: () => MASK_251,
+    MAX_STORAGE_ITEM_SIZE: () => MAX_STORAGE_ITEM_SIZE,
     NetworkName: () => NetworkName,
-    RPC_GOERLI_NODES: () => RPC_GOERLI_NODES,
-    RPC_MAINNET_NODES: () => RPC_MAINNET_NODES,
+    RPC_DEFAULT_VERSION: () => RPC_DEFAULT_VERSION,
+    RPC_NODES: () => RPC_NODES,
     StarknetChainId: () => StarknetChainId,
     TEXT_TO_FELT_MAX_LEN: () => TEXT_TO_FELT_MAX_LEN,
     TransactionHashPrefix: () => TransactionHashPrefix,
@@ -765,10 +767,14 @@ var starknet = (() => {
     if (!Number.isSafeInteger(n))
       throw new Error(`Wrong integer: ${n}`);
   }
+  function isBytes(a) {
+    return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
+  }
   function chain(...args) {
+    const id = (a) => a;
     const wrap = (a, b) => (c) => a(b(c));
-    const encode = Array.from(args).reverse().reduce((acc, i) => acc ? wrap(acc, i.encode) : i.encode, void 0);
-    const decode2 = args.reduce((acc, i) => acc ? wrap(acc, i.decode) : i.decode, void 0);
+    const encode = args.map((x) => x.encode).reduceRight(wrap, id);
+    const decode2 = args.map((x) => x.decode).reduce(wrap, id);
     return { encode, decode: decode2 };
   }
   function alphabet(alphabet2) {
@@ -904,13 +910,13 @@ var starknet = (() => {
       throw new Error("radix2: carry overflow");
     return {
       encode: (bytes2) => {
-        if (!(bytes2 instanceof Uint8Array))
+        if (!isBytes(bytes2))
           throw new Error("radix2.encode input should be Uint8Array");
         return convertRadix2(Array.from(bytes2), 8, bits, !revPadding);
       },
       decode: (digits) => {
         if (!Array.isArray(digits) || digits.length && typeof digits[0] !== "number")
-          throw new Error("radix2.decode input should be array of strings");
+          throw new Error("radix2.decode input should be array of numbers");
         return Uint8Array.from(convertRadix2(digits, bits, 8, revPadding));
       }
     };
@@ -996,21 +1002,25 @@ var starknet = (() => {
   var BN_FEE_TRANSACTION_VERSION_2 = 2n ** 128n + BN_TRANSACTION_VERSION_2;
   var ZERO = 0n;
   var MASK_250 = 2n ** 250n - 1n;
-  var MASK_251 = 2n ** 251n;
   var API_VERSION = ZERO;
+  var MAX_STORAGE_ITEM_SIZE = 256n;
+  var ADDR_BOUND = 2n ** 251n - MAX_STORAGE_ITEM_SIZE;
   var BaseUrl = /* @__PURE__ */ ((BaseUrl2) => {
     BaseUrl2["SN_MAIN"] = "https://alpha-mainnet.starknet.io";
     BaseUrl2["SN_GOERLI"] = "https://alpha4.starknet.io";
+    BaseUrl2["SN_SEPOLIA"] = "https://alpha-sepolia.starknet.io";
     return BaseUrl2;
   })(BaseUrl || {});
   var NetworkName = /* @__PURE__ */ ((NetworkName2) => {
     NetworkName2["SN_MAIN"] = "SN_MAIN";
     NetworkName2["SN_GOERLI"] = "SN_GOERLI";
+    NetworkName2["SN_SEPOLIA"] = "SN_SEPOLIA";
     return NetworkName2;
   })(NetworkName || {});
   var StarknetChainId = /* @__PURE__ */ ((StarknetChainId4) => {
     StarknetChainId4["SN_MAIN"] = "0x534e5f4d41494e";
     StarknetChainId4["SN_GOERLI"] = "0x534e5f474f45524c49";
+    StarknetChainId4["SN_SEPOLIA"] = "0x534e5f5345504f4c4941";
     return StarknetChainId4;
   })(StarknetChainId || {});
   var TransactionHashPrefix = /* @__PURE__ */ ((TransactionHashPrefix2) => {
@@ -1025,14 +1035,21 @@ var starknet = (() => {
     ADDRESS: "0x041a78e741e5af2fec34b695679bc6891742439f7afb8484ecd7766661ad02bf",
     ENTRYPOINT: "deployContract"
   };
-  var RPC_GOERLI_NODES = [
-    "https://starknet-testnet.public.blastapi.io/rpc/v0.5",
-    "https://limited-rpc.nethermind.io/goerli-juno/v0_5"
-  ];
-  var RPC_MAINNET_NODES = [
-    "https://starknet-mainnet.public.blastapi.io/rpc/v0.5",
-    "https://limited-rpc.nethermind.io/mainnet-juno/v0_5"
-  ];
+  var RPC_DEFAULT_VERSION = "v0_5";
+  var RPC_NODES = {
+    SN_GOERLI: [
+      `https://starknet-testnet.public.blastapi.io/rpc/`,
+      `https://free-rpc.nethermind.io/goerli-juno/`
+    ],
+    SN_MAIN: [
+      `https://starknet-mainnet.public.blastapi.io/rpc/`,
+      `https://free-rpc.nethermind.io/mainnet-juno/`
+    ],
+    SN_SEPOLIA: [
+      `https://starknet-sepolia.public.blastapi.io/rpc/`,
+      `https://free-rpc.nethermind.io/sepolia-juno/`
+    ]
+  };
 
   // src/types/index.ts
   var types_exports = {};
@@ -1246,6 +1263,7 @@ var starknet = (() => {
     equalBytes: () => equalBytes,
     hexToBytes: () => hexToBytes,
     hexToNumber: () => hexToNumber,
+    isBytes: () => isBytes2,
     numberToBytesBE: () => numberToBytesBE,
     numberToBytesLE: () => numberToBytesLE,
     numberToHexUnpadded: () => numberToHexUnpadded,
@@ -1256,10 +1274,12 @@ var starknet = (() => {
   var _0n = BigInt(0);
   var _1n = BigInt(1);
   var _2n = BigInt(2);
-  var u8a = (a) => a instanceof Uint8Array;
+  function isBytes2(a) {
+    return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
+  }
   var hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
   function bytesToHex(bytes2) {
-    if (!u8a(bytes2))
+    if (!isBytes2(bytes2))
       throw new Error("Uint8Array expected");
     let hex2 = "";
     for (let i = 0; i < bytes2.length; i++) {
@@ -1276,20 +1296,32 @@ var starknet = (() => {
       throw new Error("hex string expected, got " + typeof hex2);
     return BigInt(hex2 === "" ? "0" : `0x${hex2}`);
   }
+  var asciis = { _0: 48, _9: 57, _A: 65, _F: 70, _a: 97, _f: 102 };
+  function asciiToBase16(char) {
+    if (char >= asciis._0 && char <= asciis._9)
+      return char - asciis._0;
+    if (char >= asciis._A && char <= asciis._F)
+      return char - (asciis._A - 10);
+    if (char >= asciis._a && char <= asciis._f)
+      return char - (asciis._a - 10);
+    return;
+  }
   function hexToBytes(hex2) {
     if (typeof hex2 !== "string")
       throw new Error("hex string expected, got " + typeof hex2);
-    const len = hex2.length;
-    if (len % 2)
-      throw new Error("padded hex string expected, got unpadded hex of length " + len);
-    const array = new Uint8Array(len / 2);
-    for (let i = 0; i < array.length; i++) {
-      const j = i * 2;
-      const hexByte = hex2.slice(j, j + 2);
-      const byte = Number.parseInt(hexByte, 16);
-      if (Number.isNaN(byte) || byte < 0)
-        throw new Error("Invalid byte sequence");
-      array[i] = byte;
+    const hl = hex2.length;
+    const al = hl / 2;
+    if (hl % 2)
+      throw new Error("padded hex string expected, got unpadded hex of length " + hl);
+    const array = new Uint8Array(al);
+    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
+      const n1 = asciiToBase16(hex2.charCodeAt(hi));
+      const n2 = asciiToBase16(hex2.charCodeAt(hi + 1));
+      if (n1 === void 0 || n2 === void 0) {
+        const char = hex2[hi] + hex2[hi + 1];
+        throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
+      }
+      array[ai] = n1 * 16 + n2;
     }
     return array;
   }
@@ -1297,7 +1329,7 @@ var starknet = (() => {
     return hexToNumber(bytesToHex(bytes2));
   }
   function bytesToNumberLE(bytes2) {
-    if (!u8a(bytes2))
+    if (!isBytes2(bytes2))
       throw new Error("Uint8Array expected");
     return hexToNumber(bytesToHex(Uint8Array.from(bytes2).reverse()));
   }
@@ -1318,7 +1350,7 @@ var starknet = (() => {
       } catch (e) {
         throw new Error(`${title} must be valid hex string, got "${hex2}". Cause: ${e}`);
       }
-    } else if (u8a(hex2)) {
+    } else if (isBytes2(hex2)) {
       res = Uint8Array.from(hex2);
     } else {
       throw new Error(`${title} must be hex string or Uint8Array`);
@@ -1329,23 +1361,29 @@ var starknet = (() => {
     return res;
   }
   function concatBytes(...arrays) {
-    const r = new Uint8Array(arrays.reduce((sum, a) => sum + a.length, 0));
-    let pad = 0;
-    arrays.forEach((a) => {
-      if (!u8a(a))
+    let sum = 0;
+    for (let i = 0; i < arrays.length; i++) {
+      const a = arrays[i];
+      if (!isBytes2(a))
         throw new Error("Uint8Array expected");
-      r.set(a, pad);
+      sum += a.length;
+    }
+    let res = new Uint8Array(sum);
+    let pad = 0;
+    for (let i = 0; i < arrays.length; i++) {
+      const a = arrays[i];
+      res.set(a, pad);
       pad += a.length;
-    });
-    return r;
+    }
+    return res;
   }
-  function equalBytes(b1, b2) {
-    if (b1.length !== b2.length)
+  function equalBytes(a, b) {
+    if (a.length !== b.length)
       return false;
-    for (let i = 0; i < b1.length; i++)
-      if (b1[i] !== b2[i])
-        return false;
-    return true;
+    let diff = 0;
+    for (let i = 0; i < a.length; i++)
+      diff |= a[i] ^ b[i];
+    return diff === 0;
   }
   function utf8ToBytes(str) {
     if (typeof str !== "string")
@@ -1420,7 +1458,7 @@ var starknet = (() => {
     function: (val) => typeof val === "function",
     boolean: (val) => typeof val === "boolean",
     string: (val) => typeof val === "string",
-    stringOrUint8Array: (val) => typeof val === "string" || val instanceof Uint8Array,
+    stringOrUint8Array: (val) => typeof val === "string" || isBytes2(val),
     isSafeInteger: (val) => Number.isSafeInteger(val),
     array: (val) => Array.isArray(val),
     field: (val, object) => object.Fp.isValid(val),
@@ -1561,8 +1599,11 @@ var starknet = (() => {
     if (!Number.isSafeInteger(n) || n < 0)
       throw new Error(`Wrong positive integer: ${n}`);
   }
+  function isBytes3(a) {
+    return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
+  }
   function bytes(b, ...lengths) {
-    if (!(b instanceof Uint8Array))
+    if (!isBytes3(b))
       throw new Error("Expected Uint8Array");
     if (lengths.length > 0 && !lengths.includes(b.length))
       throw new Error(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);
@@ -1613,8 +1654,10 @@ var starknet = (() => {
   var crypto = typeof globalThis === "object" && "crypto" in globalThis ? globalThis.crypto : void 0;
 
   // node_modules/@noble/hashes/esm/utils.js
-  var u8a2 = (a) => a instanceof Uint8Array;
   var u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+  function isBytes4(a) {
+    return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
+  }
   var createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
   var rotr = (word, shift) => word << 32 - shift | word >>> shift;
   var isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
@@ -1628,20 +1671,25 @@ var starknet = (() => {
   function toBytes(data) {
     if (typeof data === "string")
       data = utf8ToBytes2(data);
-    if (!u8a2(data))
+    if (!isBytes4(data))
       throw new Error(`expected Uint8Array, got ${typeof data}`);
     return data;
   }
   function concatBytes2(...arrays) {
-    const r = new Uint8Array(arrays.reduce((sum, a) => sum + a.length, 0));
-    let pad = 0;
-    arrays.forEach((a) => {
-      if (!u8a2(a))
+    let sum = 0;
+    for (let i = 0; i < arrays.length; i++) {
+      const a = arrays[i];
+      if (!isBytes4(a))
         throw new Error("Uint8Array expected");
-      r.set(a, pad);
+      sum += a.length;
+    }
+    const res = new Uint8Array(sum);
+    for (let i = 0, pad = 0; i < arrays.length; i++) {
+      const a = arrays[i];
+      res.set(a, pad);
       pad += a.length;
-    });
-    return r;
+    }
+    return res;
   }
   var Hash = class {
     // Safe version that clones internal state
@@ -2647,7 +2695,7 @@ var starknet = (() => {
     toSig(hex2) {
       const { Err: E } = DER;
       const data = typeof hex2 === "string" ? h2b(hex2) : hex2;
-      if (!(data instanceof Uint8Array))
+      if (!isBytes2(data))
         throw new Error("ui8a expected");
       let l = data.length;
       if (l < 2 || data[0] != 48)
@@ -2711,7 +2759,7 @@ var starknet = (() => {
     function normPrivateKeyToScalar(key) {
       const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n } = CURVE2;
       if (lengths && typeof key !== "bigint") {
-        if (key instanceof Uint8Array)
+        if (isBytes2(key))
           key = bytesToHex(key);
         if (typeof key !== "string" || !lengths.includes(key.length))
           throw new Error("Invalid key");
@@ -3246,7 +3294,7 @@ var starknet = (() => {
       return Point.fromPrivateKey(privateKey).toRawBytes(isCompressed);
     }
     function isProbPub(item) {
-      const arr = item instanceof Uint8Array;
+      const arr = isBytes2(item);
       const str = typeof item === "string";
       const len = (arr || str) && item.length;
       if (arr)
@@ -3341,7 +3389,7 @@ var starknet = (() => {
       let _sig = void 0;
       let P;
       try {
-        if (typeof sg === "string" || sg instanceof Uint8Array) {
+        if (typeof sg === "string" || isBytes2(sg)) {
           try {
             _sig = Signature3.fromDER(sg);
           } catch (derError) {
@@ -5156,10 +5204,10 @@ var starknet = (() => {
           const oe = Array.isArray(o) ? [o.length.toString(), ...o] : o;
           return Object.entries(oe).flatMap(([k, v]) => {
             let value = v;
-            if (isLongText(value))
-              value = splitLongString(value);
             if (k === "entrypoint")
               value = getSelectorFromName(value);
+            else if (isLongText(value))
+              value = splitLongString(value);
             const kk = Array.isArray(oe) && k === "0" ? "$$len" : k;
             if (isBigInt(value))
               return [[`${prefix}${kk}`, felt(value)]];
@@ -6084,13 +6132,14 @@ var starknet = (() => {
     const compiledCalldata = CallData.compile(constructorCalldata);
     const constructorCalldataHash = computeHashOnElements2(compiledCalldata);
     const CONTRACT_ADDRESS_PREFIX = felt("0x535441524b4e45545f434f4e54524143545f41444452455353");
-    return computeHashOnElements2([
+    const hash2 = computeHashOnElements2([
       CONTRACT_ADDRESS_PREFIX,
       deployerAddress,
       salt,
       classHash,
       constructorCalldataHash
     ]);
+    return toHex(BigInt(hash2) % ADDR_BOUND);
   }
   function nullSkipReplacer(key, value) {
     if (key === "attributes" || key === "accessible_scopes") {
@@ -10797,12 +10846,12 @@ var starknet = (() => {
   };
 
   // src/provider/rpc.ts
-  var getDefaultNodeUrl = (networkName, mute = false) => {
+  var getDefaultNodeUrl = (networkName, mute = false, version = RPC_DEFAULT_VERSION) => {
     if (!mute)
       console.warn("Using default public node url, please provide nodeUrl in provider options!");
-    const nodes = networkName === "SN_MAIN" /* SN_MAIN */ ? RPC_MAINNET_NODES : RPC_GOERLI_NODES;
+    const nodes = RPC_NODES[networkName ?? "SN_GOERLI" /* SN_GOERLI */];
     const randIdx = Math.floor(Math.random() * nodes.length);
-    return nodes[randIdx];
+    return `${nodes[randIdx]}${version}`;
   };
   var defaultOptions = {
     headers: { "Content-Type": "application/json" },
@@ -10840,13 +10889,17 @@ var starknet = (() => {
        * @deprecated renamed to simulateTransaction();
        */
       this.getSimulateTransaction = this.simulateTransaction;
-      const { nodeUrl, retries, headers, blockIdentifier, chainId } = optionsOrProvider || {};
+      const { nodeUrl, retries, headers, blockIdentifier, chainId, rpcVersion } = optionsOrProvider || {};
       if (Object.values(NetworkName).includes(nodeUrl)) {
-        this.nodeUrl = getDefaultNodeUrl(nodeUrl, optionsOrProvider?.default);
+        this.nodeUrl = getDefaultNodeUrl(
+          nodeUrl,
+          optionsOrProvider?.default,
+          rpcVersion
+        );
       } else if (nodeUrl) {
         this.nodeUrl = nodeUrl;
       } else {
-        this.nodeUrl = getDefaultNodeUrl(void 0, optionsOrProvider?.default);
+        this.nodeUrl = getDefaultNodeUrl(void 0, optionsOrProvider?.default, rpcVersion);
       }
       this.retries = retries || defaultOptions.retries;
       this.headers = { ...defaultOptions.headers, ...headers };
@@ -11022,8 +11075,10 @@ var starknet = (() => {
       let isErrorState = false;
       const retryInterval = options?.retryInterval ?? 5e3;
       const errorStates = options?.errorStates ?? [
-        rpc_exports.ETransactionStatus.REJECTED,
-        rpc_exports.ETransactionExecutionStatus.REVERTED
+        rpc_exports.ETransactionStatus.REJECTED
+        // TODO: commented out to preserve the long-standing behavior of "reverted" not being treated as an error by default
+        // should decide which behavior to keep in the future
+        // RPC.ETransactionExecutionStatus.REVERTED,
       ];
       const successStates = options?.successStates ?? [
         rpc_exports.ETransactionExecutionStatus.SUCCEEDED,
@@ -11041,14 +11096,14 @@ var starknet = (() => {
             const error = new Error("waiting for transaction status");
             throw error;
           }
-          if (successStates.includes(executionStatus) || successStates.includes(finalityStatus)) {
-            onchain = true;
-          } else if (errorStates.includes(executionStatus) || errorStates.includes(finalityStatus)) {
+          if (errorStates.includes(executionStatus) || errorStates.includes(finalityStatus)) {
             const message = `${executionStatus}: ${finalityStatus}`;
             const error = new Error(message);
             error.response = txStatus;
             isErrorState = true;
             throw error;
+          } else if (successStates.includes(executionStatus) || successStates.includes(finalityStatus)) {
+            onchain = true;
           }
         } catch (error) {
           if (error instanceof Error && isErrorState) {
@@ -13402,7 +13457,7 @@ ${res.tx_failure_reason.error_message}`;
     return addHexPrefix(removeHexPrefix(toHex(address)).padStart(64, "0"));
   }
   function validateAndParseAddress(address) {
-    assertInRange(address, ZERO, MASK_251, "Starknet Address");
+    assertInRange(address, ZERO, ADDR_BOUND - 1n, "Starknet Address");
     const result = addAddressPadding(address);
     if (!result.match(/^(0x)?[0-9a-fA-F]{64}$/)) {
       throw new Error("Invalid Address Format");