@secondlayer/stacks 2.10.0 → 2.11.0

package/dist/src/tools/index.cjs

@@ -748,7 +748,37 @@ class BytesReader {
   }
 }
 
+// src/utils/constants.ts
+var MAX_U128 = (1n << 128n) - 1n;
+var MAX_I128 = (1n << 127n) - 1n;
+var MIN_I128 = -(1n << 127n);
+var AddressVersion = {
+  MainnetSingleSig: 22,
+  MainnetMultiSig: 20,
+  TestnetSingleSig: 26,
+  TestnetMultiSig: 21
+};
+
+// src/utils/hash.ts
+var import_legacy = require("@noble/hashes/legacy.js");
+var import_sha22 = require("@noble/hashes/sha2.js");
+var import_sha23 = require("@noble/hashes/sha2.js");
+function hash160(input) {
+  return import_legacy.ripemd160(import_sha22.sha256(input));
+}
+function txidFromBytes(data) {
+  return bytesToHex(import_sha23.sha512_256(data));
+}
+function hashP2PKH(input) {
+  return bytesToHex(hash160(input));
+}
+
 // src/utils/address.ts
+function publicKeyToAddress(publicKey, network = "mainnet") {
+  const bytes = typeof publicKey === "string" ? hexToBytes(without0x(publicKey)) : publicKey;
+  const version = network === "mainnet" ? AddressVersion.MainnetSingleSig : AddressVersion.TestnetSingleSig;
+  return c32address(version, bytesToHex(hash160(bytes)));
+}
 function parseContractId(contractId) {
   const [address, name] = contractId.split(".");
   if (!address || !name)
@@ -761,9 +791,9 @@ function isClarityName(name) {
 }
 
 // src/clarity/values.ts
-var MAX_U128 = BigInt("0xffffffffffffffffffffffffffffffff");
-var MIN_I128 = BigInt("-170141183460469231731687303715884105728");
-var MAX_I128 = BigInt("0x7fffffffffffffffffffffffffffffff");
+var MAX_U1282 = BigInt("0xffffffffffffffffffffffffffffffff");
+var MIN_I1282 = BigInt("-170141183460469231731687303715884105728");
+var MAX_I1282 = BigInt("0x7fffffffffffffffffffffffffffffff");
 function intCV(value) {
   let v = value;
   if (typeof v === "string" && v.toLowerCase().startsWith("0x")) {
@@ -772,18 +802,18 @@ function intCV(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)
-    throw new RangeError(`Int below min i128: ${MIN_I128}`);
+  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}`);
   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_U128)
-    throw new RangeError(`UInt exceeds max u128: ${MAX_U128}`);
+  if (n > MAX_U1282)
+    throw new RangeError(`UInt exceeds max u128: ${MAX_U1282}`);
   return { type: "uint", value: n };
 }
 var trueCV = () => ({ type: "true" });
@@ -796,13 +826,13 @@ function bufferCV(buffer) {
   return { type: "buffer", value: bytesToHex(buffer) };
 }
 function standardPrincipalCV(address) {
-  const [version, hash160] = c32addressDecode(address);
-  const normalized = c32address(version, hash160);
+  const [version, hash1602] = c32addressDecode(address);
+  const normalized = c32address(version, hash1602);
   return { type: "address", value: normalized };
 }
 function contractPrincipalCV(address, contractName) {
-  const [version, hash160] = c32addressDecode(address);
-  const normalized = c32address(version, hash160);
+  const [version, hash1602] = c32addressDecode(address);
+  const normalized = c32address(version, hash1602);
   if (utf8ToBytes(contractName).byteLength >= 128) {
     throw new Error("Contract name must be less than 128 bytes");
   }
@@ -873,8 +903,8 @@ var Cl = {
 // src/clarity/deserialize.ts
 function readAddress(reader) {
   const version = reader.readUInt8();
-  const hash160 = bytesToHex(reader.readBytes(20));
-  return c32address(version, hash160);
+  const hash1602 = bytesToHex(reader.readBytes(20));
+  return c32address(version, hash1602);
 }
 function readLPString(reader, prefixBytes = 1) {
   let length = 0;
@@ -971,11 +1001,6 @@ function toCamelCase(str) {
   return str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase()).replace(/-([A-Z])/g, (_, letter) => letter).replace(/-(\d)/g, (_, digit) => digit).replace(/-/g, "").replace(/^\d/, "_$&");
 }
 
-// src/utils/constants.ts
-var MAX_U1282 = (1n << 128n) - 1n;
-var MAX_I1282 = (1n << 127n) - 1n;
-var MIN_I1282 = -(1n << 127n);
-
 // src/clarity/abi/guards.ts
 function isAbiList(type) {
   return typeof type === "object" && type !== null && "list" in type;
@@ -1000,7 +1025,64 @@ function isAbiStringUtf8(type) {
 }
 
 // src/clarity/bridge.ts
+var CV_TYPE_TAGS = new Set([
+  "int",
+  "uint",
+  "true",
+  "false",
+  "address",
+  "contract",
+  "ascii",
+  "utf8",
+  "buffer",
+  "list",
+  "tuple",
+  "none",
+  "some",
+  "ok",
+  "err"
+]);
+function isClarityValue(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const type = value.type;
+  if (typeof type !== "string" || !CV_TYPE_TAGS.has(type))
+    return false;
+  if (type === "true" || type === "false" || type === "none")
+    return true;
+  return "value" in value;
+}
+var HEX_PAIRS_REGEX = /^(?:[0-9a-fA-F]{2})+$/;
+function coerceBuffer(value) {
+  if (value instanceof Uint8Array)
+    return bufferCV(value);
+  if (typeof value === "object" && value !== null && "type" in value) {
+    const tagged = value;
+    if (tagged.type === "buffer" && isClarityValue(value))
+      return value;
+    if (typeof tagged.value === "string") {
+      if (tagged.type === "ascii")
+        return Cl.bufferFromAscii(tagged.value);
+      if (tagged.type === "utf8")
+        return Cl.bufferFromUtf8(tagged.value);
+      if (tagged.type === "hex")
+        return Cl.bufferFromHex(tagged.value);
+    }
+    throw new Error(`Unsupported buffer input: ${JSON.stringify(value)}`);
+  }
+  if (typeof value === "string") {
+    const hex = value.startsWith("0x") ? value.slice(2) : value;
+    if (HEX_PAIRS_REGEX.test(hex))
+      return Cl.bufferFromHex(hex);
+    return Cl.bufferFromUtf8(value);
+  }
+  throw new Error("buffer arg expects Uint8Array, hex string, { type, value }, or BufferCV");
+}
 function jsToClarityValue(abiType, value) {
+  if (isAbiBuffer(abiType))
+    return coerceBuffer(value);
+  if (isClarityValue(value))
+    return value;
   if (abiType === "uint128")
     return uintCV(value);
   if (abiType === "int128")
@@ -1013,8 +1095,6 @@ function jsToClarityValue(abiType, value) {
     return stringAsciiCV(value);
   if (isAbiStringUtf8(abiType))
     return stringUtf8CV(value);
-  if (isAbiBuffer(abiType))
-    return bufferCV(value);
   if (isAbiList(abiType)) {
     const arr = value;
     return listCV(arr.map((item) => jsToClarityValue(abiType.list.type, item)));
@@ -1120,37 +1200,10 @@ function clarityValueToJSInner(abiType, cv) {
   throw new Error(`Unknown ABI type: ${JSON.stringify(abiType)}`);
 }
 
-// src/actions/public/getMapEntry.ts
-async function getMapEntry(client, params) {
-  const [address, name] = parseContractId(params.contract);
-  const serializedKey = with0x(bytesToHex(serializeCVBytes(params.key)));
-  const data = await client.request(`/v2/map_entry/${address}/${name}/${params.mapName}`, {
-    method: "POST",
-    body: serializedKey
-  });
-  return deserializeCVBytes(data.data);
-}
-
 // src/transactions/authorization.ts
 var import_hmac = require("@noble/hashes/hmac.js");
 var import_sha24 = require("@noble/hashes/sha2.js");
 var import_secp256k1 = require("@noble/secp256k1");
-
-// src/utils/hash.ts
-var import_legacy = require("@noble/hashes/legacy.js");
-var import_sha22 = require("@noble/hashes/sha2.js");
-var import_sha23 = require("@noble/hashes/sha2.js");
-function hash160(input) {
-  return import_legacy.ripemd160(import_sha22.sha256(input));
-}
-function txidFromBytes(data) {
-  return bytesToHex(import_sha23.sha512_256(data));
-}
-function hashP2PKH(input) {
-  return bytesToHex(hash160(input));
-}
-
-// src/transactions/authorization.ts
 import_secp256k1.etc.hmacSha256Sync = (key, ...msgs) => {
   const h = import_hmac.hmac.create(import_sha24.sha256, key);
   for (const msg of msgs)
@@ -1362,6 +1415,17 @@ function buildContractCall(options) {
   return tx;
 }
 
+// src/actions/public/getMapEntry.ts
+async function getMapEntry(client, params) {
+  const [address, name] = parseContractId(params.contract);
+  const serializedKey = with0x(bytesToHex(serializeCVBytes(params.key)));
+  const data = await client.request(`/v2/map_entry/${address}/${name}/${params.mapName}`, {
+    method: "POST",
+    body: serializedKey
+  });
+  return deserializeCVBytes(data.data);
+}
+
 // src/transactions/signer.ts
 function txid(tx) {
   return txidFromBytes(serializeTransaction(tx));
@@ -1600,6 +1664,46 @@ function getContract(params) {
       };
     }
   });
+  const buildCall = new Proxy({}, {
+    get(_target, prop) {
+      const fnName = camelToKebab.get(prop) ?? prop;
+      const fn = fnByName.get(fnName);
+      if (!fn || fn.access !== "public")
+        return;
+      return async (args, options) => {
+        const publicKey = options?.publicKey ?? client.account?.publicKey;
+        if (!publicKey) {
+          throw new Error("buildCall requires a publicKey (pass options.publicKey or configure a client account)");
+        }
+        const functionArgs = buildFunctionArgs(fn, args);
+        const network = client.chain?.network ?? "mainnet";
+        const nonce = options?.nonce ?? await resolveNonce(client, publicKeyToAddress(publicKey, network));
+        const unsigned = buildContractCall({
+          contractAddress: address,
+          contractName,
+          functionName: fn.name,
+          functionArgs,
+          fee: options?.fee ?? 0n,
+          nonce,
+          publicKey,
+          chain: client.chain,
+          postConditionMode: options?.postConditionMode,
+          postConditions: options?.postConditions,
+          sponsored: options?.sponsored
+        });
+        if (options?.fee === undefined) {
+          const estimates = await estimateFee(client, {
+            transaction: unsigned
+          });
+          const mid = estimates[1] ?? estimates[0];
+          if (mid) {
+            unsigned.auth.spendingCondition.fee = BigInt(mid.fee);
+          }
+        }
+        return unsigned;
+      };
+    }
+  });
   const maps = new Proxy({}, {
     get(_target, prop) {
       const mapName = camelToKebab.get(prop) ?? prop;
@@ -1622,7 +1726,7 @@ function getContract(params) {
       };
     }
   });
-  return { read, call, maps };
+  return { read, call, buildCall, maps };
 }
 function resolveNetworkContract(client, contracts) {
   if (!client.chain) {
@@ -2792,5 +2896,5 @@ var getNftHoldings = import_ai.tool({
   execute: ({ principal, limit }) => nftHoldings(getDefaultPublicClient(), principal, limit)
 });
 
-//# debugId=F40D5D6D3BD59C9E64756E2164756E21
+//# debugId=47021AD178AA414364756E2164756E21
 //# sourceMappingURL=index.cjs.map