starknet 5.24.5 → 5.25.0

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+# [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

package/dist/index.d.ts

@@ -133,15 +133,18 @@ 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",
@@ -154,8 +157,12 @@ 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;
@@ -172,8 +179,8 @@ declare const constants_MASK_250: typeof MASK_250;
 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;
@@ -196,8 +203,8 @@ declare namespace constants {
     constants_MASK_250 as MASK_250,
     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,
@@ -713,6 +720,7 @@ type RpcProviderOptions = {
     blockIdentifier?: BlockIdentifier;
     chainId?: StarknetChainId;
     default?: boolean;
+    rpcVersion?: 'v0_5' | 'v0_6';
 };
 type SequencerHttpMethod = 'POST' | 'GET';
 type SequencerProviderOptions = {
@@ -3586,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;
@@ -3662,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;
@@ -733,8 +734,8 @@ var starknet = (() => {
     MASK_250: () => MASK_250,
     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,
@@ -766,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) {
@@ -905,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));
       }
     };
@@ -1003,16 +1008,19 @@ var starknet = (() => {
   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) => {
@@ -1027,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 = {};
@@ -1248,6 +1263,7 @@ var starknet = (() => {
     equalBytes: () => equalBytes,
     hexToBytes: () => hexToBytes,
     hexToNumber: () => hexToNumber,
+    isBytes: () => isBytes2,
     numberToBytesBE: () => numberToBytesBE,
     numberToBytesLE: () => numberToBytesLE,
     numberToHexUnpadded: () => numberToHexUnpadded,
@@ -1258,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++) {
@@ -1278,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;
   }
@@ -1299,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()));
   }
@@ -1320,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`);
@@ -1331,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")
@@ -1422,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),
@@ -1563,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}`);
@@ -1615,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;
@@ -1630,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
@@ -2649,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)
@@ -2713,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");
@@ -3248,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)
@@ -3343,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) {
@@ -10800,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" },
@@ -10843,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 };