@secondlayer/stacks 6.1.0 → 6.1.1

package/dist/src/stackingdao/index.cjs

@@ -19,13 +19,15 @@ var __toESM = (mod, isNodeMode, target) => {
       return cached;
   }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: __accessProp.bind(mod, key),
-        enumerable: true
-      });
+  const to = isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  if (mod && typeof mod === "object" || typeof mod === "function") {
+    for (let key of __getOwnPropNames(mod))
+      if (!__hasOwnProp.call(to, key))
+        __defProp(to, key, {
+          get: __accessProp.bind(mod, key),
+          enumerable: true
+        });
+  }
   if (canCache)
     cache.set(mod, to);
   return to;
@@ -61,16 +63,19 @@ var __export = (target, all) => {
     });
 };
 
-// src/postconditions/index.ts
-var exports_postconditions = {};
-__export(exports_postconditions, {
-  wireToPostCondition: () => wireToPostCondition,
-  postConditionToHex: () => postConditionToHex,
-  parsePostConditionAmount: () => parsePostConditionAmount,
-  fromHex: () => fromHex,
-  Pc: () => Pc
+// src/stackingdao/index.ts
+var exports_stackingdao = {};
+__export(exports_stackingdao, {
+  STACKINGDAO_CONTRACTS: () => STACKINGDAO_CONTRACTS,
+  TRAIT_CONTRACTS: () => TRAIT_CONTRACTS,
+  stackingDao: () => stackingDao
 });
-module.exports = __toCommonJS(exports_postconditions);
+module.exports = __toCommonJS(exports_stackingdao);
+
+// src/clarity/abi/utils.ts
+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/c32.ts
 var import_sha2 = require("@noble/hashes/sha2.js");
@@ -403,103 +408,86 @@ function getContractAddress(deployer, contractName) {
   }
   return `${deployer}.${contractName}`;
 }
-
-// src/transactions/types.ts
-var AuthType = {
-  Standard: 4,
-  Sponsored: 5
-};
-var PayloadType = {
-  TokenTransfer: 0,
-  SmartContract: 1,
-  ContractCall: 2,
-  PoisonMicroblock: 3,
-  Coinbase: 4,
-  CoinbaseToAltRecipient: 5,
-  VersionedSmartContract: 6,
-  TenureChange: 7,
-  NakamotoCoinbase: 8
-};
-var ClarityVersion = {
-  Clarity1: 1,
-  Clarity2: 2,
-  Clarity3: 3,
-  Clarity4: 4,
-  Clarity5: 5,
-  Clarity6: 6
-};
-var AnchorMode = {
-  OnChainOnly: 1,
-  OffChainOnly: 2,
-  Any: 3
-};
-var PostConditionModeWire = {
-  Allow: 1,
-  Deny: 2,
-  Originator: 3
-};
-var AddressHashMode = {
-  P2PKH: 0,
-  P2SH: 1,
-  P2WPKH: 2,
-  P2WSH: 3,
-  P2SH_NonSequential: 5,
-  P2WSH_P2SH_NonSequential: 7
-};
-var PubKeyEncoding = {
-  Compressed: 0,
-  Uncompressed: 1
-};
-var FungibleConditionCode = {
-  Equal: 1,
-  Greater: 2,
-  GreaterEqual: 3,
-  Less: 4,
-  LessEqual: 5
-};
-var NonFungibleConditionCode = {
-  Sends: 16,
-  DoesNotSend: 17,
-  MaybeSent: 18
-};
-var PoxConditionCode = {
-  WillNotPerform: 48,
-  MayPerform: 49,
-  WillPerform: 50
-};
-var PostConditionPrincipalId = {
-  Origin: 1,
-  Standard: 2,
-  Contract: 3
-};
-var AssetType = {
-  STX: 0,
-  Fungible: 1,
-  NonFungible: 2,
-  Staking: 3,
-  Pox: 4
-};
-var AuthFieldType = {
-  PublicKeyCompressed: 0,
-  PublicKeyUncompressed: 1,
-  SignatureCompressed: 2,
-  SignatureUncompressed: 3
-};
-var RECOVERABLE_ECDSA_SIG_LENGTH_BYTES = 65;
-var MEMO_MAX_LENGTH_BYTES = 34;
-var MAX_STRING_LENGTH_BYTES = 128;
-var COINBASE_BYTES_LENGTH = 32;
-var VRF_PROOF_BYTES_LENGTH = 80;
-var MICROBLOCK_HEADER_BYTES_LENGTH = 132;
-var TenureChangeCause = {
-  BlockFound: 0,
-  Extended: 1,
-  ExtendedRuntime: 2,
-  ExtendedReadCount: 3,
-  ExtendedReadLength: 4,
-  ExtendedWriteCount: 5,
-  ExtendedWriteLength: 6
-};
+// src/clarity/abi/guards.ts
+function isUint128(value) {
+  return typeof value === "bigint" && value >= 0n && value <= MAX_U128;
+}
+function isInt128(value) {
+  return typeof value === "bigint" && value >= MIN_I128 && value <= MAX_I128;
+}
+function isBool(value) {
+  return typeof value === "boolean";
+}
+function isPrincipal(value) {
+  return typeof value === "string" && parsePrincipal(value) !== null;
+}
+function isStandardPrincipal(value) {
+  if (typeof value !== "string")
+    return false;
+  const parsed = parsePrincipal(value);
+  return parsed !== null && parsed.contractName === undefined;
+}
+function isContractPrincipal(value) {
+  if (typeof value !== "string")
+    return false;
+  const parsed = parsePrincipal(value);
+  return parsed !== null && parsed.contractName !== undefined;
+}
+function isTraitReference(value) {
+  return isContractPrincipal(value);
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isUint8Array(value) {
+  return value instanceof Uint8Array;
+}
+function isArray(value, itemGuard) {
+  return Array.isArray(value) && value.every(itemGuard);
+}
+function isOptional(value, guard) {
+  return value === null || guard(value);
+}
+function isOkResponse(response) {
+  return "ok" in response && !("err" in response);
+}
+function isErrResponse(response) {
+  return "err" in response && !("ok" in response);
+}
+function isResponse(value, okGuard, errGuard) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const obj = value;
+  if ("ok" in value && !("err" in value))
+    return okGuard(obj.ok);
+  if ("err" in value && !("ok" in value))
+    return errGuard(obj.err);
+  return false;
+}
+function isAbiList(type) {
+  return typeof type === "object" && type !== null && "list" in type;
+}
+function isAbiTuple(type) {
+  return typeof type === "object" && type !== null && "tuple" in type;
+}
+function isAbiOptional(type) {
+  return typeof type === "object" && type !== null && "optional" in type;
+}
+function isAbiResponse(type) {
+  return typeof type === "object" && type !== null && "response" in type;
+}
+function isAbiBuffer(type) {
+  return typeof type === "object" && type !== null && "buff" in type;
+}
+function isAbiStringAscii(type) {
+  return typeof type === "object" && type !== null && "string-ascii" in type;
+}
+function isAbiStringUtf8(type) {
+  return typeof type === "object" && type !== null && "string-utf8" in type;
+}
+function isAbiTraitReference(type) {
+  return type === "trait_reference";
+}
 
 // src/errors/base.ts
 function codeFromName(name) {
@@ -663,45 +651,139 @@ function clarityTypeFromByte(byte) {
   return type;
 }
 
-// src/clarity/serialize.ts
-var CLARITY_INT_SIZE = 128n;
-var CLARITY_INT_BYTE_SIZE = 16;
-function typeIdByte(type) {
-  return ClarityWireType[type];
-}
-function withTypeId(type, bytes) {
-  return concatBytes(new Uint8Array([typeIdByte(type)]), bytes);
+// src/clarity/deserialize.ts
+function readAddress(reader) {
+  const version = reader.readUInt8();
+  const hash160 = bytesToHex(reader.readBytes(20));
+  return c32address(version, hash160);
 }
-function serializeAddress(c32Address) {
-  const [version, hash1602] = c32addressDecode(c32Address);
-  return concatBytes(new Uint8Array([version]), hexToBytes(hash1602));
+function readLPString(reader, prefixBytes = 1) {
+  let length = 0;
+  for (let i = 0;i < prefixBytes; i++) {
+    length = length << 8 | reader.readUInt8();
+  }
+  return bytesToUtf8(reader.readBytes(length));
 }
-function serializeLPString(str, prefixBytes = 1) {
-  const content = utf8ToBytes(str);
-  const lengthPrefix = hexToBytes(intToHex(content.byteLength, prefixBytes));
-  return concatBytes(lengthPrefix, content);
+var MAX_CV_DEPTH = 64;
+var MIN_LIST_ITEM_BYTES = 1;
+var MIN_TUPLE_ENTRY_BYTES = 2;
+function checkCount(reader, count, minBytes) {
+  if (count * minBytes > reader.remaining()) {
+    throw new SerializationError(`Clarity value declares ${count} elements but only ${reader.remaining()} bytes remain`);
+  }
 }
-function serializeCVBytes(value) {
-  switch (value.type) {
+function readCV(reader, depth = 0) {
+  if (depth > MAX_CV_DEPTH) {
+    throw new SerializationError(`Clarity value nests deeper than ${MAX_CV_DEPTH} levels`);
+  }
+  const typeByte = reader.readUInt8();
+  const type = clarityTypeFromByte(typeByte);
+  switch (type) {
+    case "int":
+      return intCV(bytesToTwosBigInt(reader.readBytes(16)));
+    case "uint":
+      return uintCV(reader.readBytes(16));
     case "true":
+      return trueCV();
     case "false":
-      return new Uint8Array([typeIdByte(value.type)]);
-    case "int": {
-      const bytes = bigIntToBytes(toTwos(BigInt(value.value), CLARITY_INT_SIZE), CLARITY_INT_BYTE_SIZE);
-      return withTypeId(value.type, bytes);
-    }
-    case "uint": {
-      const bytes = bigIntToBytes(BigInt(value.value), CLARITY_INT_BYTE_SIZE);
-      return withTypeId(value.type, bytes);
-    }
+      return falseCV();
     case "buffer": {
-      const bufBytes = hexToBytes(value.value);
-      return withTypeId(value.type, concatBytes(writeUInt32BE(bufBytes.length), bufBytes));
+      const len = reader.readUInt32BE();
+      return bufferCV(reader.readBytes(len));
     }
     case "none":
-      return new Uint8Array([typeIdByte(value.type)]);
+      return noneCV();
     case "some":
-      return withTypeId(value.type, serializeCVBytes(value.value));
+      return someCV(readCV(reader, depth + 1));
+    case "ok":
+      return responseOkCV(readCV(reader, depth + 1));
+    case "err":
+      return responseErrorCV(readCV(reader, depth + 1));
+    case "address":
+      return standardPrincipalCV(readAddress(reader));
+    case "contract": {
+      const addr = readAddress(reader);
+      const name = readLPString(reader);
+      return contractPrincipalCV(addr, name);
+    }
+    case "list": {
+      const len = reader.readUInt32BE();
+      checkCount(reader, len, MIN_LIST_ITEM_BYTES);
+      const items = [];
+      for (let i = 0;i < len; i++) {
+        items.push(readCV(reader, depth + 1));
+      }
+      return listCV(items);
+    }
+    case "tuple": {
+      const len = reader.readUInt32BE();
+      checkCount(reader, len, MIN_TUPLE_ENTRY_BYTES);
+      const data = {};
+      for (let i = 0;i < len; i++) {
+        const key = readLPString(reader);
+        data[key] = readCV(reader, depth + 1);
+      }
+      return tupleCV(data);
+    }
+    case "ascii": {
+      const len = reader.readUInt32BE();
+      return stringAsciiCV(bytesToAscii(reader.readBytes(len)));
+    }
+    case "utf8": {
+      const len = reader.readUInt32BE();
+      return stringUtf8CV(bytesToUtf8(reader.readBytes(len)));
+    }
+    default:
+      throw new SerializationError(`Cannot deserialize unknown clarity type: ${type}`);
+  }
+}
+function deserializeCVBytes(input) {
+  const bytes = typeof input === "string" ? hexToBytes(without0x(input)) : input;
+  return readCV(new BytesReader(bytes));
+}
+function deserializeCV(input) {
+  return deserializeCVBytes(input);
+}
+
+// src/clarity/serialize.ts
+var CLARITY_INT_SIZE = 128n;
+var CLARITY_INT_BYTE_SIZE = 16;
+function typeIdByte(type) {
+  return ClarityWireType[type];
+}
+function withTypeId(type, bytes) {
+  return concatBytes(new Uint8Array([typeIdByte(type)]), bytes);
+}
+function serializeAddress(c32Address) {
+  const [version, hash160] = c32addressDecode(c32Address);
+  return concatBytes(new Uint8Array([version]), hexToBytes(hash160));
+}
+function serializeLPString(str, prefixBytes = 1) {
+  const content = utf8ToBytes(str);
+  const lengthPrefix = hexToBytes(intToHex(content.byteLength, prefixBytes));
+  return concatBytes(lengthPrefix, content);
+}
+function serializeCVBytes(value) {
+  switch (value.type) {
+    case "true":
+    case "false":
+      return new Uint8Array([typeIdByte(value.type)]);
+    case "int": {
+      const bytes = bigIntToBytes(toTwos(BigInt(value.value), CLARITY_INT_SIZE), CLARITY_INT_BYTE_SIZE);
+      return withTypeId(value.type, bytes);
+    }
+    case "uint": {
+      const bytes = bigIntToBytes(BigInt(value.value), CLARITY_INT_BYTE_SIZE);
+      return withTypeId(value.type, bytes);
+    }
+    case "buffer": {
+      const bufBytes = hexToBytes(value.value);
+      return withTypeId(value.type, concatBytes(writeUInt32BE(bufBytes.length), bufBytes));
+    }
+    case "none":
+      return new Uint8Array([typeIdByte(value.type)]);
+    case "some":
+      return withTypeId(value.type, serializeCVBytes(value.value));
     case "ok":
     case "err":
       return withTypeId(value.type, serializeCVBytes(value.value));
@@ -781,13 +863,13 @@ function bufferCV(buffer) {
   return { type: "buffer", value: bytesToHex(buffer) };
 }
 function standardPrincipalCV(address) {
-  const [version, hash1602] = c32addressDecode(address);
-  const normalized = c32address(version, hash1602);
+  const [version, hash160] = c32addressDecode(address);
+  const normalized = c32address(version, hash160);
   return { type: "address", value: normalized };
 }
 function contractPrincipalCV(address, contractName) {
-  const [version, hash1602] = c32addressDecode(address);
-  const normalized = c32address(version, hash1602);
+  const [version, hash160] = c32addressDecode(address);
+  const normalized = c32address(version, hash160);
   if (utf8ToBytes(contractName).byteLength >= 128) {
     throw new Error("Contract name must be less than 128 bytes");
   }
@@ -855,102 +937,284 @@ var Cl = {
   deserialize: deserializeCVBytes
 };
 
-// src/clarity/deserialize.ts
-function readAddress(reader) {
-  const version = reader.readUInt8();
-  const hash1602 = bytesToHex(reader.readBytes(20));
-  return c32address(version, hash1602);
+// 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;
 }
-function readLPString(reader, prefixBytes = 1) {
-  let length = 0;
-  for (let i = 0;i < prefixBytes; i++) {
-    length = length << 8 | reader.readUInt8();
+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)}`);
   }
-  return bytesToUtf8(reader.readBytes(length));
-}
-var MAX_CV_DEPTH = 64;
-var MIN_LIST_ITEM_BYTES = 1;
-var MIN_TUPLE_ENTRY_BYTES = 2;
-function checkCount(reader, count, minBytes) {
-  if (count * minBytes > reader.remaining()) {
-    throw new SerializationError(`Clarity value declares ${count} elements but only ${reader.remaining()} bytes remain`);
+  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 readCV(reader, depth = 0) {
-  if (depth > MAX_CV_DEPTH) {
-    throw new SerializationError(`Clarity value nests deeper than ${MAX_CV_DEPTH} levels`);
+function jsToClarityValue(abiType, value) {
+  if (isAbiBuffer(abiType))
+    return coerceBuffer(value);
+  if (isClarityValue(value))
+    return value;
+  if (abiType === "uint128")
+    return uintCV(value);
+  if (abiType === "int128")
+    return intCV(value);
+  if (abiType === "bool")
+    return boolCV(value);
+  if (abiType === "principal" || abiType === "trait_reference")
+    return Cl.principal(value);
+  if (isAbiStringAscii(abiType))
+    return stringAsciiCV(value);
+  if (isAbiStringUtf8(abiType))
+    return stringUtf8CV(value);
+  if (isAbiList(abiType)) {
+    const arr = value;
+    return listCV(arr.map((item) => jsToClarityValue(abiType.list.type, item)));
   }
-  const typeByte = reader.readUInt8();
-  const type = clarityTypeFromByte(typeByte);
-  switch (type) {
-    case "int":
-      return intCV(bytesToTwosBigInt(reader.readBytes(16)));
-    case "uint":
-      return uintCV(reader.readBytes(16));
-    case "true":
-      return trueCV();
-    case "false":
-      return falseCV();
-    case "buffer": {
-      const len = reader.readUInt32BE();
-      return bufferCV(reader.readBytes(len));
-    }
-    case "none":
-      return noneCV();
-    case "some":
-      return someCV(readCV(reader, depth + 1));
-    case "ok":
-      return responseOkCV(readCV(reader, depth + 1));
-    case "err":
-      return responseErrorCV(readCV(reader, depth + 1));
-    case "address":
-      return standardPrincipalCV(readAddress(reader));
-    case "contract": {
-      const addr = readAddress(reader);
-      const name = readLPString(reader);
-      return contractPrincipalCV(addr, name);
-    }
-    case "list": {
-      const len = reader.readUInt32BE();
-      checkCount(reader, len, MIN_LIST_ITEM_BYTES);
-      const items = [];
-      for (let i = 0;i < len; i++) {
-        items.push(readCV(reader, depth + 1));
-      }
-      return listCV(items);
-    }
-    case "tuple": {
-      const len = reader.readUInt32BE();
-      checkCount(reader, len, MIN_TUPLE_ENTRY_BYTES);
-      const data = {};
-      for (let i = 0;i < len; i++) {
-        const key = readLPString(reader);
-        data[key] = readCV(reader, depth + 1);
+  if (isAbiTuple(abiType)) {
+    const obj = value;
+    const data = {};
+    for (const field of abiType.tuple) {
+      const camelKey = toCamelCase(field.name);
+      const hasOriginal = field.name in obj;
+      const hasCamel = camelKey in obj;
+      const fieldValue = hasOriginal ? obj[field.name] : hasCamel ? obj[camelKey] : undefined;
+      if (fieldValue === undefined && !isAbiOptional(field.type)) {
+        throw new Error(`Missing tuple field: ${field.name}`);
       }
-      return tupleCV(data);
-    }
-    case "ascii": {
-      const len = reader.readUInt32BE();
-      return stringAsciiCV(bytesToAscii(reader.readBytes(len)));
-    }
-    case "utf8": {
-      const len = reader.readUInt32BE();
-      return stringUtf8CV(bytesToUtf8(reader.readBytes(len)));
+      data[field.name] = jsToClarityValue(field.type, fieldValue);
     }
-    default:
-      throw new SerializationError(`Cannot deserialize unknown clarity type: ${type}`);
+    return tupleCV(data);
   }
-}
-function deserializeCVBytes(input) {
-  const bytes = typeof input === "string" ? hexToBytes(without0x(input)) : input;
-  return readCV(new BytesReader(bytes));
-}
-function deserializeCV(input) {
-  return deserializeCVBytes(input);
-}
-
-// src/transactions/wire/deserialize.ts
-function readSpendingCondition(r) {
+  if (isAbiOptional(abiType)) {
+    if (value === null || value === undefined)
+      return noneCV();
+    return someCV(jsToClarityValue(abiType.optional, value));
+  }
+  if (isAbiResponse(abiType)) {
+    const obj = value;
+    if ("ok" in obj && !("err" in obj))
+      return responseOkCV(jsToClarityValue(abiType.response.ok, obj.ok));
+    if ("err" in obj && !("ok" in obj))
+      return responseErrorCV(jsToClarityValue(abiType.response.error, obj.err));
+    throw new Error("Response must have exactly 'ok' or 'err' property");
+  }
+  throw new Error(`Unknown ABI type: ${JSON.stringify(abiType)}`);
+}
+function clarityValueToJS(abiType, cv) {
+  return clarityValueToJSInner(abiType, cv);
+}
+function clarityValueToJSUntyped(abiType, cv) {
+  return clarityValueToJSInner(abiType, cv);
+}
+function clarityValueToJSInner(abiType, cv) {
+  if (abiType === "uint128" || abiType === "int128") {
+    if (cv.type !== "int" && cv.type !== "uint")
+      throw new Error(`Expected int/uint CV, got ${cv.type}`);
+    return cv.value;
+  }
+  if (abiType === "bool") {
+    if (cv.type === "true")
+      return true;
+    if (cv.type === "false")
+      return false;
+    throw new Error(`Expected bool CV, got ${cv.type}`);
+  }
+  if (abiType === "principal" || abiType === "trait_reference") {
+    if (cv.type !== "address" && cv.type !== "contract")
+      throw new Error(`Expected principal CV, got ${cv.type}`);
+    return cv.value;
+  }
+  if (isAbiStringAscii(abiType) || isAbiStringUtf8(abiType)) {
+    if (cv.type !== "ascii" && cv.type !== "utf8")
+      throw new Error(`Expected string CV, got ${cv.type}`);
+    return cv.value;
+  }
+  if (isAbiBuffer(abiType)) {
+    if (cv.type !== "buffer")
+      throw new Error(`Expected buffer CV, got ${cv.type}`);
+    const hex = cv.value;
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0;i < bytes.length; i++) {
+      bytes[i] = Number.parseInt(hex.substring(i * 2, i * 2 + 2), 16);
+    }
+    return bytes;
+  }
+  if (isAbiList(abiType)) {
+    if (cv.type !== "list")
+      throw new Error(`Expected list CV, got ${cv.type}`);
+    return cv.value.map((item) => clarityValueToJSInner(abiType.list.type, item));
+  }
+  if (isAbiTuple(abiType)) {
+    if (cv.type !== "tuple")
+      throw new Error(`Expected tuple CV, got ${cv.type}`);
+    const result = {};
+    for (const field of abiType.tuple) {
+      const fieldCV = cv.value[field.name];
+      if (!fieldCV)
+        throw new Error(`Missing tuple field in CV: ${field.name}`);
+      const camelKey = toCamelCase(field.name);
+      result[camelKey] = clarityValueToJSInner(field.type, fieldCV);
+    }
+    return result;
+  }
+  if (isAbiOptional(abiType)) {
+    if (cv.type === "none")
+      return null;
+    if (cv.type === "some")
+      return clarityValueToJSInner(abiType.optional, cv.value);
+    throw new Error(`Expected optional CV, got ${cv.type}`);
+  }
+  if (isAbiResponse(abiType)) {
+    if (cv.type === "ok")
+      return { ok: clarityValueToJSInner(abiType.response.ok, cv.value) };
+    if (cv.type === "err")
+      return { err: clarityValueToJSInner(abiType.response.error, cv.value) };
+    throw new Error(`Expected response CV, got ${cv.type}`);
+  }
+  throw new Error(`Unknown ABI type: ${JSON.stringify(abiType)}`);
+}
+
+// src/transactions/types.ts
+var AuthType = {
+  Standard: 4,
+  Sponsored: 5
+};
+var PayloadType = {
+  TokenTransfer: 0,
+  SmartContract: 1,
+  ContractCall: 2,
+  PoisonMicroblock: 3,
+  Coinbase: 4,
+  CoinbaseToAltRecipient: 5,
+  VersionedSmartContract: 6,
+  TenureChange: 7,
+  NakamotoCoinbase: 8
+};
+var ClarityVersion = {
+  Clarity1: 1,
+  Clarity2: 2,
+  Clarity3: 3,
+  Clarity4: 4,
+  Clarity5: 5,
+  Clarity6: 6
+};
+var AnchorMode = {
+  OnChainOnly: 1,
+  OffChainOnly: 2,
+  Any: 3
+};
+var PostConditionModeWire = {
+  Allow: 1,
+  Deny: 2,
+  Originator: 3
+};
+var AddressHashMode = {
+  P2PKH: 0,
+  P2SH: 1,
+  P2WPKH: 2,
+  P2WSH: 3,
+  P2SH_NonSequential: 5,
+  P2WSH_P2SH_NonSequential: 7
+};
+var PubKeyEncoding = {
+  Compressed: 0,
+  Uncompressed: 1
+};
+var FungibleConditionCode = {
+  Equal: 1,
+  Greater: 2,
+  GreaterEqual: 3,
+  Less: 4,
+  LessEqual: 5
+};
+var NonFungibleConditionCode = {
+  Sends: 16,
+  DoesNotSend: 17,
+  MaybeSent: 18
+};
+var PoxConditionCode = {
+  WillNotPerform: 48,
+  MayPerform: 49,
+  WillPerform: 50
+};
+var PostConditionPrincipalId = {
+  Origin: 1,
+  Standard: 2,
+  Contract: 3
+};
+var AssetType = {
+  STX: 0,
+  Fungible: 1,
+  NonFungible: 2,
+  Staking: 3,
+  Pox: 4
+};
+var AuthFieldType = {
+  PublicKeyCompressed: 0,
+  PublicKeyUncompressed: 1,
+  SignatureCompressed: 2,
+  SignatureUncompressed: 3
+};
+var RECOVERABLE_ECDSA_SIG_LENGTH_BYTES = 65;
+var MEMO_MAX_LENGTH_BYTES = 34;
+var MAX_STRING_LENGTH_BYTES = 128;
+var COINBASE_BYTES_LENGTH = 32;
+var VRF_PROOF_BYTES_LENGTH = 80;
+var MICROBLOCK_HEADER_BYTES_LENGTH = 132;
+var TenureChangeCause = {
+  BlockFound: 0,
+  Extended: 1,
+  ExtendedRuntime: 2,
+  ExtendedReadCount: 3,
+  ExtendedReadLength: 4,
+  ExtendedWriteCount: 5,
+  ExtendedWriteLength: 6
+};
+
+// src/transactions/wire/deserialize.ts
+function readSpendingCondition(r) {
   const hashMode = r.readUInt8();
   const signer = bytesToHex(r.readBytes(20));
   const nonce = r.readBigUInt64BE();
@@ -1216,8 +1480,8 @@ function deserializeTransaction(input, meta) {
 
 // src/transactions/wire/serialize.ts
 function serializeAddress2(c32Address) {
-  const [version, hash1602] = c32addressDecode(c32Address);
-  return concatBytes(new Uint8Array([version]), hexToBytes(hash1602));
+  const [version, hash160] = c32addressDecode(c32Address);
+  return concatBytes(new Uint8Array([version]), hexToBytes(hash160));
 }
 function serializeLPString2(str, prefixBytes = 1) {
   const content = utf8ToBytes(str);
@@ -1256,8 +1520,8 @@ function serializeSpendingCondition(condition) {
 }
 function serializeAuthField(field) {
   if (field.type === "publicKey") {
-    const typeId2 = field.pubKeyEncoding === 0 ? 0 : 1;
-    return concatBytes(writeUInt8(typeId2), hexToBytes(field.data));
+    const typeId = field.pubKeyEncoding === 0 ? 0 : 1;
+    return concatBytes(writeUInt8(typeId), hexToBytes(field.data));
   }
   const typeId = field.pubKeyEncoding === 0 ? 2 : 3;
   return concatBytes(writeUInt8(typeId), hexToBytes(field.data));
@@ -1544,456 +1808,41 @@ function wireToPostCondition(wire) {
     case "staking":
       return {
         type: "staking-postcondition",
-        address: principalToString(wire.principal),
-        condition: fungibleName(wire.conditionCode),
-        amount: wire.amount.toString()
-      };
-    case "pox":
-      return {
-        type: "pox-postcondition",
-        address: principalToString(wire.principal),
-        condition: poxName(wire.conditionCode)
-      };
-  }
-}
-function fungibleName(code) {
-  const name = FUNGIBLE_CODE_REVERSE[code];
-  if (!name)
-    throw new Error(`Unknown fungible post-condition code: ${code}`);
-  return name;
-}
-function nftName(code) {
-  const name = NFT_CODE_REVERSE[code];
-  if (!name)
-    throw new Error(`Unknown nft post-condition code: ${code}`);
-  return name;
-}
-function poxName(code) {
-  const name = POX_CODE_REVERSE[code];
-  if (!name)
-    throw new Error(`Unknown pox post-condition code: ${code}`);
-  return name;
-}
-function fromHex(hex) {
-  return wireToPostCondition(deserializePostConditionWire(hex));
-}
-function postConditionToHex(pc) {
-  return bytesToHex(serializePostConditionWire(convertPostCondition(pc)));
-}
-
-// src/postconditions/builder.ts
-class PartialPcWithPrincipal {
-  address;
-  constructor(address) {
-    this.address = address;
-  }
-  willSendEq(amount) {
-    return new PartialPcFtWithCode(this.address, amount, "eq");
-  }
-  willSendGte(amount) {
-    return new PartialPcFtWithCode(this.address, amount, "gte");
-  }
-  willSendGt(amount) {
-    return new PartialPcFtWithCode(this.address, amount, "gt");
-  }
-  willSendLte(amount) {
-    return new PartialPcFtWithCode(this.address, amount, "lte");
-  }
-  willSendLt(amount) {
-    return new PartialPcFtWithCode(this.address, amount, "lt");
-  }
-  willSendAsset() {
-    return new PartialPcNftWithCode(this.address, "sent");
-  }
-  willNotSendAsset() {
-    return new PartialPcNftWithCode(this.address, "not-sent");
-  }
-  willMaybeSendAsset() {
-    return new PartialPcNftWithCode(this.address, "maybe-sent");
-  }
-  willPerformPox() {
-    return {
-      type: "pox-postcondition",
-      address: this.address,
-      condition: "will-perform"
-    };
-  }
-  willNotPerformPox() {
-    return {
-      type: "pox-postcondition",
-      address: this.address,
-      condition: "will-not-perform"
-    };
-  }
-  mayPerformPox() {
-    return {
-      type: "pox-postcondition",
-      address: this.address,
-      condition: "may-perform"
-    };
-  }
-}
-
-class PartialPcFtWithCode {
-  address;
-  amount;
-  code;
-  constructor(address, amount, code) {
-    this.address = address;
-    this.amount = amount;
-    this.code = code;
-  }
-  ustx() {
-    return {
-      type: "stx-postcondition",
-      address: this.address,
-      condition: this.code,
-      amount: parsePostConditionAmount(this.amount).toString()
-    };
-  }
-  ustxToLock() {
-    return {
-      type: "staking-postcondition",
-      address: this.address,
-      condition: this.code,
-      amount: parsePostConditionAmount(this.amount).toString()
-    };
-  }
-  ft(contractId, tokenName) {
-    const [address, name] = contractId.split(".");
-    if (!address || !validateStacksAddress(address) || !name) {
-      throw new Error(`Invalid contract id: ${contractId}`);
-    }
-    return {
-      type: "ft-postcondition",
-      address: this.address,
-      condition: this.code,
-      amount: parsePostConditionAmount(this.amount).toString(),
-      asset: `${contractId}::${tokenName}`
-    };
-  }
-}
-
-class PartialPcNftWithCode {
-  address;
-  code;
-  constructor(address, code) {
-    this.address = address;
-    this.code = code;
-  }
-  nft(assetOrContractId, tokenNameOrAssetId, assetId) {
-    let contractAddress;
-    let contractName;
-    let tokenName;
-    let id;
-    if (assetId !== undefined) {
-      [contractAddress, contractName] = parseContractId(assetOrContractId);
-      tokenName = tokenNameOrAssetId;
-      id = assetId;
-    } else {
-      const [principal, tName] = assetOrContractId.split("::");
-      if (!principal || !tName)
-        throw new Error(`Invalid asset name: ${assetOrContractId}`);
-      [contractAddress, contractName] = parseContractId(principal);
-      tokenName = tName;
-      id = tokenNameOrAssetId;
-    }
-    if (!validateStacksAddress(contractAddress)) {
-      throw new Error(`Invalid contract address: ${contractAddress}`);
-    }
-    return {
-      type: "nft-postcondition",
-      address: this.address,
-      condition: this.code,
-      asset: `${contractAddress}.${contractName}::${tokenName}`,
-      assetId: id
-    };
-  }
-}
-var Pc = {
-  principal(address) {
-    const [addr, name] = address.split(".");
-    if (!addr || !validateStacksAddress(addr) || typeof name === "string" && !name) {
-      throw new Error(`Invalid principal: ${address}`);
-    }
-    return new PartialPcWithPrincipal(address);
-  },
-  origin() {
-    return new PartialPcWithPrincipal("origin");
-  },
-  fromHex: (hex) => fromHex(hex)
-};
-// src/stackingdao/index.ts
-var exports_stackingdao = {};
-__export(exports_stackingdao, {
-  stackingDao: () => stackingDao,
-  TRAIT_CONTRACTS: () => TRAIT_CONTRACTS,
-  STACKINGDAO_CONTRACTS: () => STACKINGDAO_CONTRACTS
-});
-module.exports = __toCommonJS(exports_stackingdao);
-
-// src/clarity/abi/utils.ts
-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/clarity/abi/guards.ts
-function isUint128(value) {
-  return typeof value === "bigint" && value >= 0n && value <= MAX_U128;
-}
-function isInt128(value) {
-  return typeof value === "bigint" && value >= MIN_I128 && value <= MAX_I128;
-}
-function isBool(value) {
-  return typeof value === "boolean";
-}
-function isPrincipal(value) {
-  return typeof value === "string" && parsePrincipal(value) !== null;
-}
-function isStandardPrincipal(value) {
-  if (typeof value !== "string")
-    return false;
-  const parsed = parsePrincipal(value);
-  return parsed !== null && parsed.contractName === undefined;
-}
-function isContractPrincipal(value) {
-  if (typeof value !== "string")
-    return false;
-  const parsed = parsePrincipal(value);
-  return parsed !== null && parsed.contractName !== undefined;
-}
-function isTraitReference(value) {
-  return isContractPrincipal(value);
-}
-function isString(value) {
-  return typeof value === "string";
-}
-function isUint8Array(value) {
-  return value instanceof Uint8Array;
-}
-function isArray(value, itemGuard) {
-  return Array.isArray(value) && value.every(itemGuard);
-}
-function isOptional(value, guard) {
-  return value === null || guard(value);
-}
-function isOkResponse(response) {
-  return "ok" in response && !("err" in response);
-}
-function isErrResponse(response) {
-  return "err" in response && !("ok" in response);
-}
-function isResponse(value, okGuard, errGuard) {
-  if (typeof value !== "object" || value === null)
-    return false;
-  const obj = value;
-  if ("ok" in value && !("err" in value))
-    return okGuard(obj.ok);
-  if ("err" in value && !("ok" in value))
-    return errGuard(obj.err);
-  return false;
-}
-function isAbiList(type) {
-  return typeof type === "object" && type !== null && "list" in type;
-}
-function isAbiTuple(type) {
-  return typeof type === "object" && type !== null && "tuple" in type;
-}
-function isAbiOptional(type) {
-  return typeof type === "object" && type !== null && "optional" in type;
-}
-function isAbiResponse(type) {
-  return typeof type === "object" && type !== null && "response" in type;
-}
-function isAbiBuffer(type) {
-  return typeof type === "object" && type !== null && "buff" in type;
-}
-function isAbiStringAscii(type) {
-  return typeof type === "object" && type !== null && "string-ascii" in type;
-}
-function isAbiStringUtf8(type) {
-  return typeof type === "object" && type !== null && "string-utf8" in type;
-}
-function isAbiTraitReference(type) {
-  return type === "trait_reference";
-}
-
-// 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")
-    return intCV(value);
-  if (abiType === "bool")
-    return boolCV(value);
-  if (abiType === "principal" || abiType === "trait_reference")
-    return Cl.principal(value);
-  if (isAbiStringAscii(abiType))
-    return stringAsciiCV(value);
-  if (isAbiStringUtf8(abiType))
-    return stringUtf8CV(value);
-  if (isAbiList(abiType)) {
-    const arr = value;
-    return listCV(arr.map((item) => jsToClarityValue(abiType.list.type, item)));
-  }
-  if (isAbiTuple(abiType)) {
-    const obj = value;
-    const data = {};
-    for (const field of abiType.tuple) {
-      const camelKey = toCamelCase(field.name);
-      const hasOriginal = field.name in obj;
-      const hasCamel = camelKey in obj;
-      const fieldValue = hasOriginal ? obj[field.name] : hasCamel ? obj[camelKey] : undefined;
-      if (fieldValue === undefined && !isAbiOptional(field.type)) {
-        throw new Error(`Missing tuple field: ${field.name}`);
-      }
-      data[field.name] = jsToClarityValue(field.type, fieldValue);
-    }
-    return tupleCV(data);
-  }
-  if (isAbiOptional(abiType)) {
-    if (value === null || value === undefined)
-      return noneCV();
-    return someCV(jsToClarityValue(abiType.optional, value));
-  }
-  if (isAbiResponse(abiType)) {
-    const obj = value;
-    if ("ok" in obj && !("err" in obj))
-      return responseOkCV(jsToClarityValue(abiType.response.ok, obj.ok));
-    if ("err" in obj && !("ok" in obj))
-      return responseErrorCV(jsToClarityValue(abiType.response.error, obj.err));
-    throw new Error("Response must have exactly 'ok' or 'err' property");
+        address: principalToString(wire.principal),
+        condition: fungibleName(wire.conditionCode),
+        amount: wire.amount.toString()
+      };
+    case "pox":
+      return {
+        type: "pox-postcondition",
+        address: principalToString(wire.principal),
+        condition: poxName(wire.conditionCode)
+      };
   }
-  throw new Error(`Unknown ABI type: ${JSON.stringify(abiType)}`);
 }
-function clarityValueToJS(abiType, cv) {
-  return clarityValueToJSInner(abiType, cv);
+function fungibleName(code) {
+  const name = FUNGIBLE_CODE_REVERSE[code];
+  if (!name)
+    throw new Error(`Unknown fungible post-condition code: ${code}`);
+  return name;
 }
-function clarityValueToJSUntyped(abiType, cv) {
-  return clarityValueToJSInner(abiType, cv);
+function nftName(code) {
+  const name = NFT_CODE_REVERSE[code];
+  if (!name)
+    throw new Error(`Unknown nft post-condition code: ${code}`);
+  return name;
 }
-function clarityValueToJSInner(abiType, cv) {
-  if (abiType === "uint128" || abiType === "int128") {
-    if (cv.type !== "int" && cv.type !== "uint")
-      throw new Error(`Expected int/uint CV, got ${cv.type}`);
-    return cv.value;
-  }
-  if (abiType === "bool") {
-    if (cv.type === "true")
-      return true;
-    if (cv.type === "false")
-      return false;
-    throw new Error(`Expected bool CV, got ${cv.type}`);
-  }
-  if (abiType === "principal" || abiType === "trait_reference") {
-    if (cv.type !== "address" && cv.type !== "contract")
-      throw new Error(`Expected principal CV, got ${cv.type}`);
-    return cv.value;
-  }
-  if (isAbiStringAscii(abiType) || isAbiStringUtf8(abiType)) {
-    if (cv.type !== "ascii" && cv.type !== "utf8")
-      throw new Error(`Expected string CV, got ${cv.type}`);
-    return cv.value;
-  }
-  if (isAbiBuffer(abiType)) {
-    if (cv.type !== "buffer")
-      throw new Error(`Expected buffer CV, got ${cv.type}`);
-    const hex = cv.value;
-    const bytes = new Uint8Array(hex.length / 2);
-    for (let i = 0;i < bytes.length; i++) {
-      bytes[i] = Number.parseInt(hex.substring(i * 2, i * 2 + 2), 16);
-    }
-    return bytes;
-  }
-  if (isAbiList(abiType)) {
-    if (cv.type !== "list")
-      throw new Error(`Expected list CV, got ${cv.type}`);
-    return cv.value.map((item) => clarityValueToJSInner(abiType.list.type, item));
-  }
-  if (isAbiTuple(abiType)) {
-    if (cv.type !== "tuple")
-      throw new Error(`Expected tuple CV, got ${cv.type}`);
-    const result = {};
-    for (const field of abiType.tuple) {
-      const fieldCV = cv.value[field.name];
-      if (!fieldCV)
-        throw new Error(`Missing tuple field in CV: ${field.name}`);
-      const camelKey = toCamelCase(field.name);
-      result[camelKey] = clarityValueToJSInner(field.type, fieldCV);
-    }
-    return result;
-  }
-  if (isAbiOptional(abiType)) {
-    if (cv.type === "none")
-      return null;
-    if (cv.type === "some")
-      return clarityValueToJSInner(abiType.optional, cv.value);
-    throw new Error(`Expected optional CV, got ${cv.type}`);
-  }
-  if (isAbiResponse(abiType)) {
-    if (cv.type === "ok")
-      return { ok: clarityValueToJSInner(abiType.response.ok, cv.value) };
-    if (cv.type === "err")
-      return { err: clarityValueToJSInner(abiType.response.error, cv.value) };
-    throw new Error(`Expected response CV, got ${cv.type}`);
-  }
-  throw new Error(`Unknown ABI type: ${JSON.stringify(abiType)}`);
+function poxName(code) {
+  const name = POX_CODE_REVERSE[code];
+  if (!name)
+    throw new Error(`Unknown pox post-condition code: ${code}`);
+  return name;
+}
+function fromHex(hex) {
+  return wireToPostCondition(deserializePostConditionWire(hex));
+}
+function postConditionToHex(pc) {
+  return bytesToHex(serializePostConditionWire(convertPostCondition(pc)));
 }
 
 // src/transactions/authorization.ts
@@ -2142,11 +1991,11 @@ function replayMultiSigSigHash(tx) {
   const condition = tx.auth.spendingCondition;
   if (isNonSequential(condition.hashMode)) {
     const preSign = nonSequentialPreSignHash(tx);
-    let curSigHash2 = preSign;
+    let curSigHash = preSign;
     for (const field of condition.fields) {
-      curSigHash2 = sigHashPostSign(curSigHash2, field.pubKeyEncoding, field.data);
+      curSigHash = sigHashPostSign(curSigHash, field.pubKeyEncoding, field.data);
     }
-    return curSigHash2;
+    return curSigHash;
   }
   let curSigHash = initialSigHash(tx);
   for (const field of condition.fields) {
@@ -2267,8 +2116,8 @@ async function signSequentialWithAccount(tx, condition, account, publicKeys, sig
   const fields = [...condition.fields];
   let curSigHash = initialSigHash(tx);
   for (const field of fields) {
-    const preSign2 = sigHashPreSign(curSigHash, AuthType.Standard, condition.fee, condition.nonce);
-    curSigHash = sigHashPostSign(preSign2, field.pubKeyEncoding, field.data);
+    const preSign = sigHashPreSign(curSigHash, AuthType.Standard, condition.fee, condition.nonce);
+    curSigHash = sigHashPostSign(preSign, field.pubKeyEncoding, field.data);
   }
   for (let i = fields.length;i < signerIndex; i++) {
     const pubKeyField = {
@@ -2277,8 +2126,8 @@ async function signSequentialWithAccount(tx, condition, account, publicKeys, sig
       data: publicKeys[i]
     };
     fields.push(pubKeyField);
-    const preSign2 = sigHashPreSign(curSigHash, AuthType.Standard, condition.fee, condition.nonce);
-    curSigHash = sigHashPostSign(preSign2, pubKeyField.pubKeyEncoding, pubKeyField.data);
+    const preSign = sigHashPreSign(curSigHash, AuthType.Standard, condition.fee, condition.nonce);
+    curSigHash = sigHashPostSign(preSign, pubKeyField.pubKeyEncoding, pubKeyField.data);
   }
   const preSign = sigHashPreSign(curSigHash, AuthType.Standard, condition.fee, condition.nonce);
   const sigBytes = await account.sign(hexToBytes(preSign));
@@ -2572,9 +2421,9 @@ function getOriginSigHash(tx) {
   if ("fields" in condition) {
     return replayMultiSigSigHash(tx);
   }
-  const initialSigHash2 = signBegin(tx);
+  const initialSigHash = signBegin(tx);
   const sc = condition;
-  const preSign = sigHashPreSign(initialSigHash2, AuthType.Standard, sc.fee, sc.nonce);
+  const preSign = sigHashPreSign(initialSigHash, AuthType.Standard, sc.fee, sc.nonce);
   return sigHashPostSign(preSign, sc.keyEncoding, sc.signature);
 }
 function signSponsor(tx, privateKey) {
@@ -2878,8 +2727,8 @@ function indexNotFound(error, sourceName) {
   }
   return true;
 }
-function normalizeTxid(txid2) {
-  return txid2.startsWith("0x") ? txid2 : `0x${txid2}`;
+function normalizeTxid(txid) {
+  return txid.startsWith("0x") ? txid : `0x${txid}`;
 }
 function decodeResultHex(hex) {
   if (!hex)
@@ -2903,10 +2752,10 @@ function normalizeStatus(txStatus) {
 }
 function extendedApiSource() {
   return {
-    async get({ client, txid: txid2 }) {
+    async get({ client, txid }) {
       let data;
       try {
-        data = await client.request(`/extended/v1/tx/${encodeURIComponent(normalizeTxid(txid2))}`, { method: "GET" });
+        data = await client.request(`/extended/v1/tx/${encodeURIComponent(normalizeTxid(txid))}`, { method: "GET" });
       } catch (error) {
         if (error instanceof HttpRequestError && error.status === 404) {
           return { receipt: null };
@@ -2921,7 +2770,7 @@ function extendedApiSource() {
         return { receipt: null };
       return {
         receipt: {
-          txid: normalizeTxid(txid2),
+          txid: normalizeTxid(txid),
           status,
           blockHeight: typeof data.block_height === "number" && data.block_height > 0 ? data.block_height : undefined,
           blockHash: data.block_hash ?? undefined,
@@ -2937,11 +2786,11 @@ function indexTxSource(params = {}) {
   const headers = params.apiKey ? { authorization: `Bearer ${params.apiKey}` } : undefined;
   return {
     canonicalOnly: true,
-    async get({ client, txid: txid2 }) {
+    async get({ client, txid }) {
       const request = indexRequestFn(client, params.baseUrl, "indexTxSource");
       let data;
       try {
-        data = await request(`/v1/index/transactions/${normalizeTxid(txid2)}`, {
+        data = await request(`/v1/index/transactions/${normalizeTxid(txid)}`, {
           method: "GET",
           headers
         });
@@ -2990,7 +2839,7 @@ async function getBlockHeight(client) {
 var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
 async function waitForTransactionReceipt(client, params) {
   const {
-    txid: txid2,
+    txid,
     confirmations = 1,
     timeout = 180000,
     pollingInterval = 3000
@@ -3001,21 +2850,21 @@ async function waitForTransactionReceipt(client, params) {
   let unknownSince = null;
   let everPending = false;
   while (true) {
-    const snapshot = await source.get({ client, txid: txid2 });
+    const snapshot = await source.get({ client, txid });
     const receipt = snapshot.receipt;
     if (receipt === null) {
       unknownSince ??= Date.now();
       if (Date.now() - unknownSince >= droppedGracePeriod) {
-        throw new TransactionDroppedError(everPending ? `Transaction ${txid2} left the mempool without being mined` : `Transaction ${txid2} was never observed by the status source`, { txid: txid2 });
+        throw new TransactionDroppedError(everPending ? `Transaction ${txid} left the mempool without being mined` : `Transaction ${txid} was never observed by the status source`, { txid });
       }
     } else {
       unknownSince = null;
       switch (receipt.status) {
         case "dropped":
-          throw new TransactionDroppedError(`Transaction ${txid2} was dropped from the mempool`, { txid: txid2 });
+          throw new TransactionDroppedError(`Transaction ${txid} was dropped from the mempool`, { txid });
         case "abort_by_response":
         case "abort_by_post_condition":
-          throw new TransactionAbortedError(`Transaction ${txid2} aborted (${receipt.status})`, { receipt });
+          throw new TransactionAbortedError(`Transaction ${txid} aborted (${receipt.status})`, { receipt });
         case "pending":
           everPending = true;
           break;
@@ -3032,7 +2881,7 @@ async function waitForTransactionReceipt(client, params) {
       }
     }
     if (Date.now() - startedAt >= timeout) {
-      throw new WaitForTransactionTimeoutError(`Timed out after ${timeout}ms waiting for transaction ${txid2}`, { txid: txid2 });
+      throw new WaitForTransactionTimeoutError(`Timed out after ${timeout}ms waiting for transaction ${txid}`, { txid });
     }
     await sleep2(pollingInterval);
   }
@@ -3060,11 +2909,11 @@ async function sendTransaction(client, params) {
         throw error;
       }
     } else if (error instanceof TimeoutError) {
-      const txid3 = getTransactionId(params.transaction);
-      const receipt = await getTransaction(client, { txid: txid3 }).catch(() => null);
+      const txid = getTransactionId(params.transaction);
+      const receipt = await getTransaction(client, { txid }).catch(() => null);
       if (receipt === null)
         throw error;
-      data = { txid: txid3 };
+      data = { txid };
     } else {
       throw error;
     }
@@ -3076,16 +2925,16 @@ async function sendTransaction(client, params) {
       txid: data.txid ?? getTransactionId(params.transaction)
     });
   }
-  const txid2 = typeof data === "string" ? data.replace(/"/g, "") : data.txid ?? getTransactionId(params.transaction);
+  const txid = typeof data === "string" ? data.replace(/"/g, "") : data.txid ?? getTransactionId(params.transaction);
   if (params.wait) {
     const confirmations = params.wait === true ? 1 : params.wait;
     const receipt = await waitForTransactionReceipt(client, {
-      txid: txid2,
+      txid,
       confirmations
     });
-    return { txid: txid2, receipt };
+    return { txid, receipt };
   }
-  return { txid: txid2 };
+  return { txid };
 }
 
 // src/actions/wallet/nonceManager.ts
@@ -3750,6 +3599,158 @@ var sip010Abi = SIP010_ABI;
 var sip009Abi = SIP009_ABI;
 var sip013Abi = SIP013_ABI;
 
+// src/postconditions/index.ts
+var exports_postconditions = {};
+__export(exports_postconditions, {
+  Pc: () => Pc,
+  fromHex: () => fromHex,
+  parsePostConditionAmount: () => parsePostConditionAmount,
+  postConditionToHex: () => postConditionToHex,
+  wireToPostCondition: () => wireToPostCondition
+});
+
+// src/postconditions/builder.ts
+class PartialPcWithPrincipal {
+  address;
+  constructor(address) {
+    this.address = address;
+  }
+  willSendEq(amount) {
+    return new PartialPcFtWithCode(this.address, amount, "eq");
+  }
+  willSendGte(amount) {
+    return new PartialPcFtWithCode(this.address, amount, "gte");
+  }
+  willSendGt(amount) {
+    return new PartialPcFtWithCode(this.address, amount, "gt");
+  }
+  willSendLte(amount) {
+    return new PartialPcFtWithCode(this.address, amount, "lte");
+  }
+  willSendLt(amount) {
+    return new PartialPcFtWithCode(this.address, amount, "lt");
+  }
+  willSendAsset() {
+    return new PartialPcNftWithCode(this.address, "sent");
+  }
+  willNotSendAsset() {
+    return new PartialPcNftWithCode(this.address, "not-sent");
+  }
+  willMaybeSendAsset() {
+    return new PartialPcNftWithCode(this.address, "maybe-sent");
+  }
+  willPerformPox() {
+    return {
+      type: "pox-postcondition",
+      address: this.address,
+      condition: "will-perform"
+    };
+  }
+  willNotPerformPox() {
+    return {
+      type: "pox-postcondition",
+      address: this.address,
+      condition: "will-not-perform"
+    };
+  }
+  mayPerformPox() {
+    return {
+      type: "pox-postcondition",
+      address: this.address,
+      condition: "may-perform"
+    };
+  }
+}
+
+class PartialPcFtWithCode {
+  address;
+  amount;
+  code;
+  constructor(address, amount, code) {
+    this.address = address;
+    this.amount = amount;
+    this.code = code;
+  }
+  ustx() {
+    return {
+      type: "stx-postcondition",
+      address: this.address,
+      condition: this.code,
+      amount: parsePostConditionAmount(this.amount).toString()
+    };
+  }
+  ustxToLock() {
+    return {
+      type: "staking-postcondition",
+      address: this.address,
+      condition: this.code,
+      amount: parsePostConditionAmount(this.amount).toString()
+    };
+  }
+  ft(contractId, tokenName) {
+    const [address, name] = contractId.split(".");
+    if (!address || !validateStacksAddress(address) || !name) {
+      throw new Error(`Invalid contract id: ${contractId}`);
+    }
+    return {
+      type: "ft-postcondition",
+      address: this.address,
+      condition: this.code,
+      amount: parsePostConditionAmount(this.amount).toString(),
+      asset: `${contractId}::${tokenName}`
+    };
+  }
+}
+
+class PartialPcNftWithCode {
+  address;
+  code;
+  constructor(address, code) {
+    this.address = address;
+    this.code = code;
+  }
+  nft(assetOrContractId, tokenNameOrAssetId, assetId) {
+    let contractAddress;
+    let contractName;
+    let tokenName;
+    let id;
+    if (assetId !== undefined) {
+      [contractAddress, contractName] = parseContractId(assetOrContractId);
+      tokenName = tokenNameOrAssetId;
+      id = assetId;
+    } else {
+      const [principal, tName] = assetOrContractId.split("::");
+      if (!principal || !tName)
+        throw new Error(`Invalid asset name: ${assetOrContractId}`);
+      [contractAddress, contractName] = parseContractId(principal);
+      tokenName = tName;
+      id = tokenNameOrAssetId;
+    }
+    if (!validateStacksAddress(contractAddress)) {
+      throw new Error(`Invalid contract address: ${contractAddress}`);
+    }
+    return {
+      type: "nft-postcondition",
+      address: this.address,
+      condition: this.code,
+      asset: `${contractAddress}.${contractName}::${tokenName}`,
+      assetId: id
+    };
+  }
+}
+var Pc = {
+  principal(address) {
+    const [addr, name] = address.split(".");
+    if (!addr || !validateStacksAddress(addr) || typeof name === "string" && !name) {
+      throw new Error(`Invalid principal: ${address}`);
+    }
+    return new PartialPcWithPrincipal(address);
+  },
+  origin() {
+    return new PartialPcWithPrincipal("origin");
+  },
+  fromHex: (hex) => fromHex(hex)
+};
 // src/stackingdao/abi.ts
 var withdrawTuple = {
   tuple: [
@@ -4064,5 +4065,5 @@ function stackingDao() {
   });
 }
 
-//# debugId=D75282D1D5DABE5F64756E2164756E21
+//# debugId=9C8528EDF2AF4E0964756E2164756E21
 //# sourceMappingURL=index.cjs.map