@secondlayer/stacks 6.5.4 → 6.6.1

package/dist/src/pox/index.js

@@ -1,26 +1,26 @@
-import"../../shared/stacks-esm-5eq7meyt.js";
-import"../../shared/stacks-esm-7tc40d6t.js";
-import"../../shared/stacks-esm-cs4419br.js";
-import"../../shared/stacks-esm-ev07d2aw.js";
-import"../../shared/stacks-esm-2cac1jn9.js";
-import"../../shared/stacks-esm-mmvrwreq.js";
+import"../../shared/stacks-esm-8p8xy3dz.js";
+import"../../shared/stacks-esm-h60faj2n.js";
+import"../../shared/stacks-esm-jwgtksgq.js";
+import"../../shared/stacks-esm-4rjjsz3p.js";
+import"../../shared/stacks-esm-2z40q8gs.js";
+import"../../shared/stacks-esm-wjg9aer9.js";
 import {
   Pc2
-} from "../../shared/stacks-esm-h82jj95c.js";
-import"../../shared/stacks-esm-tfechw5c.js";
+} from "../../shared/stacks-esm-9ptct1c4.js";
+import"../../shared/stacks-esm-nqkwt2z7.js";
 import {
   POX_CONTRACTS2,
   MIN_LOCK_PERIOD2,
   MAX_LOCK_PERIOD2,
   POX_ADDRESS_VERSION2,
   parseBtcAddress2
-} from "../../shared/stacks-esm-tsb8h0yr.js";
+} from "../../shared/stacks-esm-eep45e8s.js";
 import {
   getContract2,
   resolveNetworkContract
-} from "../../shared/stacks-esm-s3natb0x.js";
-import"../../shared/stacks-esm-jm688fhe.js";
-import"../../shared/stacks-esm-hm7kb2cp.js";
+} from "../../shared/stacks-esm-1f46cr7b.js";
+import"../../shared/stacks-esm-m8ph0bvw.js";
+import"../../shared/stacks-esm-mqhwqhq4.js";
 
 // src/pox/abi.ts
 var POX_ABI = {

package/dist/src/pox5/index.cjs

@@ -508,6 +508,8 @@ function bytesToHex(bytes) {
 }
 function hexToBytes(hex) {
   let h = without0x(hex);
+  if (!/^[0-9a-fA-F]*$/.test(h))
+    throw new Error("Invalid byte sequence");
   if (h.length % 2)
     h = `0${h}`;
   const array = new Uint8Array(h.length / 2);
@@ -539,6 +541,13 @@ function asciiToBytes(str) {
   }
   return bytes;
 }
+function isAscii(str) {
+  for (let i = 0;i < str.length; i++) {
+    if (str.charCodeAt(i) > 127)
+      return false;
+  }
+  return true;
+}
 function bytesToAscii(bytes) {
   return String.fromCharCode(...bytes);
 }
@@ -557,8 +566,11 @@ function concatBytes(...arrays) {
 function intToBigInt(value) {
   if (typeof value === "bigint")
     return value;
-  if (typeof value === "string")
+  if (typeof value === "string") {
+    if (value.trim() === "")
+      throw new SyntaxError("Cannot convert an empty string to an integer");
     return BigInt(value);
+  }
   if (typeof value === "number") {
     if (!Number.isInteger(value))
       throw new RangeError("Values of type 'number' must be an integer.");
@@ -899,6 +911,10 @@ function getContractAddress(deployer, contractName) {
 // src/clarity/serialize.ts
 var CLARITY_INT_SIZE = 128n;
 var CLARITY_INT_BYTE_SIZE = 16;
+var MAX_U1282 = (1n << 128n) - 1n;
+var MAX_I1282 = (1n << 127n) - 1n;
+var MIN_I1282 = -(1n << 127n);
+var MAX_STRING_BYTES = 1048576;
 function typeIdByte(type) {
   return ClarityWireType[type];
 }
@@ -920,11 +936,17 @@ function serializeCVBytes(value) {
     case "false":
       return new Uint8Array([typeIdByte(value.type)]);
     case "int": {
-      const bytes = bigIntToBytes(toTwos(BigInt(value.value), CLARITY_INT_SIZE), CLARITY_INT_BYTE_SIZE);
+      const n = BigInt(value.value);
+      if (n > MAX_I1282 || n < MIN_I1282)
+        throw new RangeError(`Int is outside i128: ${n}`);
+      const bytes = bigIntToBytes(toTwos(n, CLARITY_INT_SIZE), CLARITY_INT_BYTE_SIZE);
       return withTypeId(value.type, bytes);
     }
     case "uint": {
-      const bytes = bigIntToBytes(BigInt(value.value), CLARITY_INT_BYTE_SIZE);
+      const n = BigInt(value.value);
+      if (n < 0n || n > MAX_U1282)
+        throw new RangeError(`UInt is outside u128: ${n}`);
+      const bytes = bigIntToBytes(n, CLARITY_INT_BYTE_SIZE);
       return withTypeId(value.type, bytes);
     }
     case "buffer": {
@@ -963,6 +985,8 @@ function serializeCVBytes(value) {
       return withTypeId(value.type, concatBytes(...parts));
     }
     case "ascii": {
+      if (!isAscii(value.value))
+        throw new Error("string-ascii holds only ASCII characters");
       const strBytes = asciiToBytes(value.value);
       return withTypeId(value.type, concatBytes(writeUInt32BE(strBytes.length), strBytes));
     }
@@ -979,9 +1003,9 @@ function serializeCV(value) {
 }
 
 // src/clarity/values.ts
-var MAX_U1282 = BigInt("0xffffffffffffffffffffffffffffffff");
-var MIN_I1282 = BigInt("-170141183460469231731687303715884105728");
-var MAX_I1282 = BigInt("0x7fffffffffffffffffffffffffffffff");
+var MAX_U1283 = BigInt("0xffffffffffffffffffffffffffffffff");
+var MIN_I1283 = BigInt("-170141183460469231731687303715884105728");
+var MAX_I1283 = BigInt("0x7fffffffffffffffffffffffffffffff");
 function intCV(value) {
   let v = value;
   if (typeof v === "string" && v.toLowerCase().startsWith("0x")) {
@@ -990,18 +1014,18 @@ function intCV(value) {
   if (v instanceof Uint8Array)
     v = bytesToTwosBigInt(v);
   const n = intToBigInt(v);
-  if (n > MAX_I1282)
-    throw new RangeError(`Int exceeds max i128: ${MAX_I1282}`);
-  if (n < MIN_I1282)
-    throw new RangeError(`Int below min i128: ${MIN_I1282}`);
+  if (n > MAX_I1283)
+    throw new RangeError(`Int exceeds max i128: ${MAX_I1283}`);
+  if (n < MIN_I1283)
+    throw new RangeError(`Int below min i128: ${MIN_I1283}`);
   return { type: "int", value: n };
 }
 function uintCV(value) {
   const n = intToBigInt(value);
   if (n < 0n)
     throw new RangeError("Cannot construct unsigned int from negative value");
-  if (n > MAX_U1282)
-    throw new RangeError(`UInt exceeds max u128: ${MAX_U1282}`);
+  if (n > MAX_U1283)
+    throw new RangeError(`UInt exceeds max u128: ${MAX_U1283}`);
   return { type: "uint", value: n };
 }
 var trueCV = () => ({ type: "true" });
@@ -1050,6 +1074,10 @@ function tupleCV(data) {
   return { type: "tuple", value: data };
 }
 function stringAsciiCV(value) {
+  if (!isAscii(value))
+    throw new Error("string-ascii holds only ASCII characters");
+  if (value.length > MAX_STRING_BYTES)
+    throw new Error(`string-ascii exceeds max size of ${MAX_STRING_BYTES} bytes`);
   return { type: "ascii", value };
 }
 function stringUtf8CV(value) {
@@ -3503,6 +3531,13 @@ function assertNoFeeTierForProvider(fee) {
     throw new Error(`Fee tier '${fee}' requires local signing; provider (wallet) accounts set their own fee`);
   }
 }
+function resolveCallArgs(params) {
+  const { args, functionArgs } = params;
+  if (args !== undefined && functionArgs !== undefined) {
+    throw new Error("Pass args or functionArgs, not both (functionArgs is deprecated)");
+  }
+  return args ?? functionArgs ?? [];
+}
 
 // src/actions/wallet/callContract.ts
 async function callContract(client, params) {
@@ -3510,12 +3545,13 @@ async function callContract(client, params) {
   if (!account)
     throw new Error("Account required");
   const [contractAddress, contractName] = parseContractId(params.contract);
+  const args = resolveCallArgs(params);
   if (isProviderAccount(account)) {
     assertNoFeeTierForProvider(params.fee);
     const result = await account.provider.request("stx_callContract", {
       contract: params.contract,
       functionName: params.functionName,
-      functionArgs: params.functionArgs ?? []
+      functionArgs: args
     });
     return result.txid;
   }
@@ -3527,7 +3563,7 @@ async function callContract(client, params) {
       contractAddress,
       contractName,
       functionName: params.functionName,
-      functionArgs: params.functionArgs ?? [],
+      functionArgs: args,
       fee: needsFeeResolution ? 0n : params.fee,
       nonce,
       publicKey: account.publicKey,
@@ -3609,7 +3645,7 @@ function getContract(params) {
         return callContract(client, {
           contract: contractId,
           functionName: fn.name,
-          functionArgs: clarityArgs,
+          args: clarityArgs,
           ...options
         });
       };
@@ -6166,5 +6202,5 @@ function parseSignerCalldata(calldata) {
   };
 }
 
-//# debugId=0C3339AEA1AAF38B64756E2164756E21
+//# debugId=E525360E2DA4A64764756E2164756E21
 //# sourceMappingURL=index.cjs.map