@secondlayer/stacks 3.3.1 → 4.1.0

package/dist/shared/stacks-w23294am.js

@@ -0,0 +1,760 @@
+import {
+  BytesReader,
+  readAddress,
+  readCV,
+  readLPString,
+  serializeCVBytes
+} from "./stacks-ttdk2g2f.js";
+import {
+  parseContractId
+} from "./stacks-bfan7ex7.js";
+import {
+  asciiToBytes,
+  bytesToAscii,
+  bytesToHex,
+  c32addressDecode,
+  concatBytes,
+  hexToBytes,
+  intToBigInt,
+  intToBytes,
+  intToHex,
+  utf8ToBytes,
+  without0x,
+  writeUInt16BE,
+  writeUInt32BE,
+  writeUInt8
+} from "./stacks-qs5fzts5.js";
+
+// 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/serialize.ts
+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 prefix = hexToBytes(intToHex(content.byteLength, prefixBytes));
+  return concatBytes(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));
+  return padded;
+}
+function serializeSpendingCondition(condition) {
+  const parts = [
+    writeUInt8(condition.hashMode),
+    hexToBytes(condition.signer),
+    intToBytes(condition.nonce, 8),
+    intToBytes(condition.fee, 8)
+  ];
+  if ("signature" in condition) {
+    const sc = condition;
+    parts.push(writeUInt8(sc.keyEncoding));
+    parts.push(hexToBytes(sc.signature));
+  } else {
+    const mc = condition;
+    parts.push(writeUInt32BE(mc.fields.length));
+    for (const field of mc.fields) {
+      parts.push(serializeAuthField(field));
+    }
+    parts.push(writeUInt16BE(mc.signaturesRequired));
+  }
+  return concatBytes(...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 ? 2 : 3;
+  return concatBytes(writeUInt8(typeId), hexToBytes(field.data));
+}
+function serializeAuthorization(auth) {
+  const parts = [writeUInt8(auth.authType)];
+  parts.push(serializeSpendingCondition(auth.spendingCondition));
+  if (auth.authType === AuthType.Sponsored) {
+    parts.push(serializeSpendingCondition(auth.sponsorSpendingCondition));
+  }
+  return concatBytes(...parts);
+}
+function serializePrincipal(principal) {
+  switch (principal.type) {
+    case "origin":
+      return writeUInt8(PostConditionPrincipalId.Origin);
+    case "standard":
+      return concatBytes(writeUInt8(PostConditionPrincipalId.Standard), serializeAddress(principal.address));
+    case "contract":
+      return concatBytes(writeUInt8(PostConditionPrincipalId.Contract), serializeAddress(principal.address), serializeLPString(principal.contractName));
+  }
+}
+function serializeAssetInfo(asset) {
+  return concatBytes(serializeAddress(asset.address), serializeLPString(asset.contractName), serializeLPString(asset.assetName));
+}
+function serializePostConditionWire(pc) {
+  const parts = [];
+  switch (pc.type) {
+    case "stx":
+      parts.push(writeUInt8(AssetType.STX));
+      parts.push(serializePrincipal(pc.principal));
+      parts.push(writeUInt8(pc.conditionCode));
+      parts.push(intToBytes(pc.amount, 8));
+      break;
+    case "ft":
+      parts.push(writeUInt8(AssetType.Fungible));
+      parts.push(serializePrincipal(pc.principal));
+      parts.push(serializeAssetInfo(pc.asset));
+      parts.push(writeUInt8(pc.conditionCode));
+      parts.push(intToBytes(pc.amount, 8));
+      break;
+    case "nft":
+      parts.push(writeUInt8(AssetType.NonFungible));
+      parts.push(serializePrincipal(pc.principal));
+      parts.push(serializeAssetInfo(pc.asset));
+      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);
+}
+function serializePostConditions(pcs) {
+  const parts = [writeUInt32BE(pcs.length)];
+  for (const pc of pcs)
+    parts.push(serializePostConditionWire(pc));
+  return concatBytes(...parts);
+}
+function serializePayload(payload) {
+  const parts = [writeUInt8(payload.payloadType)];
+  switch (payload.payloadType) {
+    case PayloadType.TokenTransfer:
+      parts.push(serializeCVBytes(payload.recipient));
+      parts.push(intToBytes(payload.amount, 8));
+      parts.push(serializeMemo(payload.memo));
+      break;
+    case PayloadType.ContractCall:
+      parts.push(serializeAddress(payload.contractAddress));
+      parts.push(serializeLPString(payload.contractName));
+      parts.push(serializeLPString(payload.functionName));
+      parts.push(writeUInt32BE(payload.functionArgs.length));
+      for (const arg of payload.functionArgs) {
+        parts.push(serializeCVBytes(arg));
+      }
+      break;
+    case PayloadType.SmartContract:
+      parts.push(serializeLPString(payload.contractName));
+      parts.push(serializeLPStringLong(payload.codeBody));
+      break;
+    case PayloadType.VersionedSmartContract:
+      parts.push(writeUInt8(payload.clarityVersion ?? 2));
+      parts.push(serializeLPString(payload.contractName));
+      parts.push(serializeLPStringLong(payload.codeBody));
+      break;
+    case PayloadType.Coinbase:
+      parts.push(hexToBytes(payload.coinbaseBuffer));
+      break;
+    case PayloadType.CoinbaseToAltRecipient: {
+      const cbAlt = payload;
+      parts.push(hexToBytes(cbAlt.coinbaseBuffer));
+      parts.push(serializeCVBytes(cbAlt.recipient));
+      break;
+    }
+    case PayloadType.PoisonMicroblock: {
+      const pm = payload;
+      parts.push(hexToBytes(pm.header1));
+      parts.push(hexToBytes(pm.header2));
+      break;
+    }
+    case PayloadType.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));
+      break;
+    }
+    case PayloadType.NakamotoCoinbase: {
+      const nc = payload;
+      parts.push(hexToBytes(nc.coinbaseBuffer));
+      if (nc.recipient) {
+        parts.push(serializeCVBytes({ type: "some", value: nc.recipient }));
+      } else {
+        parts.push(serializeCVBytes({ type: "none" }));
+      }
+      parts.push(hexToBytes(nc.vrfProof));
+      break;
+    }
+  }
+  return concatBytes(...parts);
+}
+var _txCache = new WeakMap;
+function clearTxCache(tx) {
+  _txCache.delete(tx);
+}
+function serializeTransaction(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));
+  _txCache.set(tx, bytes);
+  return bytes;
+}
+function serializeTransactionHex(tx) {
+  return bytesToHex(serializeTransaction(tx));
+}
+
+// src/transactions/wire/deserialize.ts
+function readSpendingCondition(r) {
+  const hashMode = r.readUInt8();
+  const signer = bytesToHex(r.readBytes(20));
+  const nonce = r.readBigUInt64BE();
+  const fee = r.readBigUInt64BE();
+  if (hashMode === AddressHashMode.P2PKH || hashMode === AddressHashMode.P2WPKH) {
+    const keyEncoding = r.readUInt8();
+    const signature = bytesToHex(r.readBytes(RECOVERABLE_ECDSA_SIG_LENGTH_BYTES));
+    return {
+      hashMode,
+      signer,
+      nonce,
+      fee,
+      keyEncoding,
+      signature
+    };
+  }
+  const fieldCount = r.readUInt32BE();
+  const fields = [];
+  for (let i = 0;i < fieldCount; i++) {
+    const fieldType = r.readUInt8();
+    if (fieldType <= 1) {
+      const keyLen = fieldType === 0 ? 33 : 65;
+      fields.push({
+        type: "publicKey",
+        pubKeyEncoding: fieldType,
+        data: bytesToHex(r.readBytes(keyLen))
+      });
+    } else {
+      fields.push({
+        type: "signature",
+        pubKeyEncoding: fieldType === 2 ? 0 : 1,
+        data: bytesToHex(r.readBytes(RECOVERABLE_ECDSA_SIG_LENGTH_BYTES))
+      });
+    }
+  }
+  const signaturesRequired = r.readUInt16BE();
+  return {
+    hashMode,
+    signer,
+    nonce,
+    fee,
+    fields,
+    signaturesRequired
+  };
+}
+function readAuthorization(r) {
+  const authType = r.readUInt8();
+  const spendingCondition = readSpendingCondition(r);
+  if (authType === AuthType.Standard) {
+    return { authType: AuthType.Standard, spendingCondition };
+  }
+  const sponsorSpendingCondition = readSpendingCondition(r);
+  return {
+    authType: AuthType.Sponsored,
+    spendingCondition,
+    sponsorSpendingCondition
+  };
+}
+function readAssetInfo(r) {
+  return {
+    address: readAddress(r),
+    contractName: readLPString(r),
+    assetName: readLPString(r)
+  };
+}
+function readPostConditionPrincipal(r) {
+  const type = r.readUInt8();
+  switch (type) {
+    case PostConditionPrincipalId.Origin:
+      return { type: "origin" };
+    case PostConditionPrincipalId.Standard:
+      return { type: "standard", address: readAddress(r) };
+    case PostConditionPrincipalId.Contract:
+      return {
+        type: "contract",
+        address: readAddress(r),
+        contractName: readLPString(r)
+      };
+    default:
+      return { type: "origin" };
+  }
+}
+function readPostCondition(r) {
+  const assetType = r.readUInt8();
+  const principal = readPostConditionPrincipal(r);
+  switch (assetType) {
+    case AssetType.STX:
+      return {
+        type: "stx",
+        principal,
+        conditionCode: r.readUInt8(),
+        amount: r.readBigUInt64BE()
+      };
+    case AssetType.Fungible:
+      return {
+        type: "ft",
+        principal,
+        asset: readAssetInfo(r),
+        conditionCode: r.readUInt8(),
+        amount: r.readBigUInt64BE()
+      };
+    case AssetType.NonFungible:
+      return {
+        type: "nft",
+        principal,
+        asset: readAssetInfo(r),
+        assetId: readCV(r),
+        conditionCode: r.readUInt8()
+      };
+    case AssetType.Staking:
+      return {
+        type: "staking",
+        principal,
+        conditionCode: r.readUInt8(),
+        amount: r.readBigUInt64BE()
+      };
+    case AssetType.Pox:
+      return {
+        type: "pox",
+        principal,
+        conditionCode: r.readUInt8()
+      };
+    default:
+      throw new Error(`Unknown post-condition asset type: 0x${assetType.toString(16).padStart(2, "0")}`);
+  }
+}
+function readPostConditions(r) {
+  const count = r.readUInt32BE();
+  const pcs = [];
+  for (let i = 0;i < count; i++) {
+    try {
+      pcs.push(readPostCondition(r));
+    } catch (e) {
+      if (e instanceof Error && e.message.startsWith("Unknown post-condition asset type:")) {
+        throw new Error(`${e.message} (post-condition ${i + 1}/${count})`);
+      }
+      throw e;
+    }
+  }
+  return pcs;
+}
+function readPayload(r) {
+  const payloadType = r.readUInt8();
+  switch (payloadType) {
+    case PayloadType.TokenTransfer: {
+      const recipient = readCV(r);
+      const amount = r.readBigUInt64BE();
+      const memoBytes = r.readBytes(MEMO_MAX_LENGTH_BYTES);
+      const memo = bytesToAscii(memoBytes).replace(/\0+$/, "");
+      return {
+        payloadType: PayloadType.TokenTransfer,
+        recipient,
+        amount,
+        memo
+      };
+    }
+    case PayloadType.ContractCall: {
+      const contractAddress = readAddress(r);
+      const contractName = readLPString(r);
+      const functionName = readLPString(r);
+      const numArgs = r.readUInt32BE();
+      const functionArgs = [];
+      for (let i = 0;i < numArgs; i++)
+        functionArgs.push(readCV(r));
+      return {
+        payloadType: PayloadType.ContractCall,
+        contractAddress,
+        contractName,
+        functionName,
+        functionArgs
+      };
+    }
+    case PayloadType.SmartContract: {
+      const contractName = readLPString(r);
+      const codeBody = readLPString(r, 4);
+      return { payloadType: PayloadType.SmartContract, contractName, codeBody };
+    }
+    case PayloadType.VersionedSmartContract: {
+      const clarityVersion = r.readUInt8();
+      const contractName = readLPString(r);
+      const codeBody = readLPString(r, 4);
+      return {
+        payloadType: PayloadType.VersionedSmartContract,
+        clarityVersion,
+        contractName,
+        codeBody
+      };
+    }
+    case PayloadType.Coinbase: {
+      const coinbaseBuffer = bytesToHex(r.readBytes(COINBASE_BYTES_LENGTH));
+      return { payloadType: PayloadType.Coinbase, coinbaseBuffer };
+    }
+    case PayloadType.CoinbaseToAltRecipient: {
+      const coinbaseBuffer = bytesToHex(r.readBytes(COINBASE_BYTES_LENGTH));
+      const recipient = readCV(r);
+      return {
+        payloadType: PayloadType.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 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));
+      const previousTenureBlocks = r.readUInt32BE();
+      const cause = r.readUInt8();
+      const pubkeyHash = bytesToHex(r.readBytes(20));
+      return {
+        payloadType: PayloadType.TenureChange,
+        tenureConsensusHash,
+        prevTenureConsensusHash,
+        burnViewConsensusHash,
+        previousTenureEnd,
+        previousTenureBlocks,
+        cause,
+        pubkeyHash
+      };
+    }
+    case PayloadType.NakamotoCoinbase: {
+      const coinbaseBuffer = bytesToHex(r.readBytes(COINBASE_BYTES_LENGTH));
+      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));
+      return {
+        payloadType: PayloadType.NakamotoCoinbase,
+        coinbaseBuffer,
+        recipient,
+        vrfProof
+      };
+    }
+    default:
+      throw new Error(`Unknown payload type: ${payloadType}`);
+  }
+}
+function deserializePostConditionWire(input) {
+  const bytes = typeof input === "string" ? hexToBytes(without0x(input)) : input;
+  return readPostCondition(new BytesReader(bytes));
+}
+function deserializeTransaction(input, meta) {
+  const bytes = typeof input === "string" ? hexToBytes(without0x(input)) : input;
+  const r = new BytesReader(bytes);
+  const tx = {
+    version: r.readUInt8(),
+    chainId: r.readUInt32BE(),
+    auth: readAuthorization(r),
+    anchorMode: r.readUInt8(),
+    postConditionMode: r.readUInt8(),
+    postConditions: readPostConditions(r),
+    payload: readPayload(r)
+  };
+  if (meta?._multisig) {
+    tx._multisig = meta._multisig;
+  }
+  return tx;
+}
+
+// src/postconditions/convert.ts
+var MAX_U64 = 18446744073709551615n;
+function parsePostConditionAmount(amount) {
+  const value = intToBigInt(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
+};
+var FUNGIBLE_CODE_REVERSE = {
+  [FungibleConditionCode.Equal]: "eq",
+  [FungibleConditionCode.Greater]: "gt",
+  [FungibleConditionCode.GreaterEqual]: "gte",
+  [FungibleConditionCode.Less]: "lt",
+  [FungibleConditionCode.LessEqual]: "lte"
+};
+var NFT_CODE_MAP = {
+  sent: NonFungibleConditionCode.Sends,
+  "not-sent": NonFungibleConditionCode.DoesNotSend,
+  "maybe-sent": NonFungibleConditionCode.MaybeSent
+};
+var NFT_CODE_REVERSE = {
+  [NonFungibleConditionCode.Sends]: "sent",
+  [NonFungibleConditionCode.DoesNotSend]: "not-sent",
+  [NonFungibleConditionCode.MaybeSent]: "maybe-sent"
+};
+var POX_CODE_MAP = {
+  "will-not-perform": PoxConditionCode.WillNotPerform,
+  "may-perform": PoxConditionCode.MayPerform,
+  "will-perform": PoxConditionCode.WillPerform
+};
+var POX_CODE_REVERSE = {
+  [PoxConditionCode.WillNotPerform]: "will-not-perform",
+  [PoxConditionCode.MayPerform]: "may-perform",
+  [PoxConditionCode.WillPerform]: "will-perform"
+};
+function resolvePrincipal(address) {
+  if (address === "origin")
+    return { type: "origin" };
+  const [addr, name] = address.split(".");
+  if (name) {
+    return { type: "contract", address: addr, contractName: name };
+  }
+  return { type: "standard", address: addr };
+}
+function principalToString(principal) {
+  if (principal.type === "origin")
+    return "origin";
+  if (principal.type === "contract") {
+    return `${principal.address}.${principal.contractName}`;
+  }
+  return principal.address;
+}
+function assetToString(asset) {
+  return `${asset.address}.${asset.contractName}::${asset.assetName}`;
+}
+function parseAsset(asset) {
+  const [contractId, tokenName] = asset.split("::");
+  const [addr, name] = parseContractId(contractId);
+  return { address: addr, contractName: name, assetName: tokenName };
+}
+function convertPostCondition(pc) {
+  switch (pc.type) {
+    case "stx-postcondition":
+      return {
+        type: "stx",
+        principal: resolvePrincipal(pc.address),
+        conditionCode: FUNGIBLE_CODE_MAP[pc.condition],
+        amount: parsePostConditionAmount(pc.amount)
+      };
+    case "ft-postcondition":
+      return {
+        type: "ft",
+        principal: resolvePrincipal(pc.address),
+        asset: parseAsset(pc.asset),
+        conditionCode: FUNGIBLE_CODE_MAP[pc.condition],
+        amount: parsePostConditionAmount(pc.amount)
+      };
+    case "nft-postcondition":
+      return {
+        type: "nft",
+        principal: resolvePrincipal(pc.address),
+        asset: parseAsset(pc.asset),
+        conditionCode: NFT_CODE_MAP[pc.condition],
+        assetId: pc.assetId
+      };
+    case "staking-postcondition":
+      return {
+        type: "staking",
+        principal: resolvePrincipal(pc.address),
+        conditionCode: FUNGIBLE_CODE_MAP[pc.condition],
+        amount: parsePostConditionAmount(pc.amount)
+      };
+    case "pox-postcondition":
+      return {
+        type: "pox",
+        principal: resolvePrincipal(pc.address),
+        conditionCode: POX_CODE_MAP[pc.condition]
+      };
+  }
+}
+function wireToPostCondition(wire) {
+  switch (wire.type) {
+    case "stx":
+      return {
+        type: "stx-postcondition",
+        address: principalToString(wire.principal),
+        condition: fungibleName(wire.conditionCode),
+        amount: wire.amount.toString()
+      };
+    case "ft":
+      return {
+        type: "ft-postcondition",
+        address: principalToString(wire.principal),
+        condition: fungibleName(wire.conditionCode),
+        amount: wire.amount.toString(),
+        asset: assetToString(wire.asset)
+      };
+    case "nft":
+      return {
+        type: "nft-postcondition",
+        address: principalToString(wire.principal),
+        condition: nftName(wire.conditionCode),
+        asset: assetToString(wire.asset),
+        assetId: wire.assetId
+      };
+    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)));
+}
+
+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 };
+
+//# debugId=0727B877F1BE3A9864756E2164756E21
+//# sourceMappingURL=stacks-w23294am.js.map