@secondlayer/stacks 2.9.1 → 2.11.0

package/dist/src/tools/index.js

@@ -399,6 +399,11 @@ var NonFungibleConditionCode = {
   Sends: 16,
   DoesNotSend: 17
 };
+var PoxConditionCode = {
+  WillNotPerform: 48,
+  MayPerform: 49,
+  WillPerform: 50
+};
 var PostConditionPrincipalId = {
   Origin: 1,
   Standard: 2,
@@ -407,7 +412,9 @@ var PostConditionPrincipalId = {
 var AssetType = {
   STX: 0,
   Fungible: 1,
-  NonFungible: 2
+  NonFungible: 2,
+  Staking: 3,
+  Pox: 4
 };
 var RECOVERABLE_ECDSA_SIG_LENGTH_BYTES = 65;
 var MEMO_MAX_LENGTH_BYTES = 34;
@@ -504,6 +511,17 @@ function serializePostCondition(pc) {
       parts.push(serializeCVBytes(pc.assetId));
       parts.push(writeUInt8(pc.conditionCode));
       break;
+    case "staking":
+      parts.push(writeUInt8(AssetType.Staking));
+      parts.push(serializePrincipal(pc.principal));
+      parts.push(writeUInt8(pc.conditionCode));
+      parts.push(intToBytes(pc.amount, 8));
+      break;
+    case "pox":
+      parts.push(writeUInt8(AssetType.Pox));
+      parts.push(serializePrincipal(pc.principal));
+      parts.push(writeUInt8(pc.conditionCode));
+      break;
   }
   return concatBytes(...parts);
 }
@@ -677,7 +695,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
+import { ripemd160 } from "@noble/hashes/legacy.js";
+import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
+import { sha512_256 } from "@noble/hashes/sha2.js";
+function hash160(input) {
+  return ripemd160(sha2562(input));
+}
+function txidFromBytes(data) {
+  return bytesToHex(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)
@@ -690,9 +738,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")) {
@@ -701,18 +749,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" });
@@ -725,13 +773,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");
   }
@@ -802,8 +850,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;
@@ -900,11 +948,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;
@@ -929,7 +972,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")
@@ -942,8 +1042,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)));
@@ -1049,37 +1147,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
 import { hmac } from "@noble/hashes/hmac.js";
 import { sha256 as sha2563 } from "@noble/hashes/sha2.js";
 import { etc, getPublicKey as nobleGetPublicKey, sign } from "@noble/secp256k1";
-
-// src/utils/hash.ts
-import { ripemd160 } from "@noble/hashes/legacy.js";
-import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
-import { sha512_256 } from "@noble/hashes/sha2.js";
-function hash160(input) {
-  return ripemd160(sha2562(input));
-}
-function txidFromBytes(data) {
-  return bytesToHex(sha512_256(data));
-}
-function hashP2PKH(input) {
-  return bytesToHex(hash160(input));
-}
-
-// src/transactions/authorization.ts
 etc.hmacSha256Sync = (key, ...msgs) => {
   const h = hmac.create(sha2563, key);
   for (const msg of msgs)
@@ -1234,8 +1305,26 @@ function convertPostCondition(pc) {
         assetId: pc.assetId
       };
     }
+    case "staking-postcondition":
+      return {
+        type: "staking",
+        principal: resolvePrincipal(pc.address),
+        conditionCode: FUNGIBLE_CODE_MAP[pc.condition],
+        amount: intToBigInt(pc.amount)
+      };
+    case "pox-postcondition":
+      return {
+        type: "pox",
+        principal: resolvePrincipal(pc.address),
+        conditionCode: POX_CODE_MAP[pc.condition]
+      };
   }
 }
+var POX_CODE_MAP = {
+  "will-not-perform": PoxConditionCode.WillNotPerform,
+  "may-perform": PoxConditionCode.MayPerform,
+  "will-perform": PoxConditionCode.WillPerform
+};
 function resolveSpendingCondition(opts, nonce, fee) {
   if (opts.publicKeys) {
     return createMultiSigSpendingCondition(opts.publicKeys, opts.signaturesRequired, nonce, fee, opts.hashMode);
@@ -1276,6 +1365,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));
@@ -1514,6 +1614,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;
@@ -1536,7 +1676,13 @@ function getContract(params) {
       };
     }
   });
-  return { read, call, maps };
+  return { read, call, buildCall, maps };
+}
+function resolveNetworkContract(client, contracts) {
+  if (!client.chain) {
+    throw new Error("Client must have a chain configured");
+  }
+  return contracts[client.chain.network];
 }
 function buildFunctionArgs(fn, args) {
   return fn.args.map((arg) => {
@@ -2058,11 +2204,7 @@ function validateFQN(fqn) {
 
 // src/bns/actions.ts
 function getBnsContract(client) {
-  if (!client.chain) {
-    throw new Error("Client must have a chain configured");
-  }
-  const network = client.chain.network;
-  const contract = network === "mainnet" ? BNS_CONTRACTS.mainnet : BNS_CONTRACTS.testnet;
+  const contract = resolveNetworkContract(client, BNS_CONTRACTS);
   return getContract({
     client,
     address: contract.address,
@@ -2719,5 +2861,5 @@ export {
   bnsResolve
 };
 
-//# debugId=0D764C03DAFF717D64756E2164756E21
+//# debugId=4D62EAB4ED52294064756E2164756E21
 //# sourceMappingURL=index.js.map