@secondlayer/stacks 6.1.0 → 6.1.2

package/dist/shared/{stacks-esm-r9q4wnyw.js → stacks-esm-cmtj5vky.js}

@@ -1,31 +1,31 @@
 import {
-  AddressHashMode,
-  AnchorMode,
-  AuthType,
-  ClarityVersion,
-  PayloadType,
-  PostConditionModeWire,
-  PubKeyEncoding,
-  RECOVERABLE_ECDSA_SIG_LENGTH_BYTES,
-  convertPostCondition,
-  fromHex,
-  serializeTransaction
-} from "./stacks-esm-skmcf5n2.js";
+  bytesToHex2,
+  hexToBytes2,
+  concatBytes2,
+  intToBigInt2,
+  intToBytes2,
+  intToHex2,
+  c32address2,
+  hash1602,
+  txidFromBytes2,
+  hashP2PKH2
+} from "./stacks-esm-7a0ehykf.js";
 import {
-  Cl
-} from "./stacks-esm-fcfdn2zx.js";
+  Cl2
+} from "./stacks-esm-hkw1kvd4.js";
 import {
-  bytesToHex,
-  c32address,
-  concatBytes,
-  hash160,
-  hashP2PKH,
-  hexToBytes,
-  intToBigInt,
-  intToBytes,
-  intToHex,
-  txidFromBytes
-} from "./stacks-esm-cvhazvhd.js";
+  AuthType2,
+  PayloadType2,
+  ClarityVersion2,
+  AnchorMode2,
+  PostConditionModeWire2,
+  AddressHashMode2,
+  PubKeyEncoding2,
+  RECOVERABLE_ECDSA_SIG_LENGTH_BYTES2,
+  serializeTransaction2,
+  convertPostCondition,
+  fromHex2
+} from "./stacks-esm-phgy8yqf.js";
 
 // src/transactions/authorization.ts
 import { hmac } from "@noble/hashes/hmac.js";
@@ -37,28 +37,28 @@ etc.hmacSha256Sync = (key, ...msgs) => {
     h.update(msg);
   return h.digest();
 };
-var EMPTY_SIG = bytesToHex(new Uint8Array(RECOVERABLE_ECDSA_SIG_LENGTH_BYTES));
-function createSingleSigSpendingCondition(publicKey, nonce, fee) {
-  const pubKeyBytes = hexToBytes(publicKey);
-  const signer = hashP2PKH(pubKeyBytes);
+var EMPTY_SIG = bytesToHex2(new Uint8Array(RECOVERABLE_ECDSA_SIG_LENGTH_BYTES2));
+function createSingleSigSpendingCondition2(publicKey, nonce, fee) {
+  const pubKeyBytes = hexToBytes2(publicKey);
+  const signer = hashP2PKH2(pubKeyBytes);
   const isCompressed = pubKeyBytes.length === 33;
   return {
-    hashMode: AddressHashMode.P2PKH,
+    hashMode: AddressHashMode2.P2PKH,
     signer,
     nonce,
     fee,
-    keyEncoding: isCompressed ? PubKeyEncoding.Compressed : PubKeyEncoding.Uncompressed,
+    keyEncoding: isCompressed ? PubKeyEncoding2.Compressed : PubKeyEncoding2.Uncompressed,
     signature: EMPTY_SIG
   };
 }
-function createStandardAuth(spendingCondition) {
-  return { authType: AuthType.Standard, spendingCondition };
+function createStandardAuth2(spendingCondition) {
+  return { authType: AuthType2.Standard, spendingCondition };
 }
-function createSponsoredAuth(spendingCondition, sponsorSpendingCondition) {
+function createSponsoredAuth2(spendingCondition, sponsorSpendingCondition) {
   return {
-    authType: AuthType.Sponsored,
+    authType: AuthType2.Sponsored,
     spendingCondition,
-    sponsorSpendingCondition: sponsorSpendingCondition ?? createSingleSigSpendingCondition("0".repeat(66), 0n, 0n)
+    sponsorSpendingCondition: sponsorSpendingCondition ?? createSingleSigSpendingCondition2("0".repeat(66), 0n, 0n)
   };
 }
 function clearCondition(condition) {
@@ -79,42 +79,42 @@ function clearCondition(condition) {
 }
 function sponsorSigningSentinel() {
   return {
-    hashMode: AddressHashMode.P2PKH,
+    hashMode: AddressHashMode2.P2PKH,
     signer: "00".repeat(20),
     nonce: 0n,
     fee: 0n,
-    keyEncoding: PubKeyEncoding.Compressed,
+    keyEncoding: PubKeyEncoding2.Compressed,
     signature: EMPTY_SIG
   };
 }
 function intoInitialSighashAuth(auth) {
-  if (auth.authType === AuthType.Standard) {
-    return createStandardAuth(clearCondition(auth.spendingCondition));
+  if (auth.authType === AuthType2.Standard) {
+    return createStandardAuth2(clearCondition(auth.spendingCondition));
   }
-  return createSponsoredAuth(clearCondition(auth.spendingCondition), sponsorSigningSentinel());
+  return createSponsoredAuth2(clearCondition(auth.spendingCondition), sponsorSigningSentinel());
 }
-function sigHashPreSign(curSigHash, authType, fee, nonce) {
-  const data = concatBytes(hexToBytes(curSigHash), new Uint8Array([authType]), intToBytes(fee, 8), intToBytes(nonce, 8));
-  return txidFromBytes(data);
+function sigHashPreSign2(curSigHash, authType, fee, nonce) {
+  const data = concatBytes2(hexToBytes2(curSigHash), new Uint8Array([authType]), intToBytes2(fee, 8), intToBytes2(nonce, 8));
+  return txidFromBytes2(data);
 }
-function sigHashPostSign(curSigHash, pubKeyEncoding, signature) {
-  const data = concatBytes(hexToBytes(curSigHash), new Uint8Array([pubKeyEncoding]), hexToBytes(signature));
-  return txidFromBytes(data);
+function sigHashPostSign2(curSigHash, pubKeyEncoding, signature) {
+  const data = concatBytes2(hexToBytes2(curSigHash), new Uint8Array([pubKeyEncoding]), hexToBytes2(signature));
+  return txidFromBytes2(data);
 }
 function signWithKey(privateKey, messageHash) {
-  const keyBytes = hexToBytes(privateKey).slice(0, 32);
+  const keyBytes = hexToBytes2(privateKey).slice(0, 32);
   const sig = sign(messageHash, keyBytes, { lowS: true });
-  const recoveryIdHex = intToHex(sig.recovery, 1);
+  const recoveryIdHex = intToHex2(sig.recovery, 1);
   return recoveryIdHex + sig.toCompactHex();
 }
-function nextSignature(curSigHash, authType, fee, nonce, privateKey) {
-  const sigHashPre = sigHashPreSign(curSigHash, authType, fee, nonce);
-  const keyBytes = hexToBytes(privateKey).slice(0, 32);
+function nextSignature2(curSigHash, authType, fee, nonce, privateKey) {
+  const sigHashPre = sigHashPreSign2(curSigHash, authType, fee, nonce);
+  const keyBytes = hexToBytes2(privateKey).slice(0, 32);
   const pubKey = nobleGetPublicKey(keyBytes, true);
   const isCompressed = pubKey.length === 33;
-  const pubKeyEncoding = isCompressed ? PubKeyEncoding.Compressed : PubKeyEncoding.Uncompressed;
+  const pubKeyEncoding = isCompressed ? PubKeyEncoding2.Compressed : PubKeyEncoding2.Uncompressed;
   const nextSig = signWithKey(privateKey, sigHashPre);
-  const nextSigHash = sigHashPostSign(sigHashPre, pubKeyEncoding, nextSig);
+  const nextSigHash = sigHashPostSign2(sigHashPre, pubKeyEncoding, nextSig);
   return { nextSig, nextSigHash };
 }
 
@@ -124,33 +124,33 @@ import {
   sign as nobleSign
 } from "@noble/secp256k1";
 var OP_CHECKMULTISIG = 174;
-function isNonSequential(hashMode) {
+function isNonSequential2(hashMode) {
   return (hashMode & 4) !== 0;
 }
 function makeRedeemScript(publicKeys, signaturesRequired) {
   const parts = [];
   parts.push(new Uint8Array([80 + signaturesRequired]));
   for (const pk of publicKeys) {
-    const pkBytes = hexToBytes(pk);
+    const pkBytes = hexToBytes2(pk);
     parts.push(new Uint8Array([pkBytes.length]));
     parts.push(pkBytes);
   }
   parts.push(new Uint8Array([80 + publicKeys.length]));
   parts.push(new Uint8Array([OP_CHECKMULTISIG]));
-  return concatBytes(...parts);
+  return concatBytes2(...parts);
 }
-function makeMultiSigAddress(publicKeys, signaturesRequired, chain) {
+function makeMultiSigAddress2(publicKeys, signaturesRequired, chain) {
   if (signaturesRequired < 1 || signaturesRequired > publicKeys.length) {
     throw new Error(`signaturesRequired must be between 1 and ${publicKeys.length}`);
   }
   const redeemScript = makeRedeemScript(publicKeys, signaturesRequired);
-  const signer = hash160(redeemScript);
+  const signer = hash1602(redeemScript);
   const version = chain?.addressVersion?.multiSig ?? 20;
-  return c32address(version, bytesToHex(signer));
+  return c32address2(version, bytesToHex2(signer));
 }
-function createMultiSigSpendingCondition(publicKeys, signaturesRequired, nonce, fee, hashMode = AddressHashMode.P2SH) {
+function createMultiSigSpendingCondition2(publicKeys, signaturesRequired, nonce, fee, hashMode = AddressHashMode2.P2SH) {
   const redeemScript = makeRedeemScript(publicKeys, signaturesRequired);
-  const signer = bytesToHex(hash160(redeemScript));
+  const signer = bytesToHex2(hash1602(redeemScript));
   return {
     hashMode,
     signer,
@@ -165,33 +165,33 @@ function initialSigHash(tx) {
     ...tx,
     auth: intoInitialSighashAuth(tx.auth)
   };
-  return txidFromBytes(serializeTransaction(cleared));
+  return txidFromBytes2(serializeTransaction2(cleared));
 }
 function nonSequentialPreSignHash(tx) {
   const condition = tx.auth.spendingCondition;
   const initHash = initialSigHash(tx);
-  return sigHashPreSign(initHash, AuthType.Standard, condition.fee, condition.nonce);
+  return sigHashPreSign2(initHash, AuthType2.Standard, condition.fee, condition.nonce);
 }
-function replayMultiSigSigHash(tx) {
+function replayMultiSigSigHash2(tx) {
   const condition = tx.auth.spendingCondition;
-  if (isNonSequential(condition.hashMode)) {
+  if (isNonSequential2(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 = sigHashPostSign2(curSigHash, field.pubKeyEncoding, field.data);
     }
-    return curSigHash2;
+    return curSigHash;
   }
   let curSigHash = initialSigHash(tx);
   for (const field of condition.fields) {
-    const preSign = sigHashPreSign(curSigHash, AuthType.Standard, condition.fee, condition.nonce);
-    curSigHash = sigHashPostSign(preSign, field.pubKeyEncoding, field.data);
+    const preSign = sigHashPreSign2(curSigHash, AuthType2.Standard, condition.fee, condition.nonce);
+    curSigHash = sigHashPostSign2(preSign, field.pubKeyEncoding, field.data);
   }
   return curSigHash;
 }
-function signMultiSig(tx, privateKey, publicKeys) {
-  const keyBytes = hexToBytes(privateKey).slice(0, 32);
-  const signerPubKey = bytesToHex(nobleGetPublicKey2(keyBytes, true));
+function signMultiSig2(tx, privateKey, publicKeys) {
+  const keyBytes = hexToBytes2(privateKey).slice(0, 32);
+  const signerPubKey = bytesToHex2(nobleGetPublicKey2(keyBytes, true));
   const signerIndex = publicKeys.findIndex((pk) => pk === signerPubKey);
   if (signerIndex === -1) {
     throw new Error("Private key does not correspond to any signer in the multi-sig");
@@ -199,7 +199,7 @@ function signMultiSig(tx, privateKey, publicKeys) {
   const condition = {
     ...tx.auth.spendingCondition
   };
-  if (isNonSequential(condition.hashMode)) {
+  if (isNonSequential2(condition.hashMode)) {
     return signNonSequential(tx, condition, privateKey);
   }
   return signSequential(tx, condition, privateKey, publicKeys, signerIndex);
@@ -207,13 +207,13 @@ function signMultiSig(tx, privateKey, publicKeys) {
 function signNonSequential(tx, condition, privateKey) {
   const fields = [...condition.fields];
   const preSignHash = nonSequentialPreSignHash(tx);
-  const keyBytes = hexToBytes(privateKey).slice(0, 32);
+  const keyBytes = hexToBytes2(privateKey).slice(0, 32);
   const sig = nobleSign(preSignHash, keyBytes, { lowS: true });
-  const recoveryIdHex = intToHex(sig.recovery, 1);
+  const recoveryIdHex = intToHex2(sig.recovery, 1);
   const nextSig = recoveryIdHex + sig.toCompactHex();
   fields.push({
     type: "signature",
-    pubKeyEncoding: PubKeyEncoding.Compressed,
+    pubKeyEncoding: PubKeyEncoding2.Compressed,
     data: nextSig
   });
   const newCondition = { ...condition, fields };
@@ -233,23 +233,23 @@ function signSequential(tx, condition, privateKey, publicKeys, signerIndex) {
   const fields = [...condition.fields];
   let curSigHash = initialSigHash(tx);
   for (const field of fields) {
-    const preSign = sigHashPreSign(curSigHash, AuthType.Standard, condition.fee, condition.nonce);
-    curSigHash = sigHashPostSign(preSign, field.pubKeyEncoding, field.data);
+    const preSign = sigHashPreSign2(curSigHash, AuthType2.Standard, condition.fee, condition.nonce);
+    curSigHash = sigHashPostSign2(preSign, field.pubKeyEncoding, field.data);
   }
   for (let i = fields.length;i < signerIndex; i++) {
     const pubKeyField = {
       type: "publicKey",
-      pubKeyEncoding: PubKeyEncoding.Compressed,
+      pubKeyEncoding: PubKeyEncoding2.Compressed,
       data: publicKeys[i]
     };
     fields.push(pubKeyField);
-    const preSign = sigHashPreSign(curSigHash, AuthType.Standard, condition.fee, condition.nonce);
-    curSigHash = sigHashPostSign(preSign, pubKeyField.pubKeyEncoding, pubKeyField.data);
+    const preSign = sigHashPreSign2(curSigHash, AuthType2.Standard, condition.fee, condition.nonce);
+    curSigHash = sigHashPostSign2(preSign, pubKeyField.pubKeyEncoding, pubKeyField.data);
   }
-  const { nextSig, nextSigHash } = nextSignature(curSigHash, AuthType.Standard, condition.fee, condition.nonce, privateKey);
+  const { nextSig, nextSigHash } = nextSignature2(curSigHash, AuthType2.Standard, condition.fee, condition.nonce, privateKey);
   fields.push({
     type: "signature",
-    pubKeyEncoding: PubKeyEncoding.Compressed,
+    pubKeyEncoding: PubKeyEncoding2.Compressed,
     data: nextSig
   });
   curSigHash = nextSigHash;
@@ -267,7 +267,7 @@ function signSequential(tx, condition, privateKey, publicKeys, signerIndex) {
     }
   };
 }
-async function signMultiSigWithAccount(tx, account, publicKeys) {
+async function signMultiSigWithAccount2(tx, account, publicKeys) {
   const signerPubKey = account.publicKey;
   const signerIndex = publicKeys.findIndex((pk) => pk === signerPubKey);
   if (signerIndex === -1) {
@@ -276,7 +276,7 @@ async function signMultiSigWithAccount(tx, account, publicKeys) {
   const condition = {
     ...tx.auth.spendingCondition
   };
-  if (isNonSequential(condition.hashMode)) {
+  if (isNonSequential2(condition.hashMode)) {
     return signNonSequentialWithAccount(tx, condition, account);
   }
   return signSequentialWithAccount(tx, condition, account, publicKeys, signerIndex);
@@ -284,11 +284,11 @@ async function signMultiSigWithAccount(tx, account, publicKeys) {
 async function signNonSequentialWithAccount(tx, condition, account) {
   const fields = [...condition.fields];
   const preSignHash = nonSequentialPreSignHash(tx);
-  const sigBytes = await account.sign(hexToBytes(preSignHash));
-  const nextSig = bytesToHex(sigBytes);
+  const sigBytes = await account.sign(hexToBytes2(preSignHash));
+  const nextSig = bytesToHex2(sigBytes);
   fields.push({
     type: "signature",
-    pubKeyEncoding: PubKeyEncoding.Compressed,
+    pubKeyEncoding: PubKeyEncoding2.Compressed,
     data: nextSig
   });
   const newCondition = { ...condition, fields };
@@ -301,26 +301,26 @@ 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 = sigHashPreSign2(curSigHash, AuthType2.Standard, condition.fee, condition.nonce);
+    curSigHash = sigHashPostSign2(preSign, field.pubKeyEncoding, field.data);
   }
   for (let i = fields.length;i < signerIndex; i++) {
     const pubKeyField = {
       type: "publicKey",
-      pubKeyEncoding: PubKeyEncoding.Compressed,
+      pubKeyEncoding: PubKeyEncoding2.Compressed,
       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 = sigHashPreSign2(curSigHash, AuthType2.Standard, condition.fee, condition.nonce);
+    curSigHash = sigHashPostSign2(preSign, pubKeyField.pubKeyEncoding, pubKeyField.data);
   }
-  const preSign = sigHashPreSign(curSigHash, AuthType.Standard, condition.fee, condition.nonce);
-  const sigBytes = await account.sign(hexToBytes(preSign));
-  const nextSig = bytesToHex(sigBytes);
-  const nextSigHash = sigHashPostSign(preSign, PubKeyEncoding.Compressed, nextSig);
+  const preSign = sigHashPreSign2(curSigHash, AuthType2.Standard, condition.fee, condition.nonce);
+  const sigBytes = await account.sign(hexToBytes2(preSign));
+  const nextSig = bytesToHex2(sigBytes);
+  const nextSigHash = sigHashPostSign2(preSign, PubKeyEncoding2.Compressed, nextSig);
   fields.push({
     type: "signature",
-    pubKeyEncoding: PubKeyEncoding.Compressed,
+    pubKeyEncoding: PubKeyEncoding2.Compressed,
     data: nextSig
   });
   curSigHash = nextSigHash;
@@ -338,12 +338,12 @@ async function signSequentialWithAccount(tx, condition, account, publicKeys, sig
     }
   };
 }
-function finalizeMultiSig(tx, publicKeys) {
+function finalizeMultiSig2(tx, publicKeys) {
   const condition = tx.auth.spendingCondition;
-  if (isNonSequential(condition.hashMode)) {
+  if (isNonSequential2(condition.hashMode)) {
     return tx;
   }
-  const curSigHash = replayMultiSigSigHash(tx);
+  const curSigHash = replayMultiSigSigHash2(tx);
   const finalCondition = finalizeMultiSigCondition(condition, publicKeys, curSigHash);
   return {
     ...tx,
@@ -359,18 +359,18 @@ function finalizeMultiSigCondition(condition, publicKeys, curSigHash) {
   for (let i = fields.length;i < publicKeys.length; i++) {
     const pubKeyField = {
       type: "publicKey",
-      pubKeyEncoding: PubKeyEncoding.Compressed,
+      pubKeyEncoding: PubKeyEncoding2.Compressed,
       data: publicKeys[i]
     };
     fields.push(pubKeyField);
-    const preSign = sigHashPreSign(sigHash, AuthType.Standard, condition.fee, condition.nonce);
-    sigHash = sigHashPostSign(preSign, pubKeyField.pubKeyEncoding, pubKeyField.data);
+    const preSign = sigHashPreSign2(sigHash, AuthType2.Standard, condition.fee, condition.nonce);
+    sigHash = sigHashPostSign2(preSign, pubKeyField.pubKeyEncoding, pubKeyField.data);
   }
   return { ...condition, fields };
 }
-function combineMultiSigSignatures(baseTx, signedTxs) {
+function combineMultiSigSignatures2(baseTx, signedTxs) {
   const condition = baseTx.auth.spendingCondition;
-  if (!isNonSequential(condition.hashMode)) {
+  if (!isNonSequential2(condition.hashMode)) {
     throw new Error("combineMultiSigSignatures only works with non-sequential hash modes (SIP-027)");
   }
   const seenSigs = new Set;
@@ -400,47 +400,47 @@ function combineMultiSigSignatures(baseTx, signedTxs) {
 // src/transactions/build.ts
 function resolvePcMode(mode) {
   if (mode === "allow")
-    return PostConditionModeWire.Allow;
+    return PostConditionModeWire2.Allow;
   if (mode === "originator")
-    return PostConditionModeWire.Originator;
-  return PostConditionModeWire.Deny;
+    return PostConditionModeWire2.Originator;
+  return PostConditionModeWire2.Deny;
 }
 function convertPostConditions(pcs) {
   if (!pcs || pcs.length === 0)
     return [];
-  return pcs.map((pc) => convertPostCondition(typeof pc === "string" ? fromHex(pc) : pc));
+  return pcs.map((pc) => convertPostCondition(typeof pc === "string" ? fromHex2(pc) : pc));
 }
 function resolveSpendingCondition(opts, nonce, fee) {
   if (opts.publicKeys) {
-    return createMultiSigSpendingCondition(opts.publicKeys, opts.signaturesRequired, nonce, fee, opts.hashMode);
+    return createMultiSigSpendingCondition2(opts.publicKeys, opts.signaturesRequired, nonce, fee, opts.hashMode);
   }
-  return createSingleSigSpendingCondition(opts.publicKey, nonce, fee);
+  return createSingleSigSpendingCondition2(opts.publicKey, nonce, fee);
 }
 function resolveAuth(spendingCondition, sponsored) {
-  return sponsored ? createSponsoredAuth(spendingCondition) : createStandardAuth(spendingCondition);
+  return sponsored ? createSponsoredAuth2(spendingCondition) : createStandardAuth2(spendingCondition);
 }
 function resolveVersionAndChainId(chain) {
   if (!chain)
     return { version: 0, chainId: 1 };
   return { version: chain.transactionVersion, chainId: chain.id };
 }
-function buildTokenTransfer(options) {
+function buildTokenTransfer2(options) {
   const { version, chainId } = resolveVersionAndChainId(options.chain);
-  const fee = intToBigInt(options.fee);
-  const nonce = intToBigInt(options.nonce);
+  const fee = intToBigInt2(options.fee);
+  const nonce = intToBigInt2(options.nonce);
   const spendingCondition = resolveSpendingCondition(options, nonce, fee);
-  const recipient = Cl.principal(options.recipient);
+  const recipient = Cl2.principal(options.recipient);
   const tx = {
     version,
     chainId,
     auth: resolveAuth(spendingCondition, options.sponsored),
-    anchorMode: AnchorMode.Any,
+    anchorMode: AnchorMode2.Any,
     postConditionMode: resolvePcMode(options.postConditionMode),
     postConditions: convertPostConditions(options.postConditions),
     payload: {
-      payloadType: PayloadType.TokenTransfer,
+      payloadType: PayloadType2.TokenTransfer,
       recipient,
-      amount: intToBigInt(options.amount),
+      amount: intToBigInt2(options.amount),
       memo: options.memo ?? ""
     }
   };
@@ -449,20 +449,20 @@ function buildTokenTransfer(options) {
   }
   return tx;
 }
-function buildContractCall(options) {
+function buildContractCall2(options) {
   const { version, chainId } = resolveVersionAndChainId(options.chain);
-  const fee = intToBigInt(options.fee);
-  const nonce = intToBigInt(options.nonce);
+  const fee = intToBigInt2(options.fee);
+  const nonce = intToBigInt2(options.nonce);
   const spendingCondition = resolveSpendingCondition(options, nonce, fee);
   const tx = {
     version,
     chainId,
     auth: resolveAuth(spendingCondition, options.sponsored),
-    anchorMode: AnchorMode.Any,
+    anchorMode: AnchorMode2.Any,
     postConditionMode: resolvePcMode(options.postConditionMode),
     postConditions: convertPostConditions(options.postConditions),
     payload: {
-      payloadType: PayloadType.ContractCall,
+      payloadType: PayloadType2.ContractCall,
       contractAddress: options.contractAddress,
       contractName: options.contractName,
       functionName: options.functionName,
@@ -474,21 +474,21 @@ function buildContractCall(options) {
   }
   return tx;
 }
-function buildContractDeploy(options) {
+function buildContractDeploy2(options) {
   const { version, chainId } = resolveVersionAndChainId(options.chain);
-  const fee = intToBigInt(options.fee);
-  const nonce = intToBigInt(options.nonce);
+  const fee = intToBigInt2(options.fee);
+  const nonce = intToBigInt2(options.nonce);
   const spendingCondition = resolveSpendingCondition(options, nonce, fee);
-  const clarityVersion = options.clarityVersion ?? ClarityVersion.Clarity4;
+  const clarityVersion = options.clarityVersion ?? ClarityVersion2.Clarity4;
   const tx = {
     version,
     chainId,
     auth: resolveAuth(spendingCondition, options.sponsored),
-    anchorMode: AnchorMode.Any,
+    anchorMode: AnchorMode2.Any,
     postConditionMode: resolvePcMode(options.postConditionMode),
     postConditions: convertPostConditions(options.postConditions),
     payload: {
-      payloadType: PayloadType.VersionedSmartContract,
+      payloadType: PayloadType2.VersionedSmartContract,
       clarityVersion,
       contractName: options.contractName,
       codeBody: options.codeBody
@@ -502,19 +502,19 @@ function buildContractDeploy(options) {
 
 // src/transactions/signer.ts
 function txid(tx) {
-  return txidFromBytes(serializeTransaction(tx));
+  return txidFromBytes2(serializeTransaction2(tx));
 }
-function signBegin(tx) {
+function signBegin2(tx) {
   const cleared = {
     ...tx,
     auth: intoInitialSighashAuth(tx.auth)
   };
   return txid(cleared);
 }
-function signTransaction(tx, privateKey) {
-  const sigHash = signBegin(tx);
+function signTransaction2(tx, privateKey) {
+  const sigHash = signBegin2(tx);
   const condition = tx.auth.spendingCondition;
-  const { nextSig } = nextSignature(sigHash, AuthType.Standard, condition.fee, condition.nonce, privateKey);
+  const { nextSig } = nextSignature2(sigHash, AuthType2.Standard, condition.fee, condition.nonce, privateKey);
   return {
     ...tx,
     auth: {
@@ -526,12 +526,12 @@ function signTransaction(tx, privateKey) {
     }
   };
 }
-async function signTransactionWithAccount(tx, account) {
-  const sigHash = signBegin(tx);
+async function signTransactionWithAccount2(tx, account) {
+  const sigHash = signBegin2(tx);
   const condition = tx.auth.spendingCondition;
-  const sigHashPre = sigHashPreSign(sigHash, AuthType.Standard, condition.fee, condition.nonce);
-  const sigBytes = await account.sign(hexToBytes(sigHashPre));
-  const nextSig = bytesToHex(sigBytes);
+  const sigHashPre = sigHashPreSign2(sigHash, AuthType2.Standard, condition.fee, condition.nonce);
+  const sigBytes = await account.sign(hexToBytes2(sigHashPre));
+  const nextSig = bytesToHex2(sigBytes);
   return {
     ...tx,
     auth: {
@@ -543,27 +543,27 @@ async function signTransactionWithAccount(tx, account) {
     }
   };
 }
-function getTransactionId(tx) {
+function getTransactionId2(tx) {
   return txid(tx);
 }
-function getOriginSigHash(tx) {
+function getOriginSigHash2(tx) {
   const condition = tx.auth.spendingCondition;
   if ("fields" in condition) {
-    return replayMultiSigSigHash(tx);
+    return replayMultiSigSigHash2(tx);
   }
-  const initialSigHash2 = signBegin(tx);
+  const initialSigHash = signBegin2(tx);
   const sc = condition;
-  const preSign = sigHashPreSign(initialSigHash2, AuthType.Standard, sc.fee, sc.nonce);
-  return sigHashPostSign(preSign, sc.keyEncoding, sc.signature);
+  const preSign = sigHashPreSign2(initialSigHash, AuthType2.Standard, sc.fee, sc.nonce);
+  return sigHashPostSign2(preSign, sc.keyEncoding, sc.signature);
 }
-function signSponsor(tx, privateKey) {
-  if (tx.auth.authType !== AuthType.Sponsored) {
+function signSponsor2(tx, privateKey) {
+  if (tx.auth.authType !== AuthType2.Sponsored) {
     throw new Error("Transaction must be sponsored");
   }
   const auth = tx.auth;
   const sponsorCondition = auth.sponsorSpendingCondition;
-  const originSigHash = getOriginSigHash(tx);
-  const { nextSig } = nextSignature(originSigHash, AuthType.Sponsored, sponsorCondition.fee, sponsorCondition.nonce, privateKey);
+  const originSigHash = getOriginSigHash2(tx);
+  const { nextSig } = nextSignature2(originSigHash, AuthType2.Sponsored, sponsorCondition.fee, sponsorCondition.nonce, privateKey);
   return {
     ...tx,
     auth: {
@@ -575,16 +575,16 @@ function signSponsor(tx, privateKey) {
     }
   };
 }
-async function signSponsorWithAccount(tx, account) {
-  if (tx.auth.authType !== AuthType.Sponsored) {
+async function signSponsorWithAccount2(tx, account) {
+  if (tx.auth.authType !== AuthType2.Sponsored) {
     throw new Error("Transaction must be sponsored");
   }
   const auth = tx.auth;
   const sponsorCondition = auth.sponsorSpendingCondition;
-  const originSigHash = getOriginSigHash(tx);
-  const sigHashPre = sigHashPreSign(originSigHash, AuthType.Sponsored, sponsorCondition.fee, sponsorCondition.nonce);
-  const sigBytes = await account.sign(hexToBytes(sigHashPre));
-  const nextSig = bytesToHex(sigBytes);
+  const originSigHash = getOriginSigHash2(tx);
+  const sigHashPre = sigHashPreSign2(originSigHash, AuthType2.Sponsored, sponsorCondition.fee, sponsorCondition.nonce);
+  const sigBytes = await account.sign(hexToBytes2(sigHashPre));
+  const nextSig = bytesToHex2(sigBytes);
   return {
     ...tx,
     auth: {
@@ -597,7 +597,7 @@ async function signSponsorWithAccount(tx, account) {
   };
 }
 
-export { createSingleSigSpendingCondition, createStandardAuth, createSponsoredAuth, sigHashPreSign, sigHashPostSign, nextSignature, isNonSequential, makeMultiSigAddress, createMultiSigSpendingCondition, replayMultiSigSigHash, signMultiSig, signMultiSigWithAccount, finalizeMultiSig, combineMultiSigSignatures, buildTokenTransfer, buildContractCall, buildContractDeploy, signBegin, signTransaction, signTransactionWithAccount, getTransactionId, getOriginSigHash, signSponsor, signSponsorWithAccount };
+export { createSingleSigSpendingCondition2, createStandardAuth2, createSponsoredAuth2, sigHashPreSign2, sigHashPostSign2, nextSignature2, isNonSequential2, makeMultiSigAddress2, createMultiSigSpendingCondition2, replayMultiSigSigHash2, signMultiSig2, signMultiSigWithAccount2, finalizeMultiSig2, combineMultiSigSignatures2, buildTokenTransfer2, buildContractCall2, buildContractDeploy2, signBegin2, signTransaction2, signTransactionWithAccount2, getTransactionId2, getOriginSigHash2, signSponsor2, signSponsorWithAccount2 };
 
-//# debugId=88CDB78728D956D464756E2164756E21
-//# sourceMappingURL=stacks-esm-r9q4wnyw.js.map
+//# debugId=603A3254758ACC9C64756E2164756E21
+//# sourceMappingURL=stacks-esm-cmtj5vky.js.map