@secondlayer/stacks 1.0.1 → 2.0.1

package/dist/src/tools/index.js

@@ -18,13 +18,13 @@ function bytesToHex(bytes) {
   return hex;
 }
 function hexToBytes(hex) {
-  hex = without0x(hex);
-  if (hex.length % 2)
-    hex = `0${hex}`;
-  const array = new Uint8Array(hex.length / 2);
+  let h = without0x(hex);
+  if (h.length % 2)
+    h = `0${h}`;
+  const array = new Uint8Array(h.length / 2);
   for (let i = 0;i < array.length; i++) {
     const j = i * 2;
-    const byte = Number.parseInt(hex.slice(j, j + 2), 16);
+    const byte = Number.parseInt(h.slice(j, j + 2), 16);
     if (Number.isNaN(byte) || byte < 0)
       throw new Error("Invalid byte sequence");
     array[i] = byte;
@@ -140,15 +140,16 @@ function c32normalize(input) {
   return input.toUpperCase().replace(/O/g, "0").replace(/L|I/g, "1");
 }
 function c32encode(inputHex) {
-  if (inputHex.length % 2 !== 0)
-    inputHex = `0${inputHex}`;
-  inputHex = inputHex.toLowerCase();
+  let hex = inputHex;
+  if (hex.length % 2 !== 0)
+    hex = `0${hex}`;
+  hex = hex.toLowerCase();
   const res = [];
   let carry = 0;
-  for (let i = inputHex.length - 1;i >= 0; i--) {
+  for (let i = hex.length - 1;i >= 0; i--) {
     if (carry < 4) {
-      const currentCode = HEX.indexOf(inputHex[i]) >> carry;
-      const nextCode = i !== 0 ? HEX.indexOf(inputHex[i - 1]) : 0;
+      const currentCode = HEX.indexOf(hex[i]) >> carry;
+      const nextCode = i !== 0 ? HEX.indexOf(hex[i - 1]) : 0;
       const nextBits = 1 + carry;
       const nextLowBits = nextCode % (1 << nextBits) << 5 - nextBits;
       res.unshift(C32[currentCode + nextLowBits]);
@@ -161,7 +162,7 @@ function c32encode(inputHex) {
   while (leadingZeros < res.length && res[leadingZeros] === "0")
     leadingZeros++;
   const stripped = res.slice(leadingZeros);
-  const bytes = hexToBytes(inputHex);
+  const bytes = hexToBytes(hex);
   let zeroBytesCount = 0;
   while (zeroBytesCount < bytes.length && bytes[zeroBytesCount] === 0)
     zeroBytesCount++;
@@ -169,21 +170,21 @@ function c32encode(inputHex) {
   return [...prefix, ...stripped].join("");
 }
 function c32decode(c32input) {
-  c32input = c32normalize(c32input);
-  if (!c32input.match(`^[${C32}]*$`))
+  const input = c32normalize(c32input);
+  if (!input.match(`^[${C32}]*$`))
     throw new Error("Not a c32-encoded string");
-  const zeroPrefix = c32input.match(`^${C32[0]}*`);
-  const numLeadingZeroBytes = zeroPrefix ? zeroPrefix[0].length : 0;
+  const zeroPrefix = input.match(`^${C32[0]}*`);
+  const numLeadingZeroBytes = zeroPrefix ? zeroPrefix[0]?.length : 0;
   const res = [];
   let carry = 0;
   let carryBits = 0;
-  for (let i = c32input.length - 1;i >= 0; i--) {
+  for (let i = input.length - 1;i >= 0; i--) {
     if (carryBits === 4) {
       res.unshift(HEX[carry]);
       carryBits = 0;
       carry = 0;
     }
-    const currentValue = (C32.indexOf(c32input[i]) << carryBits) + carry;
+    const currentValue = (C32.indexOf(input[i]) << carryBits) + carry;
     res.unshift(HEX[currentValue % 16]);
     carryBits += 1;
     carry = currentValue >> 4;
@@ -209,19 +210,19 @@ function c32checkEncode(version, data) {
     throw new Error("Invalid version (must be between 0 and 31)");
   if (!data.match(/^[0-9a-fA-F]*$/))
     throw new Error("Invalid data (not a hex string)");
-  data = data.toLowerCase();
-  if (data.length % 2 !== 0)
-    data = `0${data}`;
+  let d = data.toLowerCase();
+  if (d.length % 2 !== 0)
+    d = `0${d}`;
   let versionHex = version.toString(16);
   if (versionHex.length === 1)
     versionHex = `0${versionHex}`;
-  const checksumHex = c32checksum(`${versionHex}${data}`);
-  return `${C32[version]}${c32encode(`${data}${checksumHex}`)}`;
+  const checksumHex = c32checksum(`${versionHex}${d}`);
+  return `${C32[version]}${c32encode(`${d}${checksumHex}`)}`;
 }
 function c32checkDecode(c32data) {
-  c32data = c32normalize(c32data);
-  const dataHex = c32decode(c32data.slice(1));
-  const version = C32.indexOf(c32data[0]);
+  const normalized = c32normalize(c32data);
+  const dataHex = c32decode(normalized.slice(1));
+  const version = C32.indexOf(normalized[0]);
   const checksum = dataHex.slice(-8);
   let versionHex = version.toString(16);
   if (versionHex.length === 1)
@@ -346,7 +347,7 @@ function serializeCVBytes(value) {
       return withTypeId(value.type, concatBytes(writeUInt32BE(strBytes.length), strBytes));
     }
     default:
-      throw new Error(`Cannot serialize unknown clarity type`);
+      throw new Error("Cannot serialize unknown clarity type");
   }
 }
 
@@ -453,12 +454,11 @@ function serializeSpendingCondition(condition) {
 }
 function serializeAuthField(field) {
   if (field.type === "publicKey") {
-    const typeId = field.pubKeyEncoding === 0 ? 0 : 1;
-    return concatBytes(writeUInt8(typeId), hexToBytes(field.data));
-  } else {
-    const typeId = field.pubKeyEncoding === 0 ? 2 : 3;
-    return concatBytes(writeUInt8(typeId), hexToBytes(field.data));
+    const typeId2 = field.pubKeyEncoding === 0 ? 0 : 1;
+    return concatBytes(writeUInt8(typeId2), hexToBytes(field.data));
   }
+  const typeId = field.pubKeyEncoding === 0 ? 2 : 3;
+  return concatBytes(writeUInt8(typeId), hexToBytes(field.data));
 }
 function serializeAuthorization(auth) {
   const parts = [writeUInt8(auth.authType)];
@@ -592,7 +592,7 @@ async function estimateFee(client, params) {
     method: "POST",
     body: {
       estimated_len: Math.ceil(txHex.length / 2),
-      transaction_payload: "0x" + payloadHex
+      transaction_payload: `0x${payloadHex}`
     }
   });
   return (data.estimations ?? []).map((e) => ({
@@ -694,12 +694,13 @@ var MAX_U128 = BigInt("0xffffffffffffffffffffffffffffffff");
 var MIN_I128 = BigInt("-170141183460469231731687303715884105728");
 var MAX_I128 = BigInt("0x7fffffffffffffffffffffffffffffff");
 function intCV(value) {
-  if (typeof value === "string" && value.toLowerCase().startsWith("0x")) {
-    value = bytesToTwosBigInt(hexToBytes(value));
+  let v = value;
+  if (typeof v === "string" && v.toLowerCase().startsWith("0x")) {
+    v = bytesToTwosBigInt(hexToBytes(v));
   }
-  if (value instanceof Uint8Array)
-    value = bytesToTwosBigInt(value);
-  const n = intToBigInt(value);
+  if (v instanceof Uint8Array)
+    v = bytesToTwosBigInt(v);
+  const n = intToBigInt(v);
   if (n > MAX_I128)
     throw new RangeError(`Int exceeds max i128: ${MAX_I128}`);
   if (n < MIN_I128)
@@ -1081,7 +1082,8 @@ function hashP2PKH(input) {
 // src/transactions/authorization.ts
 etc.hmacSha256Sync = (key, ...msgs) => {
   const h = hmac.create(sha2563, key);
-  msgs.forEach((msg) => h.update(msg));
+  for (const msg of msgs)
+    h.update(msg);
   return h.digest();
 };
 var EMPTY_SIG = bytesToHex(new Uint8Array(RECOVERABLE_ECDSA_SIG_LENGTH_BYTES));
@@ -2017,9 +2019,6 @@ async function simulateTransaction(client, params) {
 // src/errors/websocket.ts
 class WebSocketError extends BaseError {
   name = "WebSocketError";
-  constructor(message, options) {
-    super(message, options);
-  }
 }
 
 // src/subscriptions/actions.ts
@@ -2431,5 +2430,5 @@ export {
   bnsResolve
 };
 
-//# debugId=233963F854D70C5B64756E2164756E21
+//# debugId=D11981BB65E0A0F464756E2164756E21
 //# sourceMappingURL=index.js.map