@leather.io/stacks 1.19.3 → 1.19.4

package/dist/index.js

@@ -1,826 +1,570 @@
-// src/message-signing.ts
-import { bytesToHex } from "@noble/hashes/utils";
+import { bytesToHex, hexToBytes } from "@noble/hashes/utils";
 import { hashMessage } from "@stacks/encryption";
-import {
-  privateKeyToPublic,
-  signMessageHashRsv,
-  signStructuredData
-} from "@stacks/transactions";
+import { BytesReader, ClarityType, MEMO_MAX_LENGTH_BYTES, Pc, TransactionSigner, bufferCVFromString, codeBodyString, compressPrivateKey, createAddress, createMemoString, createStacksPublicKey, deserializeCV, deserializePostConditionWire, getAddressFromPrivateKey, makeRandomPrivKey, makeUnsignedContractCall, makeUnsignedContractDeploy, makeUnsignedSTXTokenTransfer, noneCV, postConditionToWire, privateKeyToPublic, publicKeyToAddressSingleSig, serializeCV, serializePayload, signMessageHashRsv, signStructuredData, someCV, standardPrincipalCVFromAddress, uintCV } from "@stacks/transactions";
+import { DerivationPathDepth, createDescriptor, createKeyOriginPath, decomposeDescriptor, deriveRootKeychainFromMnemonic, extractAddressIndexFromPath, extractKeyFromDescriptor } from "@leather.io/crypto";
+import { ChainId } from "@stacks/network";
+import { assertIsTruthy, assertUnreachable, isDefined, isEmptyString, isString, isUndefined, stxToMicroStx, toHexString } from "@leather.io/utils";
+import { bytesToHex as bytesToHex$1 } from "@stacks/common";
+import BigNumber from "bignumber.js";
+import { c32addressDecode } from "c32check";
+import { z } from "zod";
+import { ChainId as ChainId$1 } from "@leather.io/models";
+
+//#region src/message-signing.ts
 function signMessage(message, privateKey) {
-  const hash = hashMessage(message);
-  return {
-    signature: signMessageHashRsv({ privateKey, messageHash: bytesToHex(hash) }),
-    publicKey: privateKeyToPublic(privateKey)
-  };
+	return {
+		signature: signMessageHashRsv({
+			privateKey,
+			messageHash: bytesToHex(hashMessage(message))
+		}),
+		publicKey: privateKeyToPublic(privateKey)
+	};
 }
 function signStructuredDataMessage(message, domain, privateKey) {
-  const signature = signStructuredData({
-    message,
-    domain,
-    privateKey
-  });
-  return {
-    signature,
-    publicKey: privateKeyToPublic(privateKey)
-  };
+	return {
+		signature: signStructuredData({
+			message,
+			domain,
+			privateKey
+		}),
+		publicKey: privateKeyToPublic(privateKey)
+	};
 }
 
-// src/mocks/mocks.ts
-var TEST_ACCOUNT_1_STX_ADDRESS = "SPS8CKF63P16J28AYF7PXW9E5AACH0NZNTEFWSFE";
-var TEST_ACCOUNT_2_STX_ADDRESS = "SPXH3HNBPM5YP15VH16ZXZ9AX6CK289K3MCXRKCB";
-var TEST_TESTNET_ACCOUNT_2_STX_ADDRESS = "STXH3HNBPM5YP15VH16ZXZ9AX6CK289K3NVR9T1P";
-var TEST_ACCOUNT_1_STX_ADDRESS_SM = "SM3FBR6RDNZYC5K4TZWV9VZJ6NGA4VX3YBQ8X2PQ";
-var TEST_TESTNET_ACCOUNT_2_STX_ADDRESS_SN = "SNXH3HNBPM5YP15VH16ZXZ9AX6CK289K3NVR9T1P";
+//#endregion
+//#region src/mocks/mocks.ts
+const TEST_ACCOUNT_1_STX_ADDRESS = "SPS8CKF63P16J28AYF7PXW9E5AACH0NZNTEFWSFE";
+const TEST_ACCOUNT_2_STX_ADDRESS = "SPXH3HNBPM5YP15VH16ZXZ9AX6CK289K3MCXRKCB";
+const TEST_TESTNET_ACCOUNT_2_STX_ADDRESS = "STXH3HNBPM5YP15VH16ZXZ9AX6CK289K3NVR9T1P";
+const TEST_ACCOUNT_1_STX_ADDRESS_SM = "SM3FBR6RDNZYC5K4TZWV9VZJ6NGA4VX3YBQ8X2PQ";
+const TEST_TESTNET_ACCOUNT_2_STX_ADDRESS_SN = "SNXH3HNBPM5YP15VH16ZXZ9AX6CK289K3NVR9T1P";
 
-// src/signer/signer.ts
-import {
-  TransactionSigner,
-  createStacksPublicKey,
-  publicKeyToAddressSingleSig
-} from "@stacks/transactions";
-import {
-  decomposeDescriptor,
-  deriveRootKeychainFromMnemonic,
-  extractKeyFromDescriptor
-} from "@leather.io/crypto";
-
-// src/stacks.utils.ts
-import { ChainId } from "@stacks/network";
-import {
-  compressPrivateKey,
-  privateKeyToPublic as privateKeyToPublic2
-} from "@stacks/transactions";
-import {
-  DerivationPathDepth,
-  createDescriptor,
-  createKeyOriginPath,
-  extractAddressIndexFromPath
-} from "@leather.io/crypto";
-import { assertIsTruthy, isString, toHexString } from "@leather.io/utils";
-var stxDerivationWithAccount = `m/44'/5757'/0'/0/{account}`;
+//#endregion
+//#region src/stacks.utils.ts
+const stxDerivationWithAccount = `m/44'/5757'/0'/0/{account}`;
 function makeAccountIndexDerivationPathFactory(derivationPath) {
-  return (account) => derivationPath.replace("{account}", account.toString());
+	return (account) => derivationPath.replace("{account}", account.toString());
 }
 function extractStacksDerivationPathAccountIndex(path) {
-  if (!path.includes("5757")) throw new Error("Not a valid Stacks derivation path: " + path);
-  return extractAddressIndexFromPath(path);
+	if (!path.includes("5757")) throw new Error("Not a valid Stacks derivation path: " + path);
+	return extractAddressIndexFromPath(path);
 }
-var makeStxDerivationPath = makeAccountIndexDerivationPathFactory(stxDerivationWithAccount);
+/**
+* Stacks accounts always use the same derivation path, regardless of network
+*/
+const makeStxDerivationPath = makeAccountIndexDerivationPathFactory(stxDerivationWithAccount);
 function stacksChainIdToCoreNetworkMode(chainId) {
-  return whenStacksChainId(chainId)({
-    [ChainId.Mainnet]: "mainnet",
-    [ChainId.Testnet]: "testnet"
-  });
+	return whenStacksChainId(chainId)({
+		[ChainId.Mainnet]: "mainnet",
+		[ChainId.Testnet]: "testnet"
+	});
 }
 function whenStacksChainId(chainId) {
-  return (chainIdMap) => chainIdMap[chainId];
+	return (chainIdMap) => chainIdMap[chainId];
 }
 function deriveStxPrivateKey({ keychain, index }) {
-  if (keychain.depth !== DerivationPathDepth.Root) throw new Error("Root keychain must be depth 0");
-  const accountKeychain = keychain.derive(makeStxDerivationPath(index));
-  assertIsTruthy(accountKeychain.privateKey);
-  return compressPrivateKey(accountKeychain.privateKey);
+	if (keychain.depth !== DerivationPathDepth.Root) throw new Error("Root keychain must be depth 0");
+	const accountKeychain = keychain.derive(makeStxDerivationPath(index));
+	assertIsTruthy(accountKeychain.privateKey);
+	return compressPrivateKey(accountKeychain.privateKey);
 }
-function deriveStxPublicKey({
-  keychain,
-  index
-}) {
-  return privateKeyToPublic2(deriveStxPrivateKey({ keychain, index }));
+function deriveStxPublicKey({ keychain, index }) {
+	return privateKeyToPublic(deriveStxPrivateKey({
+		keychain,
+		index
+	}));
 }
 function stacksRootKeychainToAccountDescriptor(keychain, accountIndex) {
-  const fingerprint = toHexString(keychain.fingerprint);
-  const publicKey = deriveStxPublicKey({ keychain, index: accountIndex });
-  return createDescriptor(
-    createKeyOriginPath(fingerprint, makeStxDerivationPath(accountIndex)),
-    publicKey
-  );
+	const fingerprint = toHexString(keychain.fingerprint);
+	const publicKey = deriveStxPublicKey({
+		keychain,
+		index: accountIndex
+	});
+	return createDescriptor(createKeyOriginPath(fingerprint, makeStxDerivationPath(accountIndex)), publicKey);
 }
 function getStacksBurnAddress(chainIdChainId) {
-  switch (chainIdChainId) {
-    case ChainId.Mainnet:
-      return "SP00000000000003SCNSJTCSE62ZF4MSE";
-    case ChainId.Testnet:
-    default:
-      return "ST000000000000000000002AMW42H";
-  }
+	switch (chainIdChainId) {
+		case ChainId.Mainnet: return "SP00000000000003SCNSJTCSE62ZF4MSE";
+		case ChainId.Testnet:
+		default: return "ST000000000000000000002AMW42H";
+	}
 }
 function cleanHex(hexWithMaybePrefix) {
-  if (!isString(hexWithMaybePrefix)) return hexWithMaybePrefix;
-  return hexWithMaybePrefix.startsWith("0x") ? hexWithMaybePrefix.replace("0x", "") : hexWithMaybePrefix;
+	if (!isString(hexWithMaybePrefix)) return hexWithMaybePrefix;
+	return hexWithMaybePrefix.startsWith("0x") ? hexWithMaybePrefix.replace("0x", "") : hexWithMaybePrefix;
 }
 function getPrincipalFromAssetString(assetString) {
-  return assetString.split("::")[0];
+	return assetString.split("::")[0];
 }
 function formatContractId(address, name) {
-  return `${address}.${name}`;
+	return `${address}.${name}`;
 }
-function formatAssetString({
-  contractAddress,
-  contractName,
-  assetName
-}) {
-  return `${contractAddress}.${contractName}::${assetName}`;
+function formatAssetString({ contractAddress, contractName, assetName }) {
+	return `${contractAddress}.${contractName}::${assetName}`;
 }
-function formatContractIdString({
-  contractAddress,
-  contractName
-}) {
-  return `${contractAddress}.${contractName}`;
+function formatContractIdString({ contractAddress, contractName }) {
+	return `${contractAddress}.${contractName}`;
 }
+/**
+* Gets the contract name.
+*
+* @param identifier - [principal].[contract-name] or [principal].[contract-name]::[asset-name]
+*/
 function getStacksContractName(identifier) {
-  if (identifier.includes(".")) {
-    const parts = identifier?.split(".");
-    if (identifier.includes("::")) {
-      return parts[1].split("::")[0];
-    }
-    return parts[1];
-  }
-  return identifier;
-}
+	if (identifier.includes(".")) {
+		const parts = identifier?.split(".");
+		if (identifier.includes("::")) return parts[1].split("::")[0];
+		return parts[1];
+	}
+	return identifier;
+}
+/**
+* Gets the asset name.
+*
+* @param identifier - [principal].[contract-name]::[asset-name]
+*/
 function getStacksContractAssetName(identifier) {
-  if (!identifier.includes("::")) return identifier;
-  return identifier.split("::")[1];
-}
+	if (!identifier.includes("::")) return identifier;
+	return identifier.split("::")[1];
+}
+/**
+* Gets the parts that make up a fully qualified name of an asset.
+*
+* @param identifier - [principal].[contract-name]::[asset-name]
+*/
 function getStacksAssetStringParts(identifier) {
-  if (!identifier.includes(".") && !identifier.includes("::")) {
-    return {
-      contractAddress: identifier,
-      contractAssetName: identifier,
-      contractName: identifier
-    };
-  }
-  const contractAddress = identifier.split(".")[0];
-  const contractAssetName = getStacksContractAssetName(identifier);
-  const contractName = getStacksContractName(identifier);
-  return {
-    contractAddress,
-    contractAssetName,
-    contractName
-  };
+	if (!identifier.includes(".") && !identifier.includes("::")) return {
+		contractAddress: identifier,
+		contractAssetName: identifier,
+		contractName: identifier
+	};
+	return {
+		contractAddress: identifier.split(".")[0],
+		contractAssetName: getStacksContractAssetName(identifier),
+		contractName: getStacksContractName(identifier)
+	};
 }
 
-// src/signer/signer.ts
+//#endregion
+//#region src/signer/signer.ts
 function signStacksTransaction(tx, privateKey) {
-  const signer = new TransactionSigner(tx);
-  signer.signOrigin(privateKey);
-  return tx;
+	new TransactionSigner(tx).signOrigin(privateKey);
+	return tx;
 }
 async function getPrivateKey(keyOrigin, getMnemonicFn) {
-  const { mnemonic, passphrase } = await getMnemonicFn();
-  const keychain = await deriveRootKeychainFromMnemonic(mnemonic, passphrase);
-  return deriveStxPrivateKey({
-    keychain,
-    index: extractStacksDerivationPathAccountIndex(keyOrigin)
-  });
+	const { mnemonic, passphrase } = await getMnemonicFn();
+	return deriveStxPrivateKey({
+		keychain: await deriveRootKeychainFromMnemonic(mnemonic, passphrase),
+		index: extractStacksDerivationPathAccountIndex(keyOrigin)
+	});
 }
 function createSignFnFromMnemonic(keyOrigin, getMnemonicFn) {
-  return async (tx) => {
-    const privateKey = await getPrivateKey(keyOrigin, getMnemonicFn);
-    return signStacksTransaction(tx, privateKey);
-  };
+	return async (tx) => {
+		return signStacksTransaction(tx, await getPrivateKey(keyOrigin, getMnemonicFn));
+	};
 }
 function createSignMessageFnFromMnemonic(keyOrigin, getMnemonicFn) {
-  return async (message) => {
-    const privateKey = await getPrivateKey(keyOrigin, getMnemonicFn);
-    return signMessage(message, privateKey);
-  };
+	return async (message) => {
+		return signMessage(message, await getPrivateKey(keyOrigin, getMnemonicFn));
+	};
 }
 function createSignStructuredDataMessageFnFromMnemonic(keyOrigin, getMnemonicFn) {
-  return async (message, domain) => {
-    const privateKey = await getPrivateKey(keyOrigin, getMnemonicFn);
-    return signStructuredDataMessage(message, domain, privateKey);
-  };
+	return async (message, domain) => {
+		return signStructuredDataMessage(message, domain, await getPrivateKey(keyOrigin, getMnemonicFn));
+	};
 }
 function initalizeStacksSigner(args) {
-  const { descriptor, network, signFn, signMessageFn, signStructuredMessageFn } = args;
-  const publicKey = createStacksPublicKey(extractKeyFromDescriptor(descriptor)).data;
-  return {
-    ...decomposeDescriptor(descriptor),
-    // here we overwrite the accountIndex with the derivation path account index for stx
-    accountIndex: extractStacksDerivationPathAccountIndex(descriptor),
-    publicKey,
-    network,
-    address: publicKeyToAddressSingleSig(publicKey, network),
-    sign: signFn,
-    signMessage: signMessageFn,
-    signStructuredMessage: signStructuredMessageFn
-  };
+	const { descriptor, network, signFn, signMessageFn, signStructuredMessageFn } = args;
+	const publicKey = createStacksPublicKey(extractKeyFromDescriptor(descriptor)).data;
+	return {
+		...decomposeDescriptor(descriptor),
+		accountIndex: extractStacksDerivationPathAccountIndex(descriptor),
+		publicKey,
+		network,
+		address: publicKeyToAddressSingleSig(publicKey, network),
+		sign: signFn,
+		signMessage: signMessageFn,
+		signStructuredMessage: signStructuredMessageFn
+	};
 }
 
-// src/transactions/create-tx-hex.ts
-import { bytesToHex as bytesToHex2 } from "@stacks/common";
-import { Pc, serializeCV } from "@stacks/transactions";
-
-// src/transactions/generate-unsigned-transaction.ts
-import { hexToBytes as hexToBytes2 } from "@noble/hashes/utils";
-import {
-  deserializeCV,
-  makeUnsignedContractCall,
-  makeUnsignedContractDeploy,
-  makeUnsignedSTXTokenTransfer
-} from "@stacks/transactions";
-import BigNumber from "bignumber.js";
-import { assertUnreachable } from "@leather.io/utils";
-
-// src/transactions/post-condition.utils.ts
-import { hexToBytes } from "@noble/hashes/utils";
-import {
-  BytesReader,
-  deserializePostConditionWire,
-  postConditionToWire
-} from "@stacks/transactions";
-import { isString as isString2 } from "@leather.io/utils";
+//#endregion
+//#region src/transactions/post-condition.utils.ts
 function getPostConditionFromString(postCondition) {
-  try {
-    const reader = new BytesReader(hexToBytes(postCondition));
-    return deserializePostConditionWire(reader);
-  } catch {
-    throw new Error("Not a serialized post condition");
-  }
+	try {
+		return deserializePostConditionWire(new BytesReader(hexToBytes(postCondition)));
+	} catch {
+		throw new Error("Not a serialized post condition");
+	}
 }
 function ensurePostConditionWireFormat(postCondition) {
-  if (isString2(postCondition)) return getPostConditionFromString(postCondition);
-  if ("conditionType" in postCondition) return postCondition;
-  return postConditionToWire(postCondition);
+	if (isString(postCondition)) return getPostConditionFromString(postCondition);
+	if ("conditionType" in postCondition) return postCondition;
+	return postConditionToWire(postCondition);
 }
 function getPostCondition(postCondition) {
-  return isString2(postCondition) ? getPostConditionFromString(postCondition) : ensurePostConditionWireFormat(postCondition);
+	return isString(postCondition) ? getPostConditionFromString(postCondition) : ensurePostConditionWireFormat(postCondition);
 }
 function getPostConditions(postConditions) {
-  return postConditions?.map(getPostCondition);
+	return postConditions?.map(getPostCondition);
 }
 
-// src/transactions/transaction.types.ts
-var TransactionTypes = /* @__PURE__ */ ((TransactionTypes2) => {
-  TransactionTypes2["ContractCall"] = "contract_call";
-  TransactionTypes2["ContractDeploy"] = "smart_contract";
-  TransactionTypes2["StxTokenTransfer"] = "token_transfer";
-  return TransactionTypes2;
-})(TransactionTypes || {});
+//#endregion
+//#region src/transactions/transaction.types.ts
+let TransactionTypes = /* @__PURE__ */ function(TransactionTypes$1) {
+	TransactionTypes$1["ContractCall"] = "contract_call";
+	TransactionTypes$1["ContractDeploy"] = "smart_contract";
+	TransactionTypes$1["StxTokenTransfer"] = "token_transfer";
+	return TransactionTypes$1;
+}({});
 function isTransactionTypeSupported(txType) {
-  return txType === "contract_call" /* ContractCall */ || txType === "smart_contract" /* ContractDeploy */ || txType === "token_transfer" /* StxTokenTransfer */;
+	return txType === TransactionTypes.ContractCall || txType === TransactionTypes.ContractDeploy || txType === TransactionTypes.StxTokenTransfer;
 }
 
-// src/transactions/generate-unsigned-transaction.ts
+//#endregion
+//#region src/transactions/generate-unsigned-transaction.ts
 function initNonce(nonce) {
-  return new BigNumber(nonce, 10);
+	return new BigNumber(nonce, 10);
 }
 function getUnsignedContractCallParsedOptions(options) {
-  return {
-    ...options,
-    fee: options.fee.amount.toString(),
-    functionArgs: options.functionArgs.map((arg) => deserializeCV(hexToBytes2(cleanHex(arg)))),
-    nonce: initNonce(options.nonce).toString(),
-    postConditions: options.postConditions
-  };
+	return {
+		...options,
+		fee: options.fee.amount.toString(),
+		functionArgs: options.functionArgs.map((arg) => deserializeCV(hexToBytes(cleanHex(arg)))),
+		nonce: initNonce(options.nonce).toString(),
+		postConditions: options.postConditions
+	};
 }
 function getUnsignedContractDeployParsedOptions(options) {
-  return {
-    ...options,
-    fee: options.fee.amount.toString(),
-    nonce: initNonce(options.nonce).toString(),
-    postConditions: getPostConditions(
-      options.postConditions?.map((pc) => ensurePostConditionWireFormat(pc))
-    )
-  };
+	return {
+		...options,
+		fee: options.fee.amount.toString(),
+		nonce: initNonce(options.nonce).toString(),
+		postConditions: getPostConditions(options.postConditions?.map((pc) => ensurePostConditionWireFormat(pc)))
+	};
 }
 function getUnsignedStxTokenTransferParsedOptions(options) {
-  return {
-    ...options,
-    amount: options.amount.amount.toString(),
-    fee: options.fee.amount.toString(),
-    nonce: initNonce(options.nonce).toString()
-  };
+	return {
+		...options,
+		amount: options.amount.amount.toString(),
+		fee: options.fee.amount.toString(),
+		nonce: initNonce(options.nonce).toString()
+	};
 }
 function generateStacksUnsignedTransaction(options) {
-  const { txType } = options;
-  const isValid = isTransactionTypeSupported(txType);
-  if (!isValid) throw new Error(`Invalid Transaction Type: ${txType}`);
-  switch (txType) {
-    case "token_transfer" /* StxTokenTransfer */:
-      return makeUnsignedSTXTokenTransfer(getUnsignedStxTokenTransferParsedOptions(options));
-    case "contract_call" /* ContractCall */:
-      return makeUnsignedContractCall(getUnsignedContractCallParsedOptions(options));
-    case "smart_contract" /* ContractDeploy */:
-      return makeUnsignedContractDeploy(getUnsignedContractDeployParsedOptions(options));
-    default:
-      assertUnreachable(txType);
-  }
+	const { txType } = options;
+	if (!isTransactionTypeSupported(txType)) throw new Error(`Invalid Transaction Type: ${txType}`);
+	switch (txType) {
+		case TransactionTypes.StxTokenTransfer: return makeUnsignedSTXTokenTransfer(getUnsignedStxTokenTransferParsedOptions(options));
+		case TransactionTypes.ContractCall: return makeUnsignedContractCall(getUnsignedContractCallParsedOptions(options));
+		case TransactionTypes.ContractDeploy: return makeUnsignedContractDeploy(getUnsignedContractDeployParsedOptions(options));
+		default: assertUnreachable(txType);
+	}
 }
 
-// src/transactions/get-contract-fn-args.ts
-import {
-  bufferCVFromString,
-  createAddress,
-  deserializeCV as deserializeCV2,
-  noneCV,
-  someCV,
-  standardPrincipalCVFromAddress,
-  uintCV
-} from "@stacks/transactions";
-function createSip10FnArgs({
-  amount,
-  senderStacksAddress,
-  recipientStacksAddress,
-  memo
-}) {
-  const fnArgs = [
-    uintCV(amount),
-    standardPrincipalCVFromAddress(createAddress(senderStacksAddress)),
-    standardPrincipalCVFromAddress(createAddress(recipientStacksAddress)),
-    memo && memo !== "" ? someCV(bufferCVFromString(memo)) : noneCV()
-  ];
-  return fnArgs;
-}
-function createSip9FnArgs({
-  assetId,
-  senderStacksAddress,
-  recipientStacksAddress
-}) {
-  const fnArgs = [
-    deserializeCV2(assetId),
-    standardPrincipalCVFromAddress(createAddress(senderStacksAddress)),
-    standardPrincipalCVFromAddress(createAddress(recipientStacksAddress))
-  ];
-  return fnArgs;
+//#endregion
+//#region src/transactions/get-contract-fn-args.ts
+function createSip10FnArgs({ amount, senderStacksAddress, recipientStacksAddress, memo }) {
+	return [
+		uintCV(amount),
+		standardPrincipalCVFromAddress(createAddress(senderStacksAddress)),
+		standardPrincipalCVFromAddress(createAddress(recipientStacksAddress)),
+		memo && memo !== "" ? someCV(bufferCVFromString(memo)) : noneCV()
+	];
+}
+function createSip9FnArgs({ assetId, senderStacksAddress, recipientStacksAddress }) {
+	return [
+		deserializeCV(assetId),
+		standardPrincipalCVFromAddress(createAddress(senderStacksAddress)),
+		standardPrincipalCVFromAddress(createAddress(recipientStacksAddress))
+	];
 }
 
-// src/transactions/create-tx-hex.ts
-async function createTransferSip10TxHex({
-  signer,
-  assetId,
-  recipient,
-  amount,
-  nonce,
-  fee,
-  memo
-}) {
-  const { contractAddress, contractAssetName, contractName } = getStacksAssetStringParts(assetId);
-  const currentStacksAddress = signer.address;
-  const fnArgs = createSip10FnArgs({
-    amount,
-    senderStacksAddress: currentStacksAddress,
-    recipientStacksAddress: recipient,
-    memo
-  });
-  const tx = await generateStacksUnsignedTransaction({
-    txType: "contract_call" /* ContractCall */,
-    publicKey: bytesToHex2(signer.publicKey),
-    contractAddress,
-    contractName,
-    functionArgs: fnArgs.map((arg) => serializeCV(arg)),
-    functionName: "transfer",
-    nonce,
-    fee,
-    postConditions: [
-      Pc.principal(currentStacksAddress).willSendEq(amount).ft(formatContractIdString({ contractAddress, contractName }), contractAssetName)
-    ]
-  });
-  const txHex = tx.serialize();
-  return txHex;
+//#endregion
+//#region src/transactions/create-tx-hex.ts
+async function createTransferSip10TxHex({ signer, assetId, recipient, amount, nonce, fee, memo }) {
+	const { contractAddress, contractAssetName, contractName } = getStacksAssetStringParts(assetId);
+	const currentStacksAddress = signer.address;
+	const fnArgs = createSip10FnArgs({
+		amount,
+		senderStacksAddress: currentStacksAddress,
+		recipientStacksAddress: recipient,
+		memo
+	});
+	return (await generateStacksUnsignedTransaction({
+		txType: TransactionTypes.ContractCall,
+		publicKey: bytesToHex$1(signer.publicKey),
+		contractAddress,
+		contractName,
+		functionArgs: fnArgs.map((arg) => serializeCV(arg)),
+		functionName: "transfer",
+		nonce,
+		fee,
+		postConditions: [Pc.principal(currentStacksAddress).willSendEq(amount).ft(formatContractIdString({
+			contractAddress,
+			contractName
+		}), contractAssetName)]
+	})).serialize();
 }
 
-// src/transactions/get-error-message.ts
+//#endregion
+//#region src/transactions/get-error-message.ts
 function getErrorMessage(reason) {
-  switch (reason) {
-    case "BadAddressVersionByte":
-      return "Incorrect address";
-    case "BadFunctionArgument":
-      return "Incorrect function argument";
-    case "BadNonce":
-      return "Incorrect nonce";
-    case "BadTransactionVersion":
-      return "Incorrect transaction";
-    case "ConflictingNonceInMempool":
-      return "Nonce conflict";
-    case "ContractAlreadyExists":
-      return "Contract already exists";
-    case "Deserialization":
-      return "Deserialization failure";
-    case "EstimatorError":
-      return "Estimator error";
-    case "FeeTooLow":
-      return "Fee too low";
-    case "NoCoinbaseViaMempool":
-      return "No coinbase via mempool";
-    case "NoSuchContract":
-      return "Contract does not exist";
-    case "NoSuchPublicFunction":
-      return "Function does not exist";
-    case "NotEnoughFunds":
-      return "Not enough funds";
-    case "PoisonMicroblocksDoNotConflict":
-      return "Microblock conflict";
-    case "PoisonMicroblockHasUnknownPubKeyHash":
-      return "No anchor block with public key hash";
-    case "PoisonMicroblockIsInvalid":
-      return "Invalid microblock";
-    case "Serialization":
-      return "Serialization failure";
-    case "ServerFailureDatabase":
-      return "Database error";
-    case "ServerFailureNoSuchChainTip":
-      return "No such chain tip";
-    case "ServerFailureOther":
-      return "Server failure";
-    case "SignatureValidation":
-      return "Failed to validate signature";
-    case "TransferAmountMustBePositive":
-      return "Transfer amount must be positive";
-    case "TransferRecipientCannotEqualSender":
-      return "Cannot transfer STX to yourself";
-    default:
-      return "Something went wrong";
-  }
+	switch (reason) {
+		case "BadAddressVersionByte": return "Incorrect address";
+		case "BadFunctionArgument": return "Incorrect function argument";
+		case "BadNonce": return "Incorrect nonce";
+		case "BadTransactionVersion": return "Incorrect transaction";
+		case "ConflictingNonceInMempool": return "Nonce conflict";
+		case "ContractAlreadyExists": return "Contract already exists";
+		case "Deserialization": return "Deserialization failure";
+		case "EstimatorError": return "Estimator error";
+		case "FeeTooLow": return "Fee too low";
+		case "NoCoinbaseViaMempool": return "No coinbase via mempool";
+		case "NoSuchContract": return "Contract does not exist";
+		case "NoSuchPublicFunction": return "Function does not exist";
+		case "NotEnoughFunds": return "Not enough funds";
+		case "PoisonMicroblocksDoNotConflict": return "Microblock conflict";
+		case "PoisonMicroblockHasUnknownPubKeyHash": return "No anchor block with public key hash";
+		case "PoisonMicroblockIsInvalid": return "Invalid microblock";
+		case "Serialization": return "Serialization failure";
+		case "ServerFailureDatabase": return "Database error";
+		case "ServerFailureNoSuchChainTip": return "No such chain tip";
+		case "ServerFailureOther": return "Server failure";
+		case "SignatureValidation": return "Failed to validate signature";
+		case "TransferAmountMustBePositive": return "Transfer amount must be positive";
+		case "TransferRecipientCannotEqualSender": return "Cannot transfer STX to yourself";
+		default: return "Something went wrong";
+	}
 }
 
-// src/transactions/sip-10-contract-call.utils.ts
-import {
-  ClarityType
-} from "@stacks/transactions";
+//#endregion
+//#region src/transactions/sip-10-contract-call.utils.ts
 function isSip10TransferContactCall(tx) {
-  if (tx.payload && "functionName" in tx.payload) {
-    if (tx.payload.functionName.content === "transfer" && (tx.payload.functionArgs.length === 3 || tx.payload.functionArgs.length === 4)) {
-      if (tx.payload.functionArgs[0].type === ClarityType.UInt && tx.payload.functionArgs[1].type === ClarityType.PrincipalStandard && tx.payload.functionArgs[2].type === ClarityType.PrincipalStandard) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-function isSip10Transfer({
-  functionName,
-  contractInterfaceData
-}) {
-  if (functionName !== "transfer") return false;
-  const functionInterface = contractInterfaceData?.functions.find((f) => f.name === functionName);
-  if (functionInterface?.args[0]?.name === "amount" && functionInterface?.args[1]?.name === "sender" && functionInterface?.args[2]?.name === "recipient" && functionInterface?.args[3]?.name === "memo") {
-    return true;
-  }
-  return false;
-}
-function getSip10TransferAmount({
-  functionName,
-  functionArgs,
-  contractInterfaceData
-}) {
-  if (isSip10Transfer({ functionName, contractInterfaceData }) && functionArgs[0]?.type === ClarityType.UInt) {
-    return Number(functionArgs[0].value);
-  }
-  return null;
-}
-function getSip10TransferRecipient({
-  functionName,
-  functionArgs,
-  contractInterfaceData
-}) {
-  if (isSip10Transfer({ functionName, contractInterfaceData }) && functionArgs[2]?.type === ClarityType.PrincipalStandard) {
-    return functionArgs[2].value;
-  }
-  return null;
+	if (tx.payload && "functionName" in tx.payload) {
+		if (tx.payload.functionName.content === "transfer" && (tx.payload.functionArgs.length === 3 || tx.payload.functionArgs.length === 4)) {
+			if (tx.payload.functionArgs[0].type === ClarityType.UInt && tx.payload.functionArgs[1].type === ClarityType.PrincipalStandard && tx.payload.functionArgs[2].type === ClarityType.PrincipalStandard) return true;
+		}
+	}
+	return false;
+}
+function isSip10Transfer({ functionName, contractInterfaceData }) {
+	if (functionName !== "transfer") return false;
+	const functionInterface = contractInterfaceData?.functions.find((f) => f.name === functionName);
+	if (functionInterface?.args[0]?.name === "amount" && functionInterface?.args[1]?.name === "sender" && functionInterface?.args[2]?.name === "recipient" && functionInterface?.args[3]?.name === "memo") return true;
+	return false;
+}
+function getSip10TransferAmount({ functionName, functionArgs, contractInterfaceData }) {
+	if (isSip10Transfer({
+		functionName,
+		contractInterfaceData
+	}) && functionArgs[0]?.type === ClarityType.UInt) return Number(functionArgs[0].value);
+	return null;
+}
+function getSip10TransferRecipient({ functionName, functionArgs, contractInterfaceData }) {
+	if (isSip10Transfer({
+		functionName,
+		contractInterfaceData
+	}) && functionArgs[2]?.type === ClarityType.PrincipalStandard) return functionArgs[2].value;
+	return null;
 }
 
-// src/transactions/sip-9-contract-call.utils.ts
-import {
-  ClarityType as ClarityType2
-} from "@stacks/transactions";
+//#endregion
+//#region src/transactions/sip-9-contract-call.utils.ts
 function isSip9TransferContactCall(tx) {
-  if (tx.payload && "functionName" in tx.payload) {
-    if (tx.payload.functionName.content === "transfer" && tx.payload.functionArgs.length === 3) {
-      if (tx.payload.functionArgs[0].type === ClarityType2.UInt && tx.payload.functionArgs[1].type === ClarityType2.PrincipalStandard && tx.payload.functionArgs[2].type === ClarityType2.PrincipalStandard) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-function isSip9Transfer({
-  functionName,
-  contractInterfaceData
-}) {
-  if (functionName !== "transfer") return false;
-  const functionInterface = contractInterfaceData?.functions.find((f) => f.name === functionName);
-  if (functionInterface?.args[0]?.name === "id" && functionInterface?.args[1]?.name === "from" && functionInterface?.args[2]?.name === "to") {
-    return true;
-  }
-  return false;
-}
-function getSip9TransferRecipient({
-  functionName,
-  functionArgs,
-  contractInterfaceData
-}) {
-  if (isSip9Transfer({ functionName, contractInterfaceData }) && functionArgs[2]?.type === ClarityType2.PrincipalStandard) {
-    return functionArgs[2].value;
-  }
-  return null;
+	if (tx.payload && "functionName" in tx.payload) {
+		if (tx.payload.functionName.content === "transfer" && tx.payload.functionArgs.length === 3) {
+			if (tx.payload.functionArgs[0].type === ClarityType.UInt && tx.payload.functionArgs[1].type === ClarityType.PrincipalStandard && tx.payload.functionArgs[2].type === ClarityType.PrincipalStandard) return true;
+		}
+	}
+	return false;
+}
+function isSip9Transfer({ functionName, contractInterfaceData }) {
+	if (functionName !== "transfer") return false;
+	const functionInterface = contractInterfaceData?.functions.find((f) => f.name === functionName);
+	if (functionInterface?.args[0]?.name === "id" && functionInterface?.args[1]?.name === "from" && functionInterface?.args[2]?.name === "to") return true;
+	return false;
+}
+function getSip9TransferRecipient({ functionName, functionArgs, contractInterfaceData }) {
+	if (isSip9Transfer({
+		functionName,
+		contractInterfaceData
+	}) && functionArgs[2]?.type === ClarityType.PrincipalStandard) return functionArgs[2].value;
+	return null;
 }
 
-// src/validation/address-validation.ts
-import { c32addressDecode } from "c32check";
-import { z } from "zod";
-import { ChainId as ChainId2 } from "@leather.io/models";
-import { isEmptyString, isString as isString3, isUndefined } from "@leather.io/utils";
+//#endregion
+//#region src/validation/address-validation.ts
 function isValidStacksAddress(address) {
-  if (isUndefined(address) || isEmptyString(address)) {
-    return false;
-  }
-  try {
-    c32addressDecode(address);
-    return true;
-  } catch {
-    return false;
-  }
+	if (isUndefined(address) || isEmptyString(address)) return false;
+	try {
+		c32addressDecode(address);
+		return true;
+	} catch {
+		return false;
+	}
 }
 function isValidAddressChain(address, chainId) {
-  if (!address) {
-    return false;
-  }
-  const prefix = address.slice(0, 2);
-  switch (chainId) {
-    case ChainId2.Mainnet:
-      return prefix === "SM" || prefix === "SP";
-    case ChainId2.Testnet:
-      return prefix === "SN" || prefix === "ST";
-    default:
-      return false;
-  }
+	if (!address) return false;
+	const prefix = address.slice(0, 2);
+	switch (chainId) {
+		case ChainId$1.Mainnet: return prefix === "SM" || prefix === "SP";
+		case ChainId$1.Testnet: return prefix === "SN" || prefix === "ST";
+		default: return false;
+	}
 }
 function validatePayerNotRecipient(senderAddress, recipientAddress) {
-  if (!senderAddress || !recipientAddress) {
-    return false;
-  }
-  return senderAddress !== recipientAddress;
-}
-var standardPrincipalSchema = z.string().refine(
-  (address) => {
-    if (!isString3(address)) return false;
-    if (!isValidStacksAddress(address)) return false;
-    return !address.includes(".");
-  },
-  { message: "Invalid standard Stacks principal address" }
-);
-var contractPrincipalSchema = z.string().refine(
-  (principal) => {
-    if (!isString3(principal)) return false;
-    const parts = principal.split(".");
-    if (parts.length !== 2) return false;
-    const [address, contractName] = parts;
-    if (!isValidStacksAddress(address)) return false;
-    const contractNameRegex = /^[a-zA-Z0-9_-]{1,128}$/;
-    return contractNameRegex.test(contractName);
-  },
-  { message: "Invalid contract principal (must be address.contract-name format)" }
-);
-var principalSchema = z.union([standardPrincipalSchema, contractPrincipalSchema]);
+	if (!senderAddress || !recipientAddress) return false;
+	return senderAddress !== recipientAddress;
+}
+const standardPrincipalSchema = z.string().refine((address) => {
+	if (!isString(address)) return false;
+	if (!isValidStacksAddress(address)) return false;
+	return !address.includes(".");
+}, { message: "Invalid standard Stacks principal address" });
+const contractPrincipalSchema = z.string().refine((principal) => {
+	if (!isString(principal)) return false;
+	const parts = principal.split(".");
+	if (parts.length !== 2) return false;
+	const [address, contractName] = parts;
+	if (!isValidStacksAddress(address)) return false;
+	return /^[a-zA-Z0-9_-]{1,128}$/.test(contractName);
+}, { message: "Invalid contract principal (must be address.contract-name format)" });
+const principalSchema = z.union([standardPrincipalSchema, contractPrincipalSchema]);
 
-// src/validation/memo-validation.ts
-import { MEMO_MAX_LENGTH_BYTES } from "@stacks/transactions";
+//#endregion
+//#region src/validation/memo-validation.ts
 function exceedsMaxLengthBytes(value, maxLengthBytes) {
-  return value ? Buffer.from(value).length > maxLengthBytes : false;
+	return value ? Buffer.from(value).length > maxLengthBytes : false;
 }
 function isValidStacksMemo(memo) {
-  return !exceedsMaxLengthBytes(memo, MEMO_MAX_LENGTH_BYTES);
+	return !exceedsMaxLengthBytes(memo, MEMO_MAX_LENGTH_BYTES);
 }
 
-// src/validation/stacks-error.ts
+//#endregion
+//#region src/validation/stacks-error.ts
 var StacksError = class extends Error {
-  message;
-  constructor(message) {
-    super(message);
-    this.name = "StacksError";
-    this.message = message;
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
+	message;
+	constructor(message) {
+		super(message);
+		this.name = "StacksError";
+		this.message = message;
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
 };
 
-// src/validation/amount-validation.ts
-import BigNumber2 from "bignumber.js";
-import { isDefined, stxToMicroStx } from "@leather.io/utils";
+//#endregion
+//#region src/validation/amount-validation.ts
 function isMoneyAmountValid(amount) {
-  return amount && isDefined(amount.amount) && amount.amount;
+	return amount && isDefined(amount.amount) && amount.amount;
 }
 function isStxAmountValid({ availableBalance, amount, fee }) {
-  if (!isMoneyAmountValid(amount)) {
-    throw new StacksError("InvalidAmount");
-  }
-  if (!isMoneyAmountValid(availableBalance)) {
-    throw new StacksError("UnknownBalance");
-  }
-  if (!isMoneyAmountValid(fee)) {
-    throw new StacksError("UnknownFee");
-  }
-  return true;
-}
-function isStxBalanceSufficient({
-  availableBalance: { amount: availableBalanceAmount },
-  amount: { amount: desiredSpend },
-  fee: { amount: feeAmount }
-}) {
-  const fee = new BigNumber2(stxToMicroStx(feeAmount));
-  if (!availableBalanceAmount) {
-    throw new StacksError("UnknownBalance");
-  }
-  if (!fee.isFinite()) {
-    throw new StacksError("UnknownFee");
-  }
-  const availableBalance = new BigNumber2(stxToMicroStx(availableBalanceAmount));
-  const spendableAmount = availableBalance.minus(fee);
-  const amount = new BigNumber2(stxToMicroStx(desiredSpend));
-  return spendableAmount.isGreaterThanOrEqualTo(amount);
+	if (!isMoneyAmountValid(amount)) throw new StacksError("InvalidAmount");
+	if (!isMoneyAmountValid(availableBalance)) throw new StacksError("UnknownBalance");
+	if (!isMoneyAmountValid(fee)) throw new StacksError("UnknownFee");
+	return true;
+}
+function isStxBalanceSufficient({ availableBalance: { amount: availableBalanceAmount }, amount: { amount: desiredSpend }, fee: { amount: feeAmount } }) {
+	const fee = new BigNumber(stxToMicroStx(feeAmount));
+	if (!availableBalanceAmount) throw new StacksError("UnknownBalance");
+	if (!fee.isFinite()) throw new StacksError("UnknownFee");
+	const spendableAmount = new BigNumber(stxToMicroStx(availableBalanceAmount)).minus(fee);
+	const amount = new BigNumber(stxToMicroStx(desiredSpend));
+	return spendableAmount.isGreaterThanOrEqualTo(amount);
 }
 
-// src/validation/transaction-validation.ts
-function isValidStacksTransaction({
-  amount,
-  availableBalance,
-  fee,
-  payer,
-  recipient,
-  chainId
-}) {
-  if (!isValidStacksAddress(payer) || !isValidStacksAddress(recipient)) {
-    throw new StacksError("InvalidAddress");
-  }
-  if (!isValidAddressChain(payer, chainId) || !isValidAddressChain(recipient, chainId)) {
-    throw new StacksError("InvalidNetworkAddress");
-  }
-  if (!validatePayerNotRecipient(payer, recipient)) {
-    throw new StacksError("InvalidSameAddress");
-  }
-  if (!isStxAmountValid({ availableBalance, amount, fee })) {
-    throw new StacksError("InvalidAmount");
-  }
-  if (!isStxBalanceSufficient({ availableBalance, amount, fee })) {
-    throw new StacksError("InsufficientFunds");
-  }
-  return true;
+//#endregion
+//#region src/validation/transaction-validation.ts
+function isValidStacksTransaction({ amount, availableBalance, fee, payer, recipient, chainId }) {
+	if (!isValidStacksAddress(payer) || !isValidStacksAddress(recipient)) throw new StacksError("InvalidAddress");
+	if (!isValidAddressChain(payer, chainId) || !isValidAddressChain(recipient, chainId)) throw new StacksError("InvalidNetworkAddress");
+	if (!validatePayerNotRecipient(payer, recipient)) throw new StacksError("InvalidSameAddress");
+	if (!isStxAmountValid({
+		availableBalance,
+		amount,
+		fee
+	})) throw new StacksError("InvalidAmount");
+	if (!isStxBalanceSufficient({
+		availableBalance,
+		amount,
+		fee
+	})) throw new StacksError("InsufficientFunds");
+	return true;
 }
 
-// src/schemas/clarity-contract.schema.ts
-import { codeBodyString } from "@stacks/transactions";
-import { z as z2 } from "zod";
+//#endregion
+//#region src/schemas/clarity-contract.schema.ts
 function isValidContractLength(contract) {
-  try {
-    codeBodyString(contract);
-    return true;
-  } catch (_e) {
-    return false;
-  }
-}
-var clarityContractSchema = z2.string().refine((contract) => isValidContractLength(contract), {
-  message: "ContractExceedsMaxLength"
-});
+	try {
+		codeBodyString(contract);
+		return true;
+	} catch (_e) {
+		return false;
+	}
+}
+const clarityContractSchema = z.string().refine((contract) => isValidContractLength(contract), { message: "ContractExceedsMaxLength" });
 
-// src/schemas/memo.schema.ts
-import { createMemoString } from "@stacks/transactions";
-import { z as z3 } from "zod";
-var stacksMemoSchema = z3.string().refine(
-  (value) => {
-    try {
-      createMemoString(value);
-      return true;
-    } catch {
-      return false;
-    }
-  },
-  { message: "Invalid memo string" }
-);
+//#endregion
+//#region src/schemas/memo.schema.ts
+const stacksMemoSchema = z.string().refine((value) => {
+	try {
+		createMemoString(value);
+		return true;
+	} catch {
+		return false;
+	}
+}, { message: "Invalid memo string" });
 
-// src/transactions/serialization.ts
-import { serializePayload } from "@stacks/transactions";
+//#endregion
+//#region src/transactions/serialization.ts
 function getEstimatedUnsignedStacksTxByteLength(transaction) {
-  return transaction.serializeBytes().byteLength;
+	return transaction.serializeBytes().byteLength;
 }
 function getSerializedUnsignedStacksTxPayload(transaction) {
-  return serializePayload(transaction.payload);
+	return serializePayload(transaction.payload);
 }
 
-// src/addresses.ts
-import { getAddressFromPrivateKey, makeRandomPrivKey } from "@stacks/transactions";
+//#endregion
+//#region src/addresses.ts
 function generateRandomStacksAddress() {
-  const randomPrivateKey = makeRandomPrivKey();
-  const privateKeyString = randomPrivateKey;
-  const randomAddress = getAddressFromPrivateKey(privateKeyString);
-  return randomAddress;
+	return getAddressFromPrivateKey(makeRandomPrivKey());
 }
 
-// src/clarity.ts
-import {
-  ClarityType as ClarityType3
-} from "@stacks/transactions";
+//#endregion
+//#region src/clarity.ts
 function parseClarityUintResponse(response) {
-  if (response.type === ClarityType3.ResponseOk && response.value.type === ClarityType3.UInt) {
-    return BigInt(response.value.value);
-  } else if (response.type === ClarityType3.UInt) {
-    return BigInt(response.value);
-  }
-  throw new Error("Invalid Clarity response format");
+	if (response.type === ClarityType.ResponseOk && response.value.type === ClarityType.UInt) return BigInt(response.value.value);
+	else if (response.type === ClarityType.UInt) return BigInt(response.value);
+	throw new Error("Invalid Clarity response format");
 }
 function isClarityTuple(cv) {
-  return cv.type === ClarityType3.Tuple;
+	return cv.type === ClarityType.Tuple;
 }
 function isClarityResponseOk(cv) {
-  return cv.type === ClarityType3.ResponseOk;
+	return cv.type === ClarityType.ResponseOk;
 }
 function isClarityResponseError(cv) {
-  return cv.type === ClarityType3.ResponseErr;
+	return cv.type === ClarityType.ResponseErr;
 }
 function isClarityUInt(cv) {
-  return cv.type === ClarityType3.UInt;
+	return cv.type === ClarityType.UInt;
 }
 function isClarityList(cv) {
-  return cv.type === ClarityType3.List;
+	return cv.type === ClarityType.List;
 }
 function isClarityPrincipal(cv) {
-  return cv.type === ClarityType3.PrincipalStandard || cv.type === ClarityType3.PrincipalContract;
+	return cv.type === ClarityType.PrincipalStandard || cv.type === ClarityType.PrincipalContract;
 }
 function isClarityOptionalNone(cv) {
-  return cv.type === ClarityType3.OptionalNone;
+	return cv.type === ClarityType.OptionalNone;
 }
 function isClarityOptionalSome(cv) {
-  return cv.type === ClarityType3.OptionalSome;
+	return cv.type === ClarityType.OptionalSome;
 }
 function getClarityPrincipal(cv) {
-  return cv.value;
-}
-export {
-  StacksError,
-  TEST_ACCOUNT_1_STX_ADDRESS,
-  TEST_ACCOUNT_1_STX_ADDRESS_SM,
-  TEST_ACCOUNT_2_STX_ADDRESS,
-  TEST_TESTNET_ACCOUNT_2_STX_ADDRESS,
-  TEST_TESTNET_ACCOUNT_2_STX_ADDRESS_SN,
-  TransactionTypes,
-  clarityContractSchema,
-  cleanHex,
-  contractPrincipalSchema,
-  createSignFnFromMnemonic,
-  createSignMessageFnFromMnemonic,
-  createSignStructuredDataMessageFnFromMnemonic,
-  createSip10FnArgs,
-  createSip9FnArgs,
-  createTransferSip10TxHex,
-  deriveStxPrivateKey,
-  deriveStxPublicKey,
-  ensurePostConditionWireFormat,
-  extractStacksDerivationPathAccountIndex,
-  formatAssetString,
-  formatContractId,
-  formatContractIdString,
-  generateRandomStacksAddress,
-  generateStacksUnsignedTransaction,
-  getClarityPrincipal,
-  getErrorMessage,
-  getEstimatedUnsignedStacksTxByteLength,
-  getPostCondition,
-  getPostConditionFromString,
-  getPostConditions,
-  getPrincipalFromAssetString,
-  getSerializedUnsignedStacksTxPayload,
-  getSip10TransferAmount,
-  getSip10TransferRecipient,
-  getSip9TransferRecipient,
-  getStacksAssetStringParts,
-  getStacksBurnAddress,
-  getStacksContractAssetName,
-  getStacksContractName,
-  getUnsignedContractCallParsedOptions,
-  getUnsignedContractDeployParsedOptions,
-  getUnsignedStxTokenTransferParsedOptions,
-  initNonce,
-  initalizeStacksSigner,
-  isClarityList,
-  isClarityOptionalNone,
-  isClarityOptionalSome,
-  isClarityPrincipal,
-  isClarityResponseError,
-  isClarityResponseOk,
-  isClarityTuple,
-  isClarityUInt,
-  isSip10Transfer,
-  isSip10TransferContactCall,
-  isSip9Transfer,
-  isSip9TransferContactCall,
-  isTransactionTypeSupported,
-  isValidAddressChain,
-  isValidContractLength,
-  isValidStacksAddress,
-  isValidStacksMemo,
-  isValidStacksTransaction,
-  makeAccountIndexDerivationPathFactory,
-  makeStxDerivationPath,
-  parseClarityUintResponse,
-  principalSchema,
-  signMessage,
-  signStacksTransaction,
-  signStructuredDataMessage,
-  stacksChainIdToCoreNetworkMode,
-  stacksMemoSchema,
-  stacksRootKeychainToAccountDescriptor,
-  standardPrincipalSchema,
-  stxDerivationWithAccount,
-  validatePayerNotRecipient,
-  whenStacksChainId
-};
+	return cv.value;
+}
+
+//#endregion
+export { StacksError, TEST_ACCOUNT_1_STX_ADDRESS, TEST_ACCOUNT_1_STX_ADDRESS_SM, TEST_ACCOUNT_2_STX_ADDRESS, TEST_TESTNET_ACCOUNT_2_STX_ADDRESS, TEST_TESTNET_ACCOUNT_2_STX_ADDRESS_SN, TransactionTypes, clarityContractSchema, cleanHex, contractPrincipalSchema, createSignFnFromMnemonic, createSignMessageFnFromMnemonic, createSignStructuredDataMessageFnFromMnemonic, createSip10FnArgs, createSip9FnArgs, createTransferSip10TxHex, deriveStxPrivateKey, deriveStxPublicKey, ensurePostConditionWireFormat, extractStacksDerivationPathAccountIndex, formatAssetString, formatContractId, formatContractIdString, generateRandomStacksAddress, generateStacksUnsignedTransaction, getClarityPrincipal, getErrorMessage, getEstimatedUnsignedStacksTxByteLength, getPostCondition, getPostConditionFromString, getPostConditions, getPrincipalFromAssetString, getSerializedUnsignedStacksTxPayload, getSip10TransferAmount, getSip10TransferRecipient, getSip9TransferRecipient, getStacksAssetStringParts, getStacksBurnAddress, getStacksContractAssetName, getStacksContractName, getUnsignedContractCallParsedOptions, getUnsignedContractDeployParsedOptions, getUnsignedStxTokenTransferParsedOptions, initNonce, initalizeStacksSigner, isClarityList, isClarityOptionalNone, isClarityOptionalSome, isClarityPrincipal, isClarityResponseError, isClarityResponseOk, isClarityTuple, isClarityUInt, isSip10Transfer, isSip10TransferContactCall, isSip9Transfer, isSip9TransferContactCall, isTransactionTypeSupported, isValidAddressChain, isValidContractLength, isValidStacksAddress, isValidStacksMemo, isValidStacksTransaction, makeAccountIndexDerivationPathFactory, makeStxDerivationPath, parseClarityUintResponse, principalSchema, signMessage, signStacksTransaction, signStructuredDataMessage, stacksChainIdToCoreNetworkMode, stacksMemoSchema, stacksRootKeychainToAccountDescriptor, standardPrincipalSchema, stxDerivationWithAccount, validatePayerNotRecipient, whenStacksChainId };
 //# sourceMappingURL=index.js.map