@secondlayer/stacks 6.0.0 → 6.1.1

package/dist/shared/{stacks-51ybf135.js → stacks-esm-phgy8yqf.js}

@@ -1,36 +1,36 @@
 import {
+  bytesToHex2,
+  hexToBytes2,
+  without0x2,
+  utf8ToBytes2,
+  asciiToBytes2,
+  bytesToAscii2,
+  concatBytes2,
+  intToBigInt2,
+  intToBytes2,
+  intToHex2,
+  writeUInt32BE2,
+  writeUInt16BE2,
+  writeUInt82,
+  c32addressDecode2
+} from "./stacks-esm-7a0ehykf.js";
+import {
+  serializeCVBytes2,
   BytesReader,
   readAddress,
-  readCV,
   readLPString,
-  serializeCVBytes
-} from "./stacks-69nq48jp.js";
-import {
-  parseContractId
-} from "./stacks-4d7c3x27.js";
+  readCV
+} from "./stacks-esm-hkw1kvd4.js";
 import {
-  asciiToBytes,
-  bytesToAscii,
-  bytesToHex,
-  c32addressDecode,
-  concatBytes,
-  hexToBytes,
-  intToBigInt,
-  intToBytes,
-  intToHex,
-  utf8ToBytes,
-  without0x,
-  writeUInt16BE,
-  writeUInt32BE,
-  writeUInt8
-} from "./stacks-qs5fzts5.js";
+  parseContractId2
+} from "./stacks-esm-kbz5s6v8.js";
 
 // src/transactions/types.ts
-var AuthType = {
+var AuthType2 = {
   Standard: 4,
   Sponsored: 5
 };
-var PayloadType = {
+var PayloadType2 = {
   TokenTransfer: 0,
   SmartContract: 1,
   ContractCall: 2,
@@ -41,7 +41,7 @@ var PayloadType = {
   TenureChange: 7,
   NakamotoCoinbase: 8
 };
-var ClarityVersion = {
+var ClarityVersion2 = {
   Clarity1: 1,
   Clarity2: 2,
   Clarity3: 3,
@@ -49,17 +49,17 @@ var ClarityVersion = {
   Clarity5: 5,
   Clarity6: 6
 };
-var AnchorMode = {
+var AnchorMode2 = {
   OnChainOnly: 1,
   OffChainOnly: 2,
   Any: 3
 };
-var PostConditionModeWire = {
+var PostConditionModeWire2 = {
   Allow: 1,
   Deny: 2,
   Originator: 3
 };
-var AddressHashMode = {
+var AddressHashMode2 = {
   P2PKH: 0,
   P2SH: 1,
   P2WPKH: 2,
@@ -67,52 +67,52 @@ var AddressHashMode = {
   P2SH_NonSequential: 5,
   P2WSH_P2SH_NonSequential: 7
 };
-var PubKeyEncoding = {
+var PubKeyEncoding2 = {
   Compressed: 0,
   Uncompressed: 1
 };
-var FungibleConditionCode = {
+var FungibleConditionCode2 = {
   Equal: 1,
   Greater: 2,
   GreaterEqual: 3,
   Less: 4,
   LessEqual: 5
 };
-var NonFungibleConditionCode = {
+var NonFungibleConditionCode2 = {
   Sends: 16,
   DoesNotSend: 17,
   MaybeSent: 18
 };
-var PoxConditionCode = {
+var PoxConditionCode2 = {
   WillNotPerform: 48,
   MayPerform: 49,
   WillPerform: 50
 };
-var PostConditionPrincipalId = {
+var PostConditionPrincipalId2 = {
   Origin: 1,
   Standard: 2,
   Contract: 3
 };
-var AssetType = {
+var AssetType2 = {
   STX: 0,
   Fungible: 1,
   NonFungible: 2,
   Staking: 3,
   Pox: 4
 };
-var AuthFieldType = {
+var AuthFieldType2 = {
   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 = {
+var RECOVERABLE_ECDSA_SIG_LENGTH_BYTES2 = 65;
+var MEMO_MAX_LENGTH_BYTES2 = 34;
+var MAX_STRING_LENGTH_BYTES2 = 128;
+var COINBASE_BYTES_LENGTH2 = 32;
+var VRF_PROOF_BYTES_LENGTH2 = 80;
+var MICROBLOCK_HEADER_BYTES_LENGTH2 = 132;
+var TenureChangeCause2 = {
   BlockFound: 0,
   Extended: 1,
   ExtendedRuntime: 2,
@@ -124,207 +124,207 @@ var TenureChangeCause = {
 
 // src/transactions/wire/serialize.ts
 function serializeAddress(c32Address) {
-  const [version, hash160] = c32addressDecode(c32Address);
-  return concatBytes(new Uint8Array([version]), hexToBytes(hash160));
+  const [version, hash160] = c32addressDecode2(c32Address);
+  return concatBytes2(new Uint8Array([version]), hexToBytes2(hash160));
 }
 function serializeLPString(str, prefixBytes = 1) {
-  const content = utf8ToBytes(str);
-  const prefix = hexToBytes(intToHex(content.byteLength, prefixBytes));
-  return concatBytes(prefix, content);
+  const content = utf8ToBytes2(str);
+  const prefix = hexToBytes2(intToHex2(content.byteLength, prefixBytes));
+  return concatBytes2(prefix, content);
 }
 function serializeLPStringLong(str) {
   return serializeLPString(str, 4);
 }
 function serializeMemo(memo) {
-  const content = asciiToBytes(memo);
-  const padded = new Uint8Array(MEMO_MAX_LENGTH_BYTES);
-  padded.set(content.slice(0, MEMO_MAX_LENGTH_BYTES));
+  const content = asciiToBytes2(memo);
+  const padded = new Uint8Array(MEMO_MAX_LENGTH_BYTES2);
+  padded.set(content.slice(0, MEMO_MAX_LENGTH_BYTES2));
   return padded;
 }
 function serializeSpendingCondition(condition) {
   const parts = [
-    writeUInt8(condition.hashMode),
-    hexToBytes(condition.signer),
-    intToBytes(condition.nonce, 8),
-    intToBytes(condition.fee, 8)
+    writeUInt82(condition.hashMode),
+    hexToBytes2(condition.signer),
+    intToBytes2(condition.nonce, 8),
+    intToBytes2(condition.fee, 8)
   ];
   if ("signature" in condition) {
     const sc = condition;
-    parts.push(writeUInt8(sc.keyEncoding));
-    parts.push(hexToBytes(sc.signature));
+    parts.push(writeUInt82(sc.keyEncoding));
+    parts.push(hexToBytes2(sc.signature));
   } else {
     const mc = condition;
-    parts.push(writeUInt32BE(mc.fields.length));
+    parts.push(writeUInt32BE2(mc.fields.length));
     for (const field of mc.fields) {
       parts.push(serializeAuthField(field));
     }
-    parts.push(writeUInt16BE(mc.signaturesRequired));
+    parts.push(writeUInt16BE2(mc.signaturesRequired));
   }
-  return concatBytes(...parts);
+  return concatBytes2(...parts);
 }
 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 concatBytes2(writeUInt82(typeId), hexToBytes2(field.data));
   }
   const typeId = field.pubKeyEncoding === 0 ? 2 : 3;
-  return concatBytes(writeUInt8(typeId), hexToBytes(field.data));
+  return concatBytes2(writeUInt82(typeId), hexToBytes2(field.data));
 }
 function serializeAuthorization(auth) {
-  const parts = [writeUInt8(auth.authType)];
+  const parts = [writeUInt82(auth.authType)];
   parts.push(serializeSpendingCondition(auth.spendingCondition));
-  if (auth.authType === AuthType.Sponsored) {
+  if (auth.authType === AuthType2.Sponsored) {
     parts.push(serializeSpendingCondition(auth.sponsorSpendingCondition));
   }
-  return concatBytes(...parts);
+  return concatBytes2(...parts);
 }
 function serializePrincipal(principal) {
   switch (principal.type) {
     case "origin":
-      return writeUInt8(PostConditionPrincipalId.Origin);
+      return writeUInt82(PostConditionPrincipalId2.Origin);
     case "standard":
-      return concatBytes(writeUInt8(PostConditionPrincipalId.Standard), serializeAddress(principal.address));
+      return concatBytes2(writeUInt82(PostConditionPrincipalId2.Standard), serializeAddress(principal.address));
     case "contract":
-      return concatBytes(writeUInt8(PostConditionPrincipalId.Contract), serializeAddress(principal.address), serializeLPString(principal.contractName));
+      return concatBytes2(writeUInt82(PostConditionPrincipalId2.Contract), serializeAddress(principal.address), serializeLPString(principal.contractName));
   }
 }
 function serializeAssetInfo(asset) {
-  return concatBytes(serializeAddress(asset.address), serializeLPString(asset.contractName), serializeLPString(asset.assetName));
+  return concatBytes2(serializeAddress(asset.address), serializeLPString(asset.contractName), serializeLPString(asset.assetName));
 }
-function serializePostConditionWire(pc) {
+function serializePostConditionWire2(pc) {
   const parts = [];
   switch (pc.type) {
     case "stx":
-      parts.push(writeUInt8(AssetType.STX));
+      parts.push(writeUInt82(AssetType2.STX));
       parts.push(serializePrincipal(pc.principal));
-      parts.push(writeUInt8(pc.conditionCode));
-      parts.push(intToBytes(pc.amount, 8));
+      parts.push(writeUInt82(pc.conditionCode));
+      parts.push(intToBytes2(pc.amount, 8));
       break;
     case "ft":
-      parts.push(writeUInt8(AssetType.Fungible));
+      parts.push(writeUInt82(AssetType2.Fungible));
       parts.push(serializePrincipal(pc.principal));
       parts.push(serializeAssetInfo(pc.asset));
-      parts.push(writeUInt8(pc.conditionCode));
-      parts.push(intToBytes(pc.amount, 8));
+      parts.push(writeUInt82(pc.conditionCode));
+      parts.push(intToBytes2(pc.amount, 8));
       break;
     case "nft":
-      parts.push(writeUInt8(AssetType.NonFungible));
+      parts.push(writeUInt82(AssetType2.NonFungible));
       parts.push(serializePrincipal(pc.principal));
       parts.push(serializeAssetInfo(pc.asset));
-      parts.push(serializeCVBytes(pc.assetId));
-      parts.push(writeUInt8(pc.conditionCode));
+      parts.push(serializeCVBytes2(pc.assetId));
+      parts.push(writeUInt82(pc.conditionCode));
       break;
     case "staking":
-      parts.push(writeUInt8(AssetType.Staking));
+      parts.push(writeUInt82(AssetType2.Staking));
       parts.push(serializePrincipal(pc.principal));
-      parts.push(writeUInt8(pc.conditionCode));
-      parts.push(intToBytes(pc.amount, 8));
+      parts.push(writeUInt82(pc.conditionCode));
+      parts.push(intToBytes2(pc.amount, 8));
       break;
     case "pox":
-      parts.push(writeUInt8(AssetType.Pox));
+      parts.push(writeUInt82(AssetType2.Pox));
       parts.push(serializePrincipal(pc.principal));
-      parts.push(writeUInt8(pc.conditionCode));
+      parts.push(writeUInt82(pc.conditionCode));
       break;
   }
-  return concatBytes(...parts);
+  return concatBytes2(...parts);
 }
 function serializePostConditions(pcs) {
-  const parts = [writeUInt32BE(pcs.length)];
+  const parts = [writeUInt32BE2(pcs.length)];
   for (const pc of pcs)
-    parts.push(serializePostConditionWire(pc));
-  return concatBytes(...parts);
+    parts.push(serializePostConditionWire2(pc));
+  return concatBytes2(...parts);
 }
 function serializePayload(payload) {
-  const parts = [writeUInt8(payload.payloadType)];
+  const parts = [writeUInt82(payload.payloadType)];
   switch (payload.payloadType) {
-    case PayloadType.TokenTransfer:
-      parts.push(serializeCVBytes(payload.recipient));
-      parts.push(intToBytes(payload.amount, 8));
+    case PayloadType2.TokenTransfer:
+      parts.push(serializeCVBytes2(payload.recipient));
+      parts.push(intToBytes2(payload.amount, 8));
       parts.push(serializeMemo(payload.memo));
       break;
-    case PayloadType.ContractCall:
+    case PayloadType2.ContractCall:
       parts.push(serializeAddress(payload.contractAddress));
       parts.push(serializeLPString(payload.contractName));
       parts.push(serializeLPString(payload.functionName));
-      parts.push(writeUInt32BE(payload.functionArgs.length));
+      parts.push(writeUInt32BE2(payload.functionArgs.length));
       for (const arg of payload.functionArgs) {
-        parts.push(serializeCVBytes(arg));
+        parts.push(serializeCVBytes2(arg));
       }
       break;
-    case PayloadType.SmartContract:
+    case PayloadType2.SmartContract:
       parts.push(serializeLPString(payload.contractName));
       parts.push(serializeLPStringLong(payload.codeBody));
       break;
-    case PayloadType.VersionedSmartContract:
-      parts.push(writeUInt8(payload.clarityVersion ?? 2));
+    case PayloadType2.VersionedSmartContract:
+      parts.push(writeUInt82(payload.clarityVersion ?? 2));
       parts.push(serializeLPString(payload.contractName));
       parts.push(serializeLPStringLong(payload.codeBody));
       break;
-    case PayloadType.Coinbase:
-      parts.push(hexToBytes(payload.coinbaseBuffer));
+    case PayloadType2.Coinbase:
+      parts.push(hexToBytes2(payload.coinbaseBuffer));
       break;
-    case PayloadType.CoinbaseToAltRecipient: {
+    case PayloadType2.CoinbaseToAltRecipient: {
       const cbAlt = payload;
-      parts.push(hexToBytes(cbAlt.coinbaseBuffer));
-      parts.push(serializeCVBytes(cbAlt.recipient));
+      parts.push(hexToBytes2(cbAlt.coinbaseBuffer));
+      parts.push(serializeCVBytes2(cbAlt.recipient));
       break;
     }
-    case PayloadType.PoisonMicroblock: {
+    case PayloadType2.PoisonMicroblock: {
       const pm = payload;
-      parts.push(hexToBytes(pm.header1));
-      parts.push(hexToBytes(pm.header2));
+      parts.push(hexToBytes2(pm.header1));
+      parts.push(hexToBytes2(pm.header2));
       break;
     }
-    case PayloadType.TenureChange: {
+    case PayloadType2.TenureChange: {
       const tc = payload;
-      parts.push(hexToBytes(tc.tenureConsensusHash));
-      parts.push(hexToBytes(tc.prevTenureConsensusHash));
-      parts.push(hexToBytes(tc.burnViewConsensusHash));
-      parts.push(hexToBytes(tc.previousTenureEnd));
-      parts.push(writeUInt32BE(tc.previousTenureBlocks));
-      parts.push(writeUInt8(tc.cause));
-      parts.push(hexToBytes(tc.pubkeyHash));
+      parts.push(hexToBytes2(tc.tenureConsensusHash));
+      parts.push(hexToBytes2(tc.prevTenureConsensusHash));
+      parts.push(hexToBytes2(tc.burnViewConsensusHash));
+      parts.push(hexToBytes2(tc.previousTenureEnd));
+      parts.push(writeUInt32BE2(tc.previousTenureBlocks));
+      parts.push(writeUInt82(tc.cause));
+      parts.push(hexToBytes2(tc.pubkeyHash));
       break;
     }
-    case PayloadType.NakamotoCoinbase: {
+    case PayloadType2.NakamotoCoinbase: {
       const nc = payload;
-      parts.push(hexToBytes(nc.coinbaseBuffer));
+      parts.push(hexToBytes2(nc.coinbaseBuffer));
       if (nc.recipient) {
-        parts.push(serializeCVBytes({ type: "some", value: nc.recipient }));
+        parts.push(serializeCVBytes2({ type: "some", value: nc.recipient }));
       } else {
-        parts.push(serializeCVBytes({ type: "none" }));
+        parts.push(serializeCVBytes2({ type: "none" }));
       }
-      parts.push(hexToBytes(nc.vrfProof));
+      parts.push(hexToBytes2(nc.vrfProof));
       break;
     }
   }
-  return concatBytes(...parts);
+  return concatBytes2(...parts);
 }
 var _txCache = new WeakMap;
 function clearTxCache(tx) {
   _txCache.delete(tx);
 }
-function serializeTransaction(tx) {
+function serializeTransaction2(tx) {
   const cached = _txCache.get(tx);
   if (cached)
     return cached;
-  const bytes = concatBytes(writeUInt8(tx.version), writeUInt32BE(tx.chainId), serializeAuthorization(tx.auth), writeUInt8(tx.anchorMode), writeUInt8(tx.postConditionMode), serializePostConditions(tx.postConditions), serializePayload(tx.payload));
+  const bytes = concatBytes2(writeUInt82(tx.version), writeUInt32BE2(tx.chainId), serializeAuthorization(tx.auth), writeUInt82(tx.anchorMode), writeUInt82(tx.postConditionMode), serializePostConditions(tx.postConditions), serializePayload(tx.payload));
   _txCache.set(tx, bytes);
   return bytes;
 }
-function serializeTransactionHex(tx) {
-  return bytesToHex(serializeTransaction(tx));
+function serializeTransactionHex2(tx) {
+  return bytesToHex2(serializeTransaction2(tx));
 }
 
 // src/transactions/wire/deserialize.ts
 function readSpendingCondition(r) {
   const hashMode = r.readUInt8();
-  const signer = bytesToHex(r.readBytes(20));
+  const signer = bytesToHex2(r.readBytes(20));
   const nonce = r.readBigUInt64BE();
   const fee = r.readBigUInt64BE();
-  if (hashMode === AddressHashMode.P2PKH || hashMode === AddressHashMode.P2WPKH) {
+  if (hashMode === AddressHashMode2.P2PKH || hashMode === AddressHashMode2.P2WPKH) {
     const keyEncoding = r.readUInt8();
-    const signature = bytesToHex(r.readBytes(RECOVERABLE_ECDSA_SIG_LENGTH_BYTES));
+    const signature = bytesToHex2(r.readBytes(RECOVERABLE_ECDSA_SIG_LENGTH_BYTES2));
     return {
       hashMode,
       signer,
@@ -343,13 +343,13 @@ function readSpendingCondition(r) {
       fields.push({
         type: "publicKey",
         pubKeyEncoding: fieldType,
-        data: bytesToHex(r.readBytes(keyLen))
+        data: bytesToHex2(r.readBytes(keyLen))
       });
     } else {
       fields.push({
         type: "signature",
         pubKeyEncoding: fieldType === 2 ? 0 : 1,
-        data: bytesToHex(r.readBytes(RECOVERABLE_ECDSA_SIG_LENGTH_BYTES))
+        data: bytesToHex2(r.readBytes(RECOVERABLE_ECDSA_SIG_LENGTH_BYTES2))
       });
     }
   }
@@ -366,12 +366,12 @@ function readSpendingCondition(r) {
 function readAuthorization(r) {
   const authType = r.readUInt8();
   const spendingCondition = readSpendingCondition(r);
-  if (authType === AuthType.Standard) {
-    return { authType: AuthType.Standard, spendingCondition };
+  if (authType === AuthType2.Standard) {
+    return { authType: AuthType2.Standard, spendingCondition };
   }
   const sponsorSpendingCondition = readSpendingCondition(r);
   return {
-    authType: AuthType.Sponsored,
+    authType: AuthType2.Sponsored,
     spendingCondition,
     sponsorSpendingCondition
   };
@@ -386,11 +386,11 @@ function readAssetInfo(r) {
 function readPostConditionPrincipal(r) {
   const type = r.readUInt8();
   switch (type) {
-    case PostConditionPrincipalId.Origin:
+    case PostConditionPrincipalId2.Origin:
       return { type: "origin" };
-    case PostConditionPrincipalId.Standard:
+    case PostConditionPrincipalId2.Standard:
       return { type: "standard", address: readAddress(r) };
-    case PostConditionPrincipalId.Contract:
+    case PostConditionPrincipalId2.Contract:
       return {
         type: "contract",
         address: readAddress(r),
@@ -404,14 +404,14 @@ function readPostCondition(r) {
   const assetType = r.readUInt8();
   const principal = readPostConditionPrincipal(r);
   switch (assetType) {
-    case AssetType.STX:
+    case AssetType2.STX:
       return {
         type: "stx",
         principal,
         conditionCode: r.readUInt8(),
         amount: r.readBigUInt64BE()
       };
-    case AssetType.Fungible:
+    case AssetType2.Fungible:
       return {
         type: "ft",
         principal,
@@ -419,7 +419,7 @@ function readPostCondition(r) {
         conditionCode: r.readUInt8(),
         amount: r.readBigUInt64BE()
       };
-    case AssetType.NonFungible:
+    case AssetType2.NonFungible:
       return {
         type: "nft",
         principal,
@@ -427,14 +427,14 @@ function readPostCondition(r) {
         assetId: readCV(r),
         conditionCode: r.readUInt8()
       };
-    case AssetType.Staking:
+    case AssetType2.Staking:
       return {
         type: "staking",
         principal,
         conditionCode: r.readUInt8(),
         amount: r.readBigUInt64BE()
       };
-    case AssetType.Pox:
+    case AssetType2.Pox:
       return {
         type: "pox",
         principal,
@@ -462,19 +462,19 @@ function readPostConditions(r) {
 function readPayload(r) {
   const payloadType = r.readUInt8();
   switch (payloadType) {
-    case PayloadType.TokenTransfer: {
+    case PayloadType2.TokenTransfer: {
       const recipient = readCV(r);
       const amount = r.readBigUInt64BE();
-      const memoBytes = r.readBytes(MEMO_MAX_LENGTH_BYTES);
-      const memo = bytesToAscii(memoBytes).replace(/\0+$/, "");
+      const memoBytes = r.readBytes(MEMO_MAX_LENGTH_BYTES2);
+      const memo = bytesToAscii2(memoBytes).replace(/\0+$/, "");
       return {
-        payloadType: PayloadType.TokenTransfer,
+        payloadType: PayloadType2.TokenTransfer,
         recipient,
         amount,
         memo
       };
     }
-    case PayloadType.ContractCall: {
+    case PayloadType2.ContractCall: {
       const contractAddress = readAddress(r);
       const contractName = readLPString(r);
       const functionName = readLPString(r);
@@ -483,57 +483,57 @@ function readPayload(r) {
       for (let i = 0;i < numArgs; i++)
         functionArgs.push(readCV(r));
       return {
-        payloadType: PayloadType.ContractCall,
+        payloadType: PayloadType2.ContractCall,
         contractAddress,
         contractName,
         functionName,
         functionArgs
       };
     }
-    case PayloadType.SmartContract: {
+    case PayloadType2.SmartContract: {
       const contractName = readLPString(r);
       const codeBody = readLPString(r, 4);
-      return { payloadType: PayloadType.SmartContract, contractName, codeBody };
+      return { payloadType: PayloadType2.SmartContract, contractName, codeBody };
     }
-    case PayloadType.VersionedSmartContract: {
+    case PayloadType2.VersionedSmartContract: {
       const clarityVersion = r.readUInt8();
       const contractName = readLPString(r);
       const codeBody = readLPString(r, 4);
       return {
-        payloadType: PayloadType.VersionedSmartContract,
+        payloadType: PayloadType2.VersionedSmartContract,
         clarityVersion,
         contractName,
         codeBody
       };
     }
-    case PayloadType.Coinbase: {
-      const coinbaseBuffer = bytesToHex(r.readBytes(COINBASE_BYTES_LENGTH));
-      return { payloadType: PayloadType.Coinbase, coinbaseBuffer };
+    case PayloadType2.Coinbase: {
+      const coinbaseBuffer = bytesToHex2(r.readBytes(COINBASE_BYTES_LENGTH2));
+      return { payloadType: PayloadType2.Coinbase, coinbaseBuffer };
     }
-    case PayloadType.CoinbaseToAltRecipient: {
-      const coinbaseBuffer = bytesToHex(r.readBytes(COINBASE_BYTES_LENGTH));
+    case PayloadType2.CoinbaseToAltRecipient: {
+      const coinbaseBuffer = bytesToHex2(r.readBytes(COINBASE_BYTES_LENGTH2));
       const recipient = readCV(r);
       return {
-        payloadType: PayloadType.CoinbaseToAltRecipient,
+        payloadType: PayloadType2.CoinbaseToAltRecipient,
         coinbaseBuffer,
         recipient
       };
     }
-    case PayloadType.PoisonMicroblock: {
-      const header1 = bytesToHex(r.readBytes(MICROBLOCK_HEADER_BYTES_LENGTH));
-      const header2 = bytesToHex(r.readBytes(MICROBLOCK_HEADER_BYTES_LENGTH));
-      return { payloadType: PayloadType.PoisonMicroblock, header1, header2 };
+    case PayloadType2.PoisonMicroblock: {
+      const header1 = bytesToHex2(r.readBytes(MICROBLOCK_HEADER_BYTES_LENGTH2));
+      const header2 = bytesToHex2(r.readBytes(MICROBLOCK_HEADER_BYTES_LENGTH2));
+      return { payloadType: PayloadType2.PoisonMicroblock, header1, header2 };
     }
-    case PayloadType.TenureChange: {
-      const tenureConsensusHash = bytesToHex(r.readBytes(20));
-      const prevTenureConsensusHash = bytesToHex(r.readBytes(20));
-      const burnViewConsensusHash = bytesToHex(r.readBytes(20));
-      const previousTenureEnd = bytesToHex(r.readBytes(32));
+    case PayloadType2.TenureChange: {
+      const tenureConsensusHash = bytesToHex2(r.readBytes(20));
+      const prevTenureConsensusHash = bytesToHex2(r.readBytes(20));
+      const burnViewConsensusHash = bytesToHex2(r.readBytes(20));
+      const previousTenureEnd = bytesToHex2(r.readBytes(32));
       const previousTenureBlocks = r.readUInt32BE();
       const cause = r.readUInt8();
-      const pubkeyHash = bytesToHex(r.readBytes(20));
+      const pubkeyHash = bytesToHex2(r.readBytes(20));
       return {
-        payloadType: PayloadType.TenureChange,
+        payloadType: PayloadType2.TenureChange,
         tenureConsensusHash,
         prevTenureConsensusHash,
         burnViewConsensusHash,
@@ -543,13 +543,13 @@ function readPayload(r) {
         pubkeyHash
       };
     }
-    case PayloadType.NakamotoCoinbase: {
-      const coinbaseBuffer = bytesToHex(r.readBytes(COINBASE_BYTES_LENGTH));
+    case PayloadType2.NakamotoCoinbase: {
+      const coinbaseBuffer = bytesToHex2(r.readBytes(COINBASE_BYTES_LENGTH2));
       const optionalCV = readCV(r);
       const recipient = optionalCV.type === "none" ? null : optionalCV.type === "some" ? optionalCV.value : optionalCV;
-      const vrfProof = bytesToHex(r.readBytes(VRF_PROOF_BYTES_LENGTH));
+      const vrfProof = bytesToHex2(r.readBytes(VRF_PROOF_BYTES_LENGTH2));
       return {
-        payloadType: PayloadType.NakamotoCoinbase,
+        payloadType: PayloadType2.NakamotoCoinbase,
         coinbaseBuffer,
         recipient,
         vrfProof
@@ -559,12 +559,12 @@ function readPayload(r) {
       throw new Error(`Unknown payload type: ${payloadType}`);
   }
 }
-function deserializePostConditionWire(input) {
-  const bytes = typeof input === "string" ? hexToBytes(without0x(input)) : input;
+function deserializePostConditionWire2(input) {
+  const bytes = typeof input === "string" ? hexToBytes2(without0x2(input)) : input;
   return readPostCondition(new BytesReader(bytes));
 }
-function deserializeTransaction(input, meta) {
-  const bytes = typeof input === "string" ? hexToBytes(without0x(input)) : input;
+function deserializeTransaction2(input, meta) {
+  const bytes = typeof input === "string" ? hexToBytes2(without0x2(input)) : input;
   const r = new BytesReader(bytes);
   const tx = {
     version: r.readUInt8(),
@@ -583,46 +583,46 @@ function deserializeTransaction(input, meta) {
 
 // src/postconditions/convert.ts
 var MAX_U64 = 18446744073709551615n;
-function parsePostConditionAmount(amount) {
-  const value = intToBigInt(amount);
+function parsePostConditionAmount2(amount) {
+  const value = intToBigInt2(amount);
   if (value < 0n || value > MAX_U64) {
     throw new RangeError(`Post-condition amount must be between 0 and ${MAX_U64} (u64 max), received: ${value}`);
   }
   return value;
 }
 var FUNGIBLE_CODE_MAP = {
-  eq: FungibleConditionCode.Equal,
-  gt: FungibleConditionCode.Greater,
-  gte: FungibleConditionCode.GreaterEqual,
-  lt: FungibleConditionCode.Less,
-  lte: FungibleConditionCode.LessEqual
+  eq: FungibleConditionCode2.Equal,
+  gt: FungibleConditionCode2.Greater,
+  gte: FungibleConditionCode2.GreaterEqual,
+  lt: FungibleConditionCode2.Less,
+  lte: FungibleConditionCode2.LessEqual
 };
 var FUNGIBLE_CODE_REVERSE = {
-  [FungibleConditionCode.Equal]: "eq",
-  [FungibleConditionCode.Greater]: "gt",
-  [FungibleConditionCode.GreaterEqual]: "gte",
-  [FungibleConditionCode.Less]: "lt",
-  [FungibleConditionCode.LessEqual]: "lte"
+  [FungibleConditionCode2.Equal]: "eq",
+  [FungibleConditionCode2.Greater]: "gt",
+  [FungibleConditionCode2.GreaterEqual]: "gte",
+  [FungibleConditionCode2.Less]: "lt",
+  [FungibleConditionCode2.LessEqual]: "lte"
 };
 var NFT_CODE_MAP = {
-  sent: NonFungibleConditionCode.Sends,
-  "not-sent": NonFungibleConditionCode.DoesNotSend,
-  "maybe-sent": NonFungibleConditionCode.MaybeSent
+  sent: NonFungibleConditionCode2.Sends,
+  "not-sent": NonFungibleConditionCode2.DoesNotSend,
+  "maybe-sent": NonFungibleConditionCode2.MaybeSent
 };
 var NFT_CODE_REVERSE = {
-  [NonFungibleConditionCode.Sends]: "sent",
-  [NonFungibleConditionCode.DoesNotSend]: "not-sent",
-  [NonFungibleConditionCode.MaybeSent]: "maybe-sent"
+  [NonFungibleConditionCode2.Sends]: "sent",
+  [NonFungibleConditionCode2.DoesNotSend]: "not-sent",
+  [NonFungibleConditionCode2.MaybeSent]: "maybe-sent"
 };
 var POX_CODE_MAP = {
-  "will-not-perform": PoxConditionCode.WillNotPerform,
-  "may-perform": PoxConditionCode.MayPerform,
-  "will-perform": PoxConditionCode.WillPerform
+  "will-not-perform": PoxConditionCode2.WillNotPerform,
+  "may-perform": PoxConditionCode2.MayPerform,
+  "will-perform": PoxConditionCode2.WillPerform
 };
 var POX_CODE_REVERSE = {
-  [PoxConditionCode.WillNotPerform]: "will-not-perform",
-  [PoxConditionCode.MayPerform]: "may-perform",
-  [PoxConditionCode.WillPerform]: "will-perform"
+  [PoxConditionCode2.WillNotPerform]: "will-not-perform",
+  [PoxConditionCode2.MayPerform]: "may-perform",
+  [PoxConditionCode2.WillPerform]: "will-perform"
 };
 function resolvePrincipal(address) {
   if (address === "origin")
@@ -646,7 +646,7 @@ function assetToString(asset) {
 }
 function parseAsset(asset) {
   const [contractId, tokenName] = asset.split("::");
-  const [addr, name] = parseContractId(contractId);
+  const [addr, name] = parseContractId2(contractId);
   return { address: addr, contractName: name, assetName: tokenName };
 }
 function convertPostCondition(pc) {
@@ -656,7 +656,7 @@ function convertPostCondition(pc) {
         type: "stx",
         principal: resolvePrincipal(pc.address),
         conditionCode: FUNGIBLE_CODE_MAP[pc.condition],
-        amount: parsePostConditionAmount(pc.amount)
+        amount: parsePostConditionAmount2(pc.amount)
       };
     case "ft-postcondition":
       return {
@@ -664,7 +664,7 @@ function convertPostCondition(pc) {
         principal: resolvePrincipal(pc.address),
         asset: parseAsset(pc.asset),
         conditionCode: FUNGIBLE_CODE_MAP[pc.condition],
-        amount: parsePostConditionAmount(pc.amount)
+        amount: parsePostConditionAmount2(pc.amount)
       };
     case "nft-postcondition":
       return {
@@ -679,7 +679,7 @@ function convertPostCondition(pc) {
         type: "staking",
         principal: resolvePrincipal(pc.address),
         conditionCode: FUNGIBLE_CODE_MAP[pc.condition],
-        amount: parsePostConditionAmount(pc.amount)
+        amount: parsePostConditionAmount2(pc.amount)
       };
     case "pox-postcondition":
       return {
@@ -689,7 +689,7 @@ function convertPostCondition(pc) {
       };
   }
 }
-function wireToPostCondition(wire) {
+function wireToPostCondition2(wire) {
   switch (wire.type) {
     case "stx":
       return {
@@ -747,14 +747,14 @@ function poxName(code) {
     throw new Error(`Unknown pox post-condition code: ${code}`);
   return name;
 }
-function fromHex(hex) {
-  return wireToPostCondition(deserializePostConditionWire(hex));
+function fromHex2(hex) {
+  return wireToPostCondition2(deserializePostConditionWire2(hex));
 }
-function postConditionToHex(pc) {
-  return bytesToHex(serializePostConditionWire(convertPostCondition(pc)));
+function postConditionToHex2(pc) {
+  return bytesToHex2(serializePostConditionWire2(convertPostCondition(pc)));
 }
 
-export { AuthType, PayloadType, ClarityVersion, AnchorMode, PostConditionModeWire, AddressHashMode, PubKeyEncoding, FungibleConditionCode, NonFungibleConditionCode, PoxConditionCode, PostConditionPrincipalId, AssetType, AuthFieldType, RECOVERABLE_ECDSA_SIG_LENGTH_BYTES, MEMO_MAX_LENGTH_BYTES, MAX_STRING_LENGTH_BYTES, COINBASE_BYTES_LENGTH, VRF_PROOF_BYTES_LENGTH, MICROBLOCK_HEADER_BYTES_LENGTH, TenureChangeCause, serializePostConditionWire, serializePayload, clearTxCache, serializeTransaction, serializeTransactionHex, deserializePostConditionWire, deserializeTransaction, parsePostConditionAmount, convertPostCondition, wireToPostCondition, fromHex, postConditionToHex };
+export { AuthType2, PayloadType2, ClarityVersion2, AnchorMode2, PostConditionModeWire2, AddressHashMode2, PubKeyEncoding2, FungibleConditionCode2, NonFungibleConditionCode2, PoxConditionCode2, PostConditionPrincipalId2, AssetType2, AuthFieldType2, RECOVERABLE_ECDSA_SIG_LENGTH_BYTES2, MEMO_MAX_LENGTH_BYTES2, MAX_STRING_LENGTH_BYTES2, COINBASE_BYTES_LENGTH2, VRF_PROOF_BYTES_LENGTH2, MICROBLOCK_HEADER_BYTES_LENGTH2, TenureChangeCause2, serializePostConditionWire2, serializePayload, clearTxCache, serializeTransaction2, serializeTransactionHex2, deserializePostConditionWire2, deserializeTransaction2, parsePostConditionAmount2, convertPostCondition, wireToPostCondition2, fromHex2, postConditionToHex2 };
 
-//# debugId=0727B877F1BE3A9864756E2164756E21
-//# sourceMappingURL=stacks-51ybf135.js.map
+//# debugId=4AE8108BDE2F69E064756E2164756E21
+//# sourceMappingURL=stacks-esm-phgy8yqf.js.map