@leather.io/stacks 1.3.6 → 1.5.0

package/dist/index.d.ts

@@ -1,8 +1,68 @@
 import * as _stacks_transactions from '@stacks/transactions';
-import { ChainID, StacksPrivateKey, ClarityValue, StacksTransaction } from '@stacks/transactions';
-import { HDKey } from '@scure/bip32';
-import { NetworkModes } from '@leather.io/models';
+import { StacksTransaction, UnsignedContractCallOptions, UnsignedContractDeployOptions, UnsignedTokenTransferOptions, PostCondition, ChainID, StacksPrivateKey, ClarityValue } from '@stacks/transactions';
 import { Signer } from '@leather.io/crypto';
+import { NetworkModes, ReplaceTypes, Money } from '@leather.io/models';
+import BigNumber from 'bignumber.js';
+import { HDKey } from '@scure/bip32';
+
+declare function signStacksTransaction(tx: StacksTransaction, privateKey: string): StacksTransaction;
+type StacksSignerFn = (tx: StacksTransaction) => Promise<StacksTransaction>;
+interface StacksSigner extends Signer {
+    descriptor: string;
+    keyOrigin: string;
+    address: string;
+    accountIndex: number;
+    network: NetworkModes;
+    sign: StacksSignerFn;
+}
+declare function createSignFnFromMnemonic(keyOrigin: string, getMnemonicFn: () => Promise<{
+    mnemonic: string;
+    passphrase?: string;
+}>): (tx: StacksTransaction) => Promise<StacksTransaction>;
+interface InitalizeStacksSignerArgs {
+    descriptor: string;
+    network: NetworkModes;
+    signFn: StacksSignerFn;
+}
+declare function initalizeStacksSigner(args: InitalizeStacksSignerArgs): StacksSigner;
+
+declare enum TransactionTypes {
+    ContractCall = "contract_call",
+    ContractDeploy = "smart_contract",
+    StxTokenTransfer = "token_transfer"
+}
+declare function isTransactionTypeSupported(txType: TransactionTypes): txType is TransactionTypes;
+type StacksUnsignedContractCallOptions = ReplaceTypes<UnsignedContractCallOptions, {
+    fee: Money;
+    functionArgs: string[];
+    nonce: number | string;
+}> & {
+    txType: TransactionTypes.ContractCall;
+};
+type StacksUnsignedContractDeployOptions = ReplaceTypes<UnsignedContractDeployOptions, {
+    fee: Money;
+    nonce: number | string;
+}> & {
+    txType: TransactionTypes.ContractDeploy;
+};
+type StacksUnsignedTokenTransferOptions = ReplaceTypes<UnsignedTokenTransferOptions, {
+    amount: Money;
+    fee: Money;
+    nonce: number | string;
+}> & {
+    txType: TransactionTypes.StxTokenTransfer;
+};
+type StacksUnsignedTransactionOptions = StacksUnsignedContractCallOptions | StacksUnsignedContractDeployOptions | StacksUnsignedTokenTransferOptions;
+
+declare function initNonce(nonce: number | string): BigNumber;
+declare function generateUnsignedContractCall(options: StacksUnsignedContractCallOptions): Promise<_stacks_transactions.StacksTransaction>;
+declare function generateUnsignedContractDeploy(options: StacksUnsignedContractDeployOptions): Promise<_stacks_transactions.StacksTransaction>;
+declare function generateUnsignedStxTokenTransfer(options: StacksUnsignedTokenTransferOptions): Promise<_stacks_transactions.StacksTransaction>;
+declare function generateStacksUnsignedTransaction(options: StacksUnsignedTransactionOptions): Promise<_stacks_transactions.StacksTransaction>;
+
+declare function getPostConditionFromString(postCondition: string): PostCondition;
+declare function getPostCondition(postCondition: string | PostCondition): PostCondition;
+declare function getPostConditions(postConditions?: (string | PostCondition)[]): PostCondition[] | undefined;
 
 declare const stxDerivationWithAccount = "m/44'/5757'/0'/0/{account}";
 declare function makeAccountIndexDerivationPathFactory(derivationPath: string): (account: number) => string;
@@ -27,6 +87,29 @@ declare function deriveStxPublicKey({ keychain, index }: {
 }): _stacks_transactions.StacksPublicKey;
 declare function stacksRootKeychainToAccountDescriptor(keychain: HDKey, accountIndex: number): string;
 declare function getStacksBurnAddress(chainId: ChainID): string;
+declare function cleanHex(hexWithMaybePrefix: string): string;
+/**
+ * Gets the contract name of a fully qualified name of an asset.
+ *
+ * @param contractId - the source string: [principal].[contract-name] or [principal].[contract-name]::[asset-name]
+ */
+declare function getStacksContractName(contractId: string): string;
+/**
+ * Gets the asset name from a a fully qualified name of an asset.
+ *
+ * @param contractId - the fully qualified name of the asset: [principal].[contract-name]::[asset-name]
+ */
+declare function getStacksContractAssetName(contractId: string): string;
+/**
+ * Gets the parts that make up a fully qualified name of an asset.
+ *
+ * @param contractId - the fully qualified name of the asset: [principal].[contract-name]::[asset-name]
+ */
+declare function getStacksContractIdStringParts(contractId: string): {
+    contractAddress: string;
+    contractAssetName: string;
+    contractName: string;
+};
 
 interface SignatureData {
     signature: string;
@@ -35,25 +118,4 @@ interface SignatureData {
 declare function signMessage(message: string, privateKey: StacksPrivateKey): SignatureData;
 declare function signStructuredDataMessage(message: ClarityValue, domain: ClarityValue, privateKey: StacksPrivateKey): SignatureData;
 
-declare function signStacksTransaction(tx: StacksTransaction, privateKey: string): StacksTransaction;
-type StacksSignerFn = (tx: StacksTransaction) => Promise<StacksTransaction>;
-interface StacksSigner extends Signer {
-    descriptor: string;
-    keyOrigin: string;
-    address: string;
-    accountIndex: number;
-    network: NetworkModes;
-    sign: StacksSignerFn;
-}
-declare function createSignFnFromMnemonic(keyOrigin: string, getMnemonicFn: () => Promise<{
-    mnemonic: string;
-    passphrase?: string;
-}>): (tx: StacksTransaction) => Promise<StacksTransaction>;
-interface InitalizeStacksSignerArgs {
-    descriptor: string;
-    network: NetworkModes;
-    signFn: StacksSignerFn;
-}
-declare function initalizeStacksSigner(args: InitalizeStacksSignerArgs): StacksSigner;
-
-export { type StacksSigner, type StacksSignerFn, createSignFnFromMnemonic, deriveStxPrivateKey, deriveStxPublicKey, extractStacksDerivationPathAccountIndex, getStacksBurnAddress, initalizeStacksSigner, makeAccountIndexDerivationPathFactory, makeStxDerivationPath, signMessage, signStacksTransaction, signStructuredDataMessage, stacksChainIdToCoreNetworkMode, stacksRootKeychainToAccountDescriptor, stxDerivationWithAccount, whenStacksChainId };
+export { type StacksSigner, type StacksSignerFn, type StacksUnsignedContractCallOptions, type StacksUnsignedContractDeployOptions, type StacksUnsignedTokenTransferOptions, type StacksUnsignedTransactionOptions, TransactionTypes, cleanHex, createSignFnFromMnemonic, deriveStxPrivateKey, deriveStxPublicKey, extractStacksDerivationPathAccountIndex, generateStacksUnsignedTransaction, generateUnsignedContractCall, generateUnsignedContractDeploy, generateUnsignedStxTokenTransfer, getPostCondition, getPostConditionFromString, getPostConditions, getStacksBurnAddress, getStacksContractAssetName, getStacksContractIdStringParts, getStacksContractName, initNonce, initalizeStacksSigner, isTransactionTypeSupported, makeAccountIndexDerivationPathFactory, makeStxDerivationPath, signMessage, signStacksTransaction, signStructuredDataMessage, stacksChainIdToCoreNetworkMode, stacksRootKeychainToAccountDescriptor, stxDerivationWithAccount, whenStacksChainId };

package/dist/index.js

@@ -1,3 +1,18 @@
+// src/signer/signer.ts
+import {
+  AddressVersion,
+  TransactionSigner,
+  createStacksPrivateKey as createStacksPrivateKey2,
+  createStacksPublicKey,
+  publicKeyToAddress
+} from "@stacks/transactions";
+import {
+  decomposeDescriptor,
+  deriveRootKeychainFromMnemonic,
+  extractKeyFromDescriptor
+} from "@leather.io/crypto";
+import { whenNetwork } from "@leather.io/utils";
+
 // src/stacks.utils.ts
 import { bytesToHex } from "@noble/hashes/utils";
 import { compressPrivateKey } from "@stacks/encryption";
@@ -8,7 +23,7 @@ import {
   createKeyOriginPath,
   extractAddressIndexFromPath
 } from "@leather.io/crypto";
-import { assertIsTruthy, toHexString } from "@leather.io/utils";
+import { assertIsTruthy, isString, toHexString } from "@leather.io/utils";
 var stxDerivationWithAccount = `m/44'/5757'/0'/0/{account}`;
 function makeAccountIndexDerivationPathFactory(derivationPath) {
   return (account) => derivationPath.replace("{account}", account.toString());
@@ -50,49 +65,43 @@ function getStacksBurnAddress(chainId) {
       return "ST000000000000000000002AMW42H";
   }
 }
-
-// src/message-signing.ts
-import { bytesToHex as bytesToHex2 } from "@noble/hashes/utils";
-import { hashMessage } from "@stacks/encryption";
-import {
-  getPublicKey as getPublicKey2,
-  publicKeyToString,
-  signMessageHashRsv,
-  signStructuredData
-} from "@stacks/transactions";
-function signMessage(message, privateKey) {
-  const hash = hashMessage(message);
-  return {
-    signature: signMessageHashRsv({ privateKey, messageHash: bytesToHex2(hash) }).data,
-    publicKey: publicKeyToString(getPublicKey2(privateKey))
-  };
+function cleanHex(hexWithMaybePrefix) {
+  if (!isString(hexWithMaybePrefix)) return hexWithMaybePrefix;
+  return hexWithMaybePrefix.startsWith("0x") ? hexWithMaybePrefix.replace("0x", "") : hexWithMaybePrefix;
 }
-function signStructuredDataMessage(message, domain, privateKey) {
-  const signature = signStructuredData({
-    message,
-    domain,
-    privateKey
-  }).data;
+function getStacksContractName(contractId) {
+  if (contractId.includes(".")) {
+    const parts = contractId?.split(".");
+    if (contractId.includes("::")) {
+      return parts[1].split("::")[0];
+    }
+    return parts[1];
+  }
+  return contractId;
+}
+function getStacksContractAssetName(contractId) {
+  if (!contractId.includes("::")) return contractId;
+  return contractId.split("::")[1];
+}
+function getStacksContractIdStringParts(contractId) {
+  if (!contractId.includes(".") || !contractId.includes("::")) {
+    return {
+      contractAddress: contractId,
+      contractAssetName: contractId,
+      contractName: contractId
+    };
+  }
+  const contractAddress = contractId.split(".")[0];
+  const contractAssetName = getStacksContractAssetName(contractId);
+  const contractName = getStacksContractName(contractId);
   return {
-    signature,
-    publicKey: publicKeyToString(getPublicKey2(privateKey))
+    contractAddress,
+    contractAssetName,
+    contractName
   };
 }
 
 // src/signer/signer.ts
-import {
-  AddressVersion,
-  TransactionSigner,
-  createStacksPrivateKey as createStacksPrivateKey2,
-  createStacksPublicKey,
-  publicKeyToAddress
-} from "@stacks/transactions";
-import {
-  decomposeDescriptor,
-  deriveRootKeychainFromMnemonic,
-  extractKeyFromDescriptor
-} from "@leather.io/crypto";
-import { whenNetwork } from "@leather.io/utils";
 function signStacksTransaction(tx, privateKey) {
   const signer = new TransactionSigner(tx);
   signer.signOrigin(createStacksPrivateKey2(privateKey));
@@ -114,6 +123,8 @@ function initalizeStacksSigner(args) {
   const publicKey = createStacksPublicKey(extractKeyFromDescriptor(descriptor));
   return {
     ...decomposeDescriptor(descriptor),
+    // here we overwrite the accountIndex with the derivation path account index for stx
+    accountIndex: extractStacksDerivationPathAccountIndex(descriptor),
     publicKey: publicKey.data,
     network,
     address: publicKeyToAddress(
@@ -126,13 +137,141 @@ function initalizeStacksSigner(args) {
     sign: signFn
   };
 }
+
+// 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";
+
+// src/transactions/post-condition.utils.ts
+import { hexToBytes } from "@noble/hashes/utils";
+import { BytesReader, deserializePostCondition } from "@stacks/transactions";
+import { isString as isString2 } from "@leather.io/utils";
+function getPostConditionFromString(postCondition) {
+  try {
+    const reader = new BytesReader(hexToBytes(postCondition));
+    return deserializePostCondition(reader);
+  } catch (err) {
+    throw new Error("Not a serialized post condition");
+  }
+}
+function getPostCondition(postCondition) {
+  return isString2(postCondition) ? getPostConditionFromString(postCondition) : postCondition;
+}
+function getPostConditions(postConditions) {
+  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 || {});
+function isTransactionTypeSupported(txType) {
+  return txType === "contract_call" /* ContractCall */ || txType === "smart_contract" /* ContractDeploy */ || txType === "token_transfer" /* StxTokenTransfer */;
+}
+
+// src/transactions/generate-unsigned-transaction.ts
+function initNonce(nonce) {
+  return new BigNumber(nonce, 10);
+}
+function generateUnsignedContractCall(options) {
+  const { fee, functionArgs, nonce, postConditions } = options;
+  const fnArgs = functionArgs.map((arg) => deserializeCV(hexToBytes2(cleanHex(arg))));
+  const parsedOptions = {
+    fee: fee.amount.toString(),
+    functionArgs: fnArgs,
+    nonce: initNonce(nonce).toString(),
+    postConditions: getPostConditions(postConditions)
+  };
+  return makeUnsignedContractCall({ ...options, ...parsedOptions });
+}
+function generateUnsignedContractDeploy(options) {
+  const { fee, nonce, postConditions } = options;
+  const parsedOptions = {
+    fee: fee.amount.toString(),
+    nonce: initNonce(nonce).toString(),
+    postConditions: getPostConditions(postConditions)
+  };
+  return makeUnsignedContractDeploy({ ...options, ...parsedOptions });
+}
+function generateUnsignedStxTokenTransfer(options) {
+  const { amount, fee, nonce } = options;
+  const parsedOptions = {
+    amount: amount.amount.toString(),
+    fee: fee.amount.toString(),
+    nonce: initNonce(nonce).toString()
+  };
+  return makeUnsignedSTXTokenTransfer({ ...options, ...parsedOptions });
+}
+async function generateStacksUnsignedTransaction(options) {
+  const isValid = isTransactionTypeSupported(options.txType);
+  if (!isValid) throw new Error(`Invalid Transaction Type: ${options.txType}`);
+  switch (options.txType) {
+    case "token_transfer" /* StxTokenTransfer */:
+      return generateUnsignedStxTokenTransfer(options);
+    case "contract_call" /* ContractCall */:
+      return generateUnsignedContractCall(options);
+    case "smart_contract" /* ContractDeploy */:
+      return generateUnsignedContractDeploy(options);
+  }
+}
+
+// src/message-signing.ts
+import { bytesToHex as bytesToHex2 } from "@noble/hashes/utils";
+import { hashMessage } from "@stacks/encryption";
+import {
+  getPublicKey as getPublicKey2,
+  publicKeyToString,
+  signMessageHashRsv,
+  signStructuredData
+} from "@stacks/transactions";
+function signMessage(message, privateKey) {
+  const hash = hashMessage(message);
+  return {
+    signature: signMessageHashRsv({ privateKey, messageHash: bytesToHex2(hash) }).data,
+    publicKey: publicKeyToString(getPublicKey2(privateKey))
+  };
+}
+function signStructuredDataMessage(message, domain, privateKey) {
+  const signature = signStructuredData({
+    message,
+    domain,
+    privateKey
+  }).data;
+  return {
+    signature,
+    publicKey: publicKeyToString(getPublicKey2(privateKey))
+  };
+}
 export {
+  TransactionTypes,
+  cleanHex,
   createSignFnFromMnemonic,
   deriveStxPrivateKey,
   deriveStxPublicKey,
   extractStacksDerivationPathAccountIndex,
+  generateStacksUnsignedTransaction,
+  generateUnsignedContractCall,
+  generateUnsignedContractDeploy,
+  generateUnsignedStxTokenTransfer,
+  getPostCondition,
+  getPostConditionFromString,
+  getPostConditions,
   getStacksBurnAddress,
+  getStacksContractAssetName,
+  getStacksContractIdStringParts,
+  getStacksContractName,
+  initNonce,
   initalizeStacksSigner,
+  isTransactionTypeSupported,
   makeAccountIndexDerivationPathFactory,
   makeStxDerivationPath,
   signMessage,

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/stacks.utils.ts","../src/message-signing.ts","../src/signer/signer.ts"],"sourcesContent":["import { bytesToHex } from '@noble/hashes/utils';\nimport { HDKey } from '@scure/bip32';\nimport { compressPrivateKey } from '@stacks/encryption';\nimport { ChainID, createStacksPrivateKey, getPublicKey } from '@stacks/transactions';\n\nimport {\n  DerivationPathDepth,\n  createDescriptor,\n  createKeyOriginPath,\n  extractAddressIndexFromPath,\n} from '@leather.io/crypto';\nimport type { NetworkModes } from '@leather.io/models';\nimport { assertIsTruthy, toHexString } from '@leather.io/utils';\n\nexport const stxDerivationWithAccount = `m/44'/5757'/0'/0/{account}`;\n\nexport function makeAccountIndexDerivationPathFactory(derivationPath: string) {\n  return (account: number) => derivationPath.replace('{account}', account.toString());\n}\n\nexport function extractStacksDerivationPathAccountIndex(path: string) {\n  if (!path.includes('5757')) throw new Error('Not a valid Stacks derivation path: ' + path);\n  return extractAddressIndexFromPath(path);\n}\n\n/**\n * Stacks accounts always use the same derivation path, regardless of network\n */\nexport const makeStxDerivationPath =\n  makeAccountIndexDerivationPathFactory(stxDerivationWithAccount);\n\nexport function stacksChainIdToCoreNetworkMode(chainId: ChainID): NetworkModes {\n  return whenStacksChainId(chainId)({ [ChainID.Mainnet]: 'mainnet', [ChainID.Testnet]: 'testnet' });\n}\n\ninterface WhenStacksChainIdMap<T> {\n  [ChainID.Mainnet]: T;\n  [ChainID.Testnet]: T;\n}\nexport function whenStacksChainId(chainId: ChainID) {\n  return <T>(chainIdMap: WhenStacksChainIdMap<T>): T => chainIdMap[chainId];\n}\n\n// From `@stacks/wallet-sdk` package we are trying not to use\nexport function deriveStxPrivateKey({ keychain, index }: { keychain: HDKey; index: number }) {\n  if (keychain.depth !== DerivationPathDepth.Root) throw new Error('Root keychain must be depth 0');\n  const accountKeychain = keychain.derive(makeStxDerivationPath(index));\n  assertIsTruthy(accountKeychain.privateKey);\n  return bytesToHex(compressPrivateKey(accountKeychain.privateKey));\n}\n\nexport function deriveStxPublicKey({ keychain, index }: { keychain: HDKey; index: number }) {\n  return getPublicKey(createStacksPrivateKey(deriveStxPrivateKey({ keychain, index })));\n}\n\nexport function stacksRootKeychainToAccountDescriptor(keychain: HDKey, accountIndex: number) {\n  const fingerprint = toHexString(keychain.fingerprint);\n  const publicKey = deriveStxPublicKey({ keychain, index: accountIndex });\n  return createDescriptor(\n    createKeyOriginPath(fingerprint, makeStxDerivationPath(accountIndex)),\n    bytesToHex(publicKey.data)\n  );\n}\n\nexport function getStacksBurnAddress(chainId: ChainID): string {\n  switch (chainId) {\n    case ChainID.Mainnet:\n      return 'SP00000000000003SCNSJTCSE62ZF4MSE';\n    case ChainID.Testnet:\n    default:\n      return 'ST000000000000000000002AMW42H';\n  }\n}\n","import { bytesToHex } from '@noble/hashes/utils';\nimport { hashMessage } from '@stacks/encryption';\nimport {\n  ClarityValue,\n  StacksPrivateKey,\n  getPublicKey,\n  publicKeyToString,\n  signMessageHashRsv,\n  signStructuredData,\n} from '@stacks/transactions';\n\ninterface SignatureData {\n  signature: string;\n  publicKey: string;\n}\n\nexport function signMessage(message: string, privateKey: StacksPrivateKey): SignatureData {\n  const hash = hashMessage(message);\n  return {\n    signature: signMessageHashRsv({ privateKey, messageHash: bytesToHex(hash) }).data,\n    publicKey: publicKeyToString(getPublicKey(privateKey)),\n  };\n}\n\nexport function signStructuredDataMessage(\n  message: ClarityValue,\n  domain: ClarityValue,\n  privateKey: StacksPrivateKey\n): SignatureData {\n  const signature = signStructuredData({\n    message,\n    domain,\n    privateKey,\n  }).data;\n\n  return {\n    signature,\n    publicKey: publicKeyToString(getPublicKey(privateKey)),\n  };\n}\n","import {\n  AddressVersion,\n  StacksTransaction,\n  TransactionSigner,\n  createStacksPrivateKey,\n  createStacksPublicKey,\n  publicKeyToAddress,\n} from '@stacks/transactions';\n\nimport {\n  Signer,\n  decomposeDescriptor,\n  deriveRootKeychainFromMnemonic,\n  extractKeyFromDescriptor,\n} from '@leather.io/crypto';\nimport { NetworkModes } from '@leather.io/models';\nimport { whenNetwork } from '@leather.io/utils';\n\nimport { deriveStxPrivateKey, extractStacksDerivationPathAccountIndex } from '../stacks.utils';\n\n// Warning: mutatitive. Ideally there would be a tx.clone() method\nexport function signStacksTransaction(tx: StacksTransaction, privateKey: string) {\n  const signer = new TransactionSigner(tx);\n  signer.signOrigin(createStacksPrivateKey(privateKey));\n  return tx;\n}\n\nexport type StacksSignerFn = (tx: StacksTransaction) => Promise<StacksTransaction>;\n\nexport interface StacksSigner extends Signer {\n  descriptor: string;\n  keyOrigin: string;\n  address: string;\n  accountIndex: number;\n  network: NetworkModes;\n  sign: StacksSignerFn;\n}\n\nexport function createSignFnFromMnemonic(\n  keyOrigin: string,\n  getMnemonicFn: () => Promise<{ mnemonic: string; passphrase?: string }>\n) {\n  return async (tx: StacksTransaction) => {\n    const { mnemonic, passphrase } = await getMnemonicFn();\n    const keychain = await deriveRootKeychainFromMnemonic(mnemonic, passphrase);\n    const privateKey = deriveStxPrivateKey({\n      keychain,\n      index: extractStacksDerivationPathAccountIndex(keyOrigin),\n    });\n    return signStacksTransaction(tx, privateKey);\n  };\n}\n\ninterface InitalizeStacksSignerArgs {\n  descriptor: string;\n  network: NetworkModes;\n  signFn: StacksSignerFn;\n}\nexport function initalizeStacksSigner(args: InitalizeStacksSignerArgs): StacksSigner {\n  const { descriptor, network, signFn } = args;\n\n  const publicKey = createStacksPublicKey(extractKeyFromDescriptor(descriptor));\n\n  return {\n    ...decomposeDescriptor(descriptor),\n    publicKey: publicKey.data,\n    network,\n    address: publicKeyToAddress(\n      whenNetwork(network)({\n        mainnet: AddressVersion.MainnetSingleSig,\n        testnet: AddressVersion.TestnetSingleSig,\n      }),\n      publicKey\n    ),\n    sign: signFn,\n  };\n}\n"],"mappings":"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","names":["bytesToHex","getPublicKey","createStacksPrivateKey","createStacksPrivateKey"]}
+{"version":3,"sources":["../src/signer/signer.ts","../src/stacks.utils.ts","../src/transactions/generate-unsigned-transaction.ts","../src/transactions/post-condition.utils.ts","../src/transactions/transaction.types.ts","../src/message-signing.ts"],"sourcesContent":["import {\n  AddressVersion,\n  StacksTransaction,\n  TransactionSigner,\n  createStacksPrivateKey,\n  createStacksPublicKey,\n  publicKeyToAddress,\n} from '@stacks/transactions';\n\nimport {\n  Signer,\n  decomposeDescriptor,\n  deriveRootKeychainFromMnemonic,\n  extractKeyFromDescriptor,\n} from '@leather.io/crypto';\nimport { NetworkModes } from '@leather.io/models';\nimport { whenNetwork } from '@leather.io/utils';\n\nimport { deriveStxPrivateKey, extractStacksDerivationPathAccountIndex } from '../stacks.utils';\n\n// Warning: mutatitive. Ideally there would be a tx.clone() method\nexport function signStacksTransaction(tx: StacksTransaction, privateKey: string) {\n  const signer = new TransactionSigner(tx);\n  signer.signOrigin(createStacksPrivateKey(privateKey));\n  return tx;\n}\n\nexport type StacksSignerFn = (tx: StacksTransaction) => Promise<StacksTransaction>;\n\nexport interface StacksSigner extends Signer {\n  descriptor: string;\n  keyOrigin: string;\n  address: string;\n  accountIndex: number;\n  network: NetworkModes;\n  sign: StacksSignerFn;\n}\n\nexport function createSignFnFromMnemonic(\n  keyOrigin: string,\n  getMnemonicFn: () => Promise<{ mnemonic: string; passphrase?: string }>\n) {\n  return async (tx: StacksTransaction) => {\n    const { mnemonic, passphrase } = await getMnemonicFn();\n    const keychain = await deriveRootKeychainFromMnemonic(mnemonic, passphrase);\n    const privateKey = deriveStxPrivateKey({\n      keychain,\n      index: extractStacksDerivationPathAccountIndex(keyOrigin),\n    });\n    return signStacksTransaction(tx, privateKey);\n  };\n}\n\ninterface InitalizeStacksSignerArgs {\n  descriptor: string;\n  network: NetworkModes;\n  signFn: StacksSignerFn;\n}\nexport function initalizeStacksSigner(args: InitalizeStacksSignerArgs): StacksSigner {\n  const { descriptor, network, signFn } = args;\n\n  const publicKey = createStacksPublicKey(extractKeyFromDescriptor(descriptor));\n\n  return {\n    ...decomposeDescriptor(descriptor),\n    // here we overwrite the accountIndex with the derivation path account index for stx\n    accountIndex: extractStacksDerivationPathAccountIndex(descriptor),\n    publicKey: publicKey.data,\n    network,\n    address: publicKeyToAddress(\n      whenNetwork(network)({\n        mainnet: AddressVersion.MainnetSingleSig,\n        testnet: AddressVersion.TestnetSingleSig,\n      }),\n      publicKey\n    ),\n    sign: signFn,\n  };\n}\n","import { bytesToHex } from '@noble/hashes/utils';\nimport { HDKey } from '@scure/bip32';\nimport { compressPrivateKey } from '@stacks/encryption';\nimport { ChainID, createStacksPrivateKey, getPublicKey } from '@stacks/transactions';\n\nimport {\n  DerivationPathDepth,\n  createDescriptor,\n  createKeyOriginPath,\n  extractAddressIndexFromPath,\n} from '@leather.io/crypto';\nimport type { NetworkModes } from '@leather.io/models';\nimport { assertIsTruthy, isString, toHexString } from '@leather.io/utils';\n\nexport const stxDerivationWithAccount = `m/44'/5757'/0'/0/{account}`;\n\nexport function makeAccountIndexDerivationPathFactory(derivationPath: string) {\n  return (account: number) => derivationPath.replace('{account}', account.toString());\n}\n\nexport function extractStacksDerivationPathAccountIndex(path: string) {\n  if (!path.includes('5757')) throw new Error('Not a valid Stacks derivation path: ' + path);\n  return extractAddressIndexFromPath(path);\n}\n\n/**\n * Stacks accounts always use the same derivation path, regardless of network\n */\nexport const makeStxDerivationPath =\n  makeAccountIndexDerivationPathFactory(stxDerivationWithAccount);\n\nexport function stacksChainIdToCoreNetworkMode(chainId: ChainID): NetworkModes {\n  return whenStacksChainId(chainId)({ [ChainID.Mainnet]: 'mainnet', [ChainID.Testnet]: 'testnet' });\n}\n\ninterface WhenStacksChainIdMap<T> {\n  [ChainID.Mainnet]: T;\n  [ChainID.Testnet]: T;\n}\nexport function whenStacksChainId(chainId: ChainID) {\n  return <T>(chainIdMap: WhenStacksChainIdMap<T>): T => chainIdMap[chainId];\n}\n\n// From `@stacks/wallet-sdk` package we are trying not to use\nexport function deriveStxPrivateKey({ keychain, index }: { keychain: HDKey; index: number }) {\n  if (keychain.depth !== DerivationPathDepth.Root) throw new Error('Root keychain must be depth 0');\n  const accountKeychain = keychain.derive(makeStxDerivationPath(index));\n  assertIsTruthy(accountKeychain.privateKey);\n  return bytesToHex(compressPrivateKey(accountKeychain.privateKey));\n}\n\nexport function deriveStxPublicKey({ keychain, index }: { keychain: HDKey; index: number }) {\n  return getPublicKey(createStacksPrivateKey(deriveStxPrivateKey({ keychain, index })));\n}\n\nexport function stacksRootKeychainToAccountDescriptor(keychain: HDKey, accountIndex: number) {\n  const fingerprint = toHexString(keychain.fingerprint);\n  const publicKey = deriveStxPublicKey({ keychain, index: accountIndex });\n  return createDescriptor(\n    createKeyOriginPath(fingerprint, makeStxDerivationPath(accountIndex)),\n    bytesToHex(publicKey.data)\n  );\n}\n\nexport function getStacksBurnAddress(chainId: ChainID): string {\n  switch (chainId) {\n    case ChainID.Mainnet:\n      return 'SP00000000000003SCNSJTCSE62ZF4MSE';\n    case ChainID.Testnet:\n    default:\n      return 'ST000000000000000000002AMW42H';\n  }\n}\n\nexport function cleanHex(hexWithMaybePrefix: string): string {\n  if (!isString(hexWithMaybePrefix)) return hexWithMaybePrefix;\n  return hexWithMaybePrefix.startsWith('0x')\n    ? hexWithMaybePrefix.replace('0x', '')\n    : hexWithMaybePrefix;\n}\n\n/**\n * Gets the contract name of a fully qualified name of an asset.\n *\n * @param contractId - the source string: [principal].[contract-name] or [principal].[contract-name]::[asset-name]\n */\nexport function getStacksContractName(contractId: string): string {\n  if (contractId.includes('.')) {\n    const parts = contractId?.split('.');\n    if (contractId.includes('::')) {\n      return parts[1].split('::')[0];\n    }\n    return parts[1];\n  }\n  return contractId;\n}\n\n/**\n * Gets the asset name from a a fully qualified name of an asset.\n *\n * @param contractId - the fully qualified name of the asset: [principal].[contract-name]::[asset-name]\n */\nexport function getStacksContractAssetName(contractId: string): string {\n  if (!contractId.includes('::')) return contractId;\n  return contractId.split('::')[1];\n}\n\n/**\n * Gets the parts that make up a fully qualified name of an asset.\n *\n * @param contractId - the fully qualified name of the asset: [principal].[contract-name]::[asset-name]\n */\nexport function getStacksContractIdStringParts(contractId: string): {\n  contractAddress: string;\n  contractAssetName: string;\n  contractName: string;\n} {\n  if (!contractId.includes('.') || !contractId.includes('::')) {\n    return {\n      contractAddress: contractId,\n      contractAssetName: contractId,\n      contractName: contractId,\n    };\n  }\n\n  const contractAddress = contractId.split('.')[0];\n  const contractAssetName = getStacksContractAssetName(contractId);\n  const contractName = getStacksContractName(contractId);\n\n  return {\n    contractAddress,\n    contractAssetName,\n    contractName,\n  };\n}\n","import { hexToBytes } from '@noble/hashes/utils';\nimport {\n  deserializeCV,\n  makeUnsignedContractCall,\n  makeUnsignedContractDeploy,\n  makeUnsignedSTXTokenTransfer,\n} from '@stacks/transactions';\nimport BigNumber from 'bignumber.js';\n\nimport { cleanHex } from '../stacks.utils';\nimport { getPostConditions } from './post-condition.utils';\nimport {\n  StacksUnsignedContractCallOptions,\n  StacksUnsignedContractDeployOptions,\n  StacksUnsignedTokenTransferOptions,\n  StacksUnsignedTransactionOptions,\n  TransactionTypes,\n  isTransactionTypeSupported,\n} from './transaction.types';\n\nexport function initNonce(nonce: number | string) {\n  return new BigNumber(nonce, 10);\n}\n\nexport function generateUnsignedContractCall(options: StacksUnsignedContractCallOptions) {\n  const { fee, functionArgs, nonce, postConditions } = options;\n\n  const fnArgs = functionArgs.map(arg => deserializeCV(hexToBytes(cleanHex(arg))));\n\n  const parsedOptions = {\n    fee: fee.amount.toString(),\n    functionArgs: fnArgs,\n    nonce: initNonce(nonce).toString(),\n    postConditions: getPostConditions(postConditions),\n  };\n\n  return makeUnsignedContractCall({ ...options, ...parsedOptions });\n}\n\nexport function generateUnsignedContractDeploy(options: StacksUnsignedContractDeployOptions) {\n  const { fee, nonce, postConditions } = options;\n\n  const parsedOptions = {\n    fee: fee.amount.toString(),\n    nonce: initNonce(nonce).toString(),\n    postConditions: getPostConditions(postConditions),\n  };\n\n  return makeUnsignedContractDeploy({ ...options, ...parsedOptions });\n}\n\nexport function generateUnsignedStxTokenTransfer(options: StacksUnsignedTokenTransferOptions) {\n  const { amount, fee, nonce } = options;\n\n  const parsedOptions = {\n    amount: amount.amount.toString(),\n    fee: fee.amount.toString(),\n    nonce: initNonce(nonce).toString(),\n  };\n\n  return makeUnsignedSTXTokenTransfer({ ...options, ...parsedOptions });\n}\n\nexport async function generateStacksUnsignedTransaction(options: StacksUnsignedTransactionOptions) {\n  const isValid = isTransactionTypeSupported(options.txType);\n\n  if (!isValid) throw new Error(`Invalid Transaction Type: ${options.txType}`);\n\n  switch (options.txType) {\n    case TransactionTypes.StxTokenTransfer:\n      return generateUnsignedStxTokenTransfer(options);\n    case TransactionTypes.ContractCall:\n      return generateUnsignedContractCall(options);\n    case TransactionTypes.ContractDeploy:\n      return generateUnsignedContractDeploy(options);\n  }\n}\n","import { hexToBytes } from '@noble/hashes/utils';\nimport { BytesReader, PostCondition, deserializePostCondition } from '@stacks/transactions';\n\nimport { isString } from '@leather.io/utils';\n\nexport function getPostConditionFromString(postCondition: string): PostCondition {\n  try {\n    const reader = new BytesReader(hexToBytes(postCondition));\n    return deserializePostCondition(reader);\n  } catch (err) {\n    throw new Error('Not a serialized post condition');\n  }\n}\n\nexport function getPostCondition(postCondition: string | PostCondition): PostCondition {\n  return isString(postCondition) ? getPostConditionFromString(postCondition) : postCondition;\n}\n\nexport function getPostConditions(\n  postConditions?: (string | PostCondition)[]\n): PostCondition[] | undefined {\n  return postConditions?.map(getPostCondition);\n}\n","import {\n  UnsignedContractCallOptions,\n  UnsignedContractDeployOptions,\n  UnsignedTokenTransferOptions,\n} from '@stacks/transactions';\n\nimport { Money, ReplaceTypes } from '@leather.io/models';\n\nexport enum TransactionTypes {\n  ContractCall = 'contract_call',\n  ContractDeploy = 'smart_contract',\n  StxTokenTransfer = 'token_transfer',\n}\n\nexport function isTransactionTypeSupported(txType: TransactionTypes) {\n  return (\n    txType === TransactionTypes.ContractCall ||\n    txType === TransactionTypes.ContractDeploy ||\n    txType === TransactionTypes.StxTokenTransfer\n  );\n}\n\nexport type StacksUnsignedContractCallOptions = ReplaceTypes<\n  UnsignedContractCallOptions,\n  {\n    fee: Money;\n    functionArgs: string[];\n    nonce: number | string;\n  }\n> & { txType: TransactionTypes.ContractCall };\n\nexport type StacksUnsignedContractDeployOptions = ReplaceTypes<\n  UnsignedContractDeployOptions,\n  {\n    fee: Money;\n    nonce: number | string;\n  }\n> & { txType: TransactionTypes.ContractDeploy };\n\nexport type StacksUnsignedTokenTransferOptions = ReplaceTypes<\n  UnsignedTokenTransferOptions,\n  {\n    amount: Money;\n    fee: Money;\n    nonce: number | string;\n  }\n> & { txType: TransactionTypes.StxTokenTransfer };\n\nexport type StacksUnsignedTransactionOptions =\n  | StacksUnsignedContractCallOptions\n  | StacksUnsignedContractDeployOptions\n  | StacksUnsignedTokenTransferOptions;\n","import { bytesToHex } from '@noble/hashes/utils';\nimport { hashMessage } from '@stacks/encryption';\nimport {\n  ClarityValue,\n  StacksPrivateKey,\n  getPublicKey,\n  publicKeyToString,\n  signMessageHashRsv,\n  signStructuredData,\n} from '@stacks/transactions';\n\ninterface SignatureData {\n  signature: string;\n  publicKey: string;\n}\n\nexport function signMessage(message: string, privateKey: StacksPrivateKey): SignatureData {\n  const hash = hashMessage(message);\n  return {\n    signature: signMessageHashRsv({ privateKey, messageHash: bytesToHex(hash) }).data,\n    publicKey: publicKeyToString(getPublicKey(privateKey)),\n  };\n}\n\nexport function signStructuredDataMessage(\n  message: ClarityValue,\n  domain: ClarityValue,\n  privateKey: StacksPrivateKey\n): SignatureData {\n  const signature = signStructuredData({\n    message,\n    domain,\n    privateKey,\n  }).data;\n\n  return {\n    signature,\n    publicKey: publicKeyToString(getPublicKey(privateKey)),\n  };\n}\n"],"mappings":";AAAA;AAAA,EACE;AAAA,EAEA;AAAA,EACA,0BAAAA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP;AAAA,EAEE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP,SAAS,mBAAmB;;;AChB5B,SAAS,kBAAkB;AAE3B,SAAS,0BAA0B;AACnC,SAAS,SAAS,wBAAwB,oBAAoB;AAE9D;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP,SAAS,gBAAgB,UAAU,mBAAmB;AAE/C,IAAM,2BAA2B;AAEjC,SAAS,sCAAsC,gBAAwB;AAC5E,SAAO,CAAC,YAAoB,eAAe,QAAQ,aAAa,QAAQ,SAAS,CAAC;AACpF;AAEO,SAAS,wCAAwC,MAAc;AACpE,MAAI,CAAC,KAAK,SAAS,MAAM,EAAG,OAAM,IAAI,MAAM,yCAAyC,IAAI;AACzF,SAAO,4BAA4B,IAAI;AACzC;AAKO,IAAM,wBACX,sCAAsC,wBAAwB;AAEzD,SAAS,+BAA+B,SAAgC;AAC7E,SAAO,kBAAkB,OAAO,EAAE,EAAE,CAAC,QAAQ,OAAO,GAAG,WAAW,CAAC,QAAQ,OAAO,GAAG,UAAU,CAAC;AAClG;AAMO,SAAS,kBAAkB,SAAkB;AAClD,SAAO,CAAI,eAA2C,WAAW,OAAO;AAC1E;AAGO,SAAS,oBAAoB,EAAE,UAAU,MAAM,GAAuC;AAC3F,MAAI,SAAS,UAAU,oBAAoB,KAAM,OAAM,IAAI,MAAM,+BAA+B;AAChG,QAAM,kBAAkB,SAAS,OAAO,sBAAsB,KAAK,CAAC;AACpE,iBAAe,gBAAgB,UAAU;AACzC,SAAO,WAAW,mBAAmB,gBAAgB,UAAU,CAAC;AAClE;AAEO,SAAS,mBAAmB,EAAE,UAAU,MAAM,GAAuC;AAC1F,SAAO,aAAa,uBAAuB,oBAAoB,EAAE,UAAU,MAAM,CAAC,CAAC,CAAC;AACtF;AAEO,SAAS,sCAAsC,UAAiB,cAAsB;AAC3F,QAAM,cAAc,YAAY,SAAS,WAAW;AACpD,QAAM,YAAY,mBAAmB,EAAE,UAAU,OAAO,aAAa,CAAC;AACtE,SAAO;AAAA,IACL,oBAAoB,aAAa,sBAAsB,YAAY,CAAC;AAAA,IACpE,WAAW,UAAU,IAAI;AAAA,EAC3B;AACF;AAEO,SAAS,qBAAqB,SAA0B;AAC7D,UAAQ,SAAS;AAAA,IACf,KAAK,QAAQ;AACX,aAAO;AAAA,IACT,KAAK,QAAQ;AAAA,IACb;AACE,aAAO;AAAA,EACX;AACF;AAEO,SAAS,SAAS,oBAAoC;AAC3D,MAAI,CAAC,SAAS,kBAAkB,EAAG,QAAO;AAC1C,SAAO,mBAAmB,WAAW,IAAI,IACrC,mBAAmB,QAAQ,MAAM,EAAE,IACnC;AACN;AAOO,SAAS,sBAAsB,YAA4B;AAChE,MAAI,WAAW,SAAS,GAAG,GAAG;AAC5B,UAAM,QAAQ,YAAY,MAAM,GAAG;AACnC,QAAI,WAAW,SAAS,IAAI,GAAG;AAC7B,aAAO,MAAM,CAAC,EAAE,MAAM,IAAI,EAAE,CAAC;AAAA,IAC/B;AACA,WAAO,MAAM,CAAC;AAAA,EAChB;AACA,SAAO;AACT;AAOO,SAAS,2BAA2B,YAA4B;AACrE,MAAI,CAAC,WAAW,SAAS,IAAI,EAAG,QAAO;AACvC,SAAO,WAAW,MAAM,IAAI,EAAE,CAAC;AACjC;AAOO,SAAS,+BAA+B,YAI7C;AACA,MAAI,CAAC,WAAW,SAAS,GAAG,KAAK,CAAC,WAAW,SAAS,IAAI,GAAG;AAC3D,WAAO;AAAA,MACL,iBAAiB;AAAA,MACjB,mBAAmB;AAAA,MACnB,cAAc;AAAA,IAChB;AAAA,EACF;AAEA,QAAM,kBAAkB,WAAW,MAAM,GAAG,EAAE,CAAC;AAC/C,QAAM,oBAAoB,2BAA2B,UAAU;AAC/D,QAAM,eAAe,sBAAsB,UAAU;AAErD,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;;;ADjHO,SAAS,sBAAsB,IAAuB,YAAoB;AAC/E,QAAM,SAAS,IAAI,kBAAkB,EAAE;AACvC,SAAO,WAAWC,wBAAuB,UAAU,CAAC;AACpD,SAAO;AACT;AAaO,SAAS,yBACd,WACA,eACA;AACA,SAAO,OAAO,OAA0B;AACtC,UAAM,EAAE,UAAU,WAAW,IAAI,MAAM,cAAc;AACrD,UAAM,WAAW,MAAM,+BAA+B,UAAU,UAAU;AAC1E,UAAM,aAAa,oBAAoB;AAAA,MACrC;AAAA,MACA,OAAO,wCAAwC,SAAS;AAAA,IAC1D,CAAC;AACD,WAAO,sBAAsB,IAAI,UAAU;AAAA,EAC7C;AACF;AAOO,SAAS,sBAAsB,MAA+C;AACnF,QAAM,EAAE,YAAY,SAAS,OAAO,IAAI;AAExC,QAAM,YAAY,sBAAsB,yBAAyB,UAAU,CAAC;AAE5E,SAAO;AAAA,IACL,GAAG,oBAAoB,UAAU;AAAA;AAAA,IAEjC,cAAc,wCAAwC,UAAU;AAAA,IAChE,WAAW,UAAU;AAAA,IACrB;AAAA,IACA,SAAS;AAAA,MACP,YAAY,OAAO,EAAE;AAAA,QACnB,SAAS,eAAe;AAAA,QACxB,SAAS,eAAe;AAAA,MAC1B,CAAC;AAAA,MACD;AAAA,IACF;AAAA,IACA,MAAM;AAAA,EACR;AACF;;;AE9EA,SAAS,cAAAC,mBAAkB;AAC3B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,OAAO,eAAe;;;ACPtB,SAAS,kBAAkB;AAC3B,SAAS,aAA4B,gCAAgC;AAErE,SAAS,YAAAC,iBAAgB;AAElB,SAAS,2BAA2B,eAAsC;AAC/E,MAAI;AACF,UAAM,SAAS,IAAI,YAAY,WAAW,aAAa,CAAC;AACxD,WAAO,yBAAyB,MAAM;AAAA,EACxC,SAAS,KAAK;AACZ,UAAM,IAAI,MAAM,iCAAiC;AAAA,EACnD;AACF;AAEO,SAAS,iBAAiB,eAAsD;AACrF,SAAOA,UAAS,aAAa,IAAI,2BAA2B,aAAa,IAAI;AAC/E;AAEO,SAAS,kBACd,gBAC6B;AAC7B,SAAO,gBAAgB,IAAI,gBAAgB;AAC7C;;;ACdO,IAAK,mBAAL,kBAAKC,sBAAL;AACL,EAAAA,kBAAA,kBAAe;AACf,EAAAA,kBAAA,oBAAiB;AACjB,EAAAA,kBAAA,sBAAmB;AAHT,SAAAA;AAAA,GAAA;AAML,SAAS,2BAA2B,QAA0B;AACnE,SACE,WAAW,sCACX,WAAW,yCACX,WAAW;AAEf;;;AFAO,SAAS,UAAU,OAAwB;AAChD,SAAO,IAAI,UAAU,OAAO,EAAE;AAChC;AAEO,SAAS,6BAA6B,SAA4C;AACvF,QAAM,EAAE,KAAK,cAAc,OAAO,eAAe,IAAI;AAErD,QAAM,SAAS,aAAa,IAAI,SAAO,cAAcC,YAAW,SAAS,GAAG,CAAC,CAAC,CAAC;AAE/E,QAAM,gBAAgB;AAAA,IACpB,KAAK,IAAI,OAAO,SAAS;AAAA,IACzB,cAAc;AAAA,IACd,OAAO,UAAU,KAAK,EAAE,SAAS;AAAA,IACjC,gBAAgB,kBAAkB,cAAc;AAAA,EAClD;AAEA,SAAO,yBAAyB,EAAE,GAAG,SAAS,GAAG,cAAc,CAAC;AAClE;AAEO,SAAS,+BAA+B,SAA8C;AAC3F,QAAM,EAAE,KAAK,OAAO,eAAe,IAAI;AAEvC,QAAM,gBAAgB;AAAA,IACpB,KAAK,IAAI,OAAO,SAAS;AAAA,IACzB,OAAO,UAAU,KAAK,EAAE,SAAS;AAAA,IACjC,gBAAgB,kBAAkB,cAAc;AAAA,EAClD;AAEA,SAAO,2BAA2B,EAAE,GAAG,SAAS,GAAG,cAAc,CAAC;AACpE;AAEO,SAAS,iCAAiC,SAA6C;AAC5F,QAAM,EAAE,QAAQ,KAAK,MAAM,IAAI;AAE/B,QAAM,gBAAgB;AAAA,IACpB,QAAQ,OAAO,OAAO,SAAS;AAAA,IAC/B,KAAK,IAAI,OAAO,SAAS;AAAA,IACzB,OAAO,UAAU,KAAK,EAAE,SAAS;AAAA,EACnC;AAEA,SAAO,6BAA6B,EAAE,GAAG,SAAS,GAAG,cAAc,CAAC;AACtE;AAEA,eAAsB,kCAAkC,SAA2C;AACjG,QAAM,UAAU,2BAA2B,QAAQ,MAAM;AAEzD,MAAI,CAAC,QAAS,OAAM,IAAI,MAAM,6BAA6B,QAAQ,MAAM,EAAE;AAE3E,UAAQ,QAAQ,QAAQ;AAAA,IACtB;AACE,aAAO,iCAAiC,OAAO;AAAA,IACjD;AACE,aAAO,6BAA6B,OAAO;AAAA,IAC7C;AACE,aAAO,+BAA+B,OAAO;AAAA,EACjD;AACF;;;AG5EA,SAAS,cAAAC,mBAAkB;AAC3B,SAAS,mBAAmB;AAC5B;AAAA,EAGE,gBAAAC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAOA,SAAS,YAAY,SAAiB,YAA6C;AACxF,QAAM,OAAO,YAAY,OAAO;AAChC,SAAO;AAAA,IACL,WAAW,mBAAmB,EAAE,YAAY,aAAaD,YAAW,IAAI,EAAE,CAAC,EAAE;AAAA,IAC7E,WAAW,kBAAkBC,cAAa,UAAU,CAAC;AAAA,EACvD;AACF;AAEO,SAAS,0BACd,SACA,QACA,YACe;AACf,QAAM,YAAY,mBAAmB;AAAA,IACnC;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC,EAAE;AAEH,SAAO;AAAA,IACL;AAAA,IACA,WAAW,kBAAkBA,cAAa,UAAU,CAAC;AAAA,EACvD;AACF;","names":["createStacksPrivateKey","createStacksPrivateKey","hexToBytes","isString","TransactionTypes","hexToBytes","bytesToHex","getPublicKey"]}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@leather.io/stacks",
   "author": "leather.io",
   "description": "Stacks package for Leather",
-  "version": "1.3.6",
+  "version": "1.5.0",
   "license": "MIT",
   "type": "module",
   "exports": {
@@ -12,13 +12,18 @@
     "@noble/hashes": "1.5.0",
     "@scure/bip32": "1.5.0",
     "@stacks/encryption": "6.16.1",
+    "@stacks/network": "6.13.0",
+    "@stacks/stacks-blockchain-api-types": "7.8.2",
     "@stacks/transactions": "6.17.0",
-    "@leather.io/models": "0.21.0",
-    "@leather.io/crypto": "1.6.13",
-    "@leather.io/utils": "0.19.2"
+    "bignumber.js": "9.1.2",
+    "@leather.io/constants": "0.13.6",
+    "@leather.io/crypto": "1.6.15",
+    "@leather.io/models": "0.23.0",
+    "@leather.io/utils": "0.20.1"
   },
   "devDependencies": {
-    "tsup": "8.1.0"
+    "tsup": "8.1.0",
+    "vitest": "2.1.5"
   },
   "files": [
     "dist"