@secondlayer/stacks 0.0.1

package/dist/src/transactions/index.d.ts

@@ -0,0 +1,412 @@
+type IntCV = {
+	readonly type: "int"
+	readonly value: bigint
+};
+type UIntCV = {
+	readonly type: "uint"
+	readonly value: bigint
+};
+type BooleanCV = TrueCV | FalseCV;
+type TrueCV = {
+	readonly type: "true"
+};
+type FalseCV = {
+	readonly type: "false"
+};
+type BufferCV = {
+	readonly type: "buffer"
+	readonly value: string
+};
+type NoneCV = {
+	readonly type: "none"
+};
+type SomeCV = {
+	readonly type: "some"
+	readonly value: ClarityValue
+};
+type ResponseOkCV = {
+	readonly type: "ok"
+	readonly value: ClarityValue
+};
+type ResponseErrorCV = {
+	readonly type: "err"
+	readonly value: ClarityValue
+};
+type StandardPrincipalCV = {
+	readonly type: "address"
+	readonly value: string
+};
+type ContractPrincipalCV = {
+	readonly type: "contract"
+	readonly value: string
+};
+type ListCV = {
+	type: "list"
+	value: ClarityValue[]
+};
+type TupleData = {
+	[key: string]: ClarityValue
+};
+type TupleCV = {
+	type: "tuple"
+	value: TupleData
+};
+type StringAsciiCV = {
+	readonly type: "ascii"
+	readonly value: string
+};
+type StringUtf8CV = {
+	readonly type: "utf8"
+	readonly value: string
+};
+type ClarityValue = IntCV | UIntCV | BooleanCV | BufferCV | NoneCV | SomeCV | ResponseOkCV | ResponseErrorCV | StandardPrincipalCV | ContractPrincipalCV | ListCV | TupleCV | StringAsciiCV | StringUtf8CV;
+declare const AuthType: {
+	readonly Standard: 0x04
+	readonly Sponsored: 0x05
+};
+type AuthType = (typeof AuthType)[keyof typeof AuthType];
+declare const PayloadType: {
+	readonly TokenTransfer: 0x00
+	readonly SmartContract: 0x01
+	readonly ContractCall: 0x02
+	readonly PoisonMicroblock: 0x03
+	readonly Coinbase: 0x04
+	readonly CoinbaseToAltRecipient: 0x05
+	readonly VersionedSmartContract: 0x06
+	readonly TenureChange: 0x07
+	readonly NakamotoCoinbase: 0x08
+};
+type PayloadType = (typeof PayloadType)[keyof typeof PayloadType];
+declare const ClarityVersion: {
+	readonly Clarity1: 1
+	readonly Clarity2: 2
+	readonly Clarity3: 3
+};
+type ClarityVersion = (typeof ClarityVersion)[keyof typeof ClarityVersion];
+declare const AnchorMode: {
+	readonly OnChainOnly: 0x01
+	readonly OffChainOnly: 0x02
+	readonly Any: 0x03
+};
+type AnchorMode = (typeof AnchorMode)[keyof typeof AnchorMode];
+declare const PostConditionModeWire: {
+	readonly Allow: 0x01
+	readonly Deny: 0x02
+};
+type PostConditionModeWire = (typeof PostConditionModeWire)[keyof typeof PostConditionModeWire];
+declare const AddressHashMode: {
+	readonly P2PKH: 0x00
+	readonly P2SH: 0x01
+	readonly P2WPKH: 0x02
+	readonly P2WSH: 0x03
+	readonly P2SH_NonSequential: 0x05
+	readonly P2WSH_P2SH_NonSequential: 0x07
+};
+type AddressHashMode = (typeof AddressHashMode)[keyof typeof AddressHashMode];
+declare const PubKeyEncoding: {
+	readonly Compressed: 0x00
+	readonly Uncompressed: 0x01
+};
+type PubKeyEncoding = (typeof PubKeyEncoding)[keyof typeof PubKeyEncoding];
+declare const FungibleConditionCode: {
+	readonly Equal: 0x01
+	readonly Greater: 0x02
+	readonly GreaterEqual: 0x03
+	readonly Less: 0x04
+	readonly LessEqual: 0x05
+};
+declare const NonFungibleConditionCode: {
+	readonly Sends: 0x10
+	readonly DoesNotSend: 0x11
+};
+declare const PostConditionPrincipalId: {
+	readonly Origin: 0x01
+	readonly Standard: 0x02
+	readonly Contract: 0x03
+};
+declare const AssetType: {
+	readonly STX: 0x00
+	readonly Fungible: 0x01
+	readonly NonFungible: 0x02
+};
+declare const AuthFieldType: {
+	readonly PublicKeyCompressed: 0x00
+	readonly PublicKeyUncompressed: 0x01
+	readonly SignatureCompressed: 0x02
+	readonly SignatureUncompressed: 0x03
+};
+declare const RECOVERABLE_ECDSA_SIG_LENGTH_BYTES = 65;
+declare const MEMO_MAX_LENGTH_BYTES = 34;
+declare const MAX_STRING_LENGTH_BYTES = 128;
+type TokenTransferPayload = {
+	payloadType: typeof PayloadType.TokenTransfer
+	recipient: ClarityValue
+	amount: bigint
+	memo: string
+};
+type ContractCallPayload = {
+	payloadType: typeof PayloadType.ContractCall
+	contractAddress: string
+	contractName: string
+	functionName: string
+	functionArgs: ClarityValue[]
+};
+type SmartContractPayload = {
+	payloadType: typeof PayloadType.SmartContract | typeof PayloadType.VersionedSmartContract
+	clarityVersion?: ClarityVersion
+	contractName: string
+	codeBody: string
+};
+type TransactionPayload = TokenTransferPayload | ContractCallPayload | SmartContractPayload;
+type SingleSigSpendingCondition = {
+	hashMode: typeof AddressHashMode.P2PKH | typeof AddressHashMode.P2WPKH
+	signer: string
+	nonce: bigint
+	fee: bigint
+	keyEncoding: PubKeyEncoding
+	signature: string
+};
+type TransactionAuthField = {
+	pubKeyEncoding: PubKeyEncoding
+	type: "publicKey" | "signature"
+	data: string
+};
+type MultiSigHashMode = typeof AddressHashMode.P2SH | typeof AddressHashMode.P2WSH | typeof AddressHashMode.P2SH_NonSequential | typeof AddressHashMode.P2WSH_P2SH_NonSequential;
+type MultiSigSpendingCondition = {
+	hashMode: MultiSigHashMode
+	signer: string
+	nonce: bigint
+	fee: bigint
+	fields: TransactionAuthField[]
+	signaturesRequired: number
+};
+type SpendingCondition = SingleSigSpendingCondition | MultiSigSpendingCondition;
+type StandardAuthorization = {
+	authType: typeof AuthType.Standard
+	spendingCondition: SpendingCondition
+};
+type SponsoredAuthorization = {
+	authType: typeof AuthType.Sponsored
+	spendingCondition: SpendingCondition
+	sponsorSpendingCondition: SpendingCondition
+};
+type Authorization = StandardAuthorization | SponsoredAuthorization;
+type StacksTransaction = {
+	version: number
+	chainId: number
+	auth: Authorization
+	anchorMode: AnchorMode
+	postConditionMode: PostConditionModeWire
+	postConditions: PostConditionWire[]
+	payload: TransactionPayload
+};
+type PostConditionWire = StxPostConditionWire | FtPostConditionWire | NftPostConditionWire;
+type StxPostConditionWire = {
+	type: "stx"
+	principal: PostConditionPrincipalWire
+	conditionCode: number
+	amount: bigint
+};
+type FtPostConditionWire = {
+	type: "ft"
+	principal: PostConditionPrincipalWire
+	asset: AssetInfoWire
+	conditionCode: number
+	amount: bigint
+};
+type NftPostConditionWire = {
+	type: "nft"
+	principal: PostConditionPrincipalWire
+	asset: AssetInfoWire
+	conditionCode: number
+	assetId: ClarityValue
+};
+type PostConditionPrincipalWire = {
+	type: "origin"
+} | {
+	type: "standard"
+	address: string
+} | {
+	type: "contract"
+	address: string
+	contractName: string
+};
+type AssetInfoWire = {
+	address: string
+	contractName: string
+	assetName: string
+};
+declare function createSingleSigSpendingCondition(publicKey: string, nonce: bigint, fee: bigint): SingleSigSpendingCondition;
+declare function createStandardAuth(spendingCondition: SpendingCondition): StandardAuthorization;
+declare function createSponsoredAuth(spendingCondition: SpendingCondition, sponsorSpendingCondition?: SpendingCondition): SponsoredAuthorization;
+/** Compute pre-sign sighash = sha512/256(prevSigHash + authType + fee + nonce) */
+declare function sigHashPreSign(curSigHash: string, authType: number, fee: bigint, nonce: bigint): string;
+/** Compute post-sign sighash = sha512/256(preSigHash + pubKeyEncoding + signature) */
+declare function sigHashPostSign(curSigHash: string, pubKeyEncoding: number, signature: string): string;
+declare function nextSignature(curSigHash: string, authType: number, fee: bigint, nonce: bigint, privateKey: string): {
+	nextSig: string
+	nextSigHash: string
+};
+/** Account derived from a local private key (mnemonic or raw key). */
+type LocalAccount = {
+	type: "local"
+	address: string
+	/** Compressed public key (hex) */
+	publicKey: string
+	/** Raw ECDSA sign over a hash */
+	sign(hash: Uint8Array): Uint8Array
+	/** Sign a structured message (SIP-018) */
+	signMessage(message: string | Uint8Array): string
+};
+/** Account with a user-provided signing function (sync or async). */
+type CustomAccount = {
+	type: "custom"
+	address: string
+	publicKey: string
+	sign(hash: Uint8Array): Promise<Uint8Array> | Uint8Array
+};
+/** Compute the initial sighash for a transaction */
+declare function signBegin(tx: StacksTransaction): string;
+/** Sign a single-sig transaction with a private key, returning the signed transaction */
+declare function signTransaction(tx: StacksTransaction, privateKey: string): StacksTransaction;
+/** Sign a single-sig transaction using an account (LocalAccount or CustomAccount) */
+declare function signTransactionWithAccount(tx: StacksTransaction, account: LocalAccount | CustomAccount): Promise<StacksTransaction>;
+/** Get the txid of a transaction */
+declare function getTransactionId(tx: StacksTransaction): string;
+/** Reconstruct the sighash after origin signing (needed for sponsor signing) */
+declare function getOriginSigHash(tx: StacksTransaction): string;
+/** Sign a sponsored transaction as the sponsor with a private key */
+declare function signSponsor(tx: StacksTransaction, privateKey: string): StacksTransaction;
+/** Sign a sponsored transaction as the sponsor using an account */
+declare function signSponsorWithAccount(tx: StacksTransaction, account: LocalAccount | CustomAccount): Promise<StacksTransaction>;
+/** Full chain descriptor used by clients and transports for network-aware operations. */
+type StacksChain = {
+	/** Chain ID (e.g. 0x00000001 for mainnet) */
+	id: number
+	/** Human-readable name */
+	name: string
+	/** Network type */
+	network: "mainnet" | "testnet"
+	/** Transaction version byte for serialization */
+	transactionVersion: number
+	/** Peer network ID for P2P broadcasting */
+	peerNetworkId: number
+	/** Address version bytes */
+	addressVersion: {
+		singleSig: number
+		multiSig: number
+	}
+	/** Magic bytes for network identification */
+	magicBytes: string
+	/** Boot address (system contracts deployer) */
+	bootAddress: string
+	/** Native currency info */
+	nativeCurrency: {
+		name: string
+		symbol: string
+		decimals: number
+	}
+	/** Default RPC URLs */
+	rpcUrls: {
+		default: {
+			http: string[]
+			ws?: string[]
+		}
+	}
+	/** Block explorer URLs */
+	blockExplorers?: {
+		default: {
+			name: string
+			url: string
+		}
+	}
+};
+type FungibleComparator = "eq" | "gt" | "gte" | "lt" | "lte";
+type NonFungibleComparator = "sent" | "not-sent";
+type StxPostCondition = {
+	type: "stx-postcondition"
+	address: string
+	condition: FungibleComparator
+	amount: string | bigint | number
+};
+type FtPostCondition = {
+	type: "ft-postcondition"
+	address: string
+	condition: FungibleComparator
+	asset: string
+	amount: string | bigint | number
+};
+type NftPostCondition = {
+	type: "nft-postcondition"
+	address: string
+	condition: NonFungibleComparator
+	asset: string
+	assetId: ClarityValue
+};
+type PostCondition = StxPostCondition | FtPostCondition | NftPostCondition;
+type IntegerType = number | string | bigint | Uint8Array;
+type MultiSigOptions = {
+	publicKeys?: string[]
+	signaturesRequired?: number
+	hashMode?: MultiSigHashMode
+};
+type BuildTokenTransferOptions = MultiSigOptions & {
+	recipient: string
+	amount: IntegerType
+	memo?: string
+	fee: IntegerType
+	nonce: IntegerType
+	publicKey?: string
+	chain?: StacksChain
+	postConditionMode?: "allow" | "deny"
+	postConditions?: PostCondition[]
+	sponsored?: boolean
+};
+type BuildContractCallOptions = MultiSigOptions & {
+	contractAddress: string
+	contractName: string
+	functionName: string
+	functionArgs: ClarityValue[]
+	fee: IntegerType
+	nonce: IntegerType
+	publicKey?: string
+	chain?: StacksChain
+	postConditionMode?: "allow" | "deny"
+	postConditions?: PostCondition[]
+	sponsored?: boolean
+};
+type BuildContractDeployOptions = MultiSigOptions & {
+	contractName: string
+	codeBody: string
+	clarityVersion?: ClarityVersion
+	fee: IntegerType
+	nonce: IntegerType
+	publicKey?: string
+	chain?: StacksChain
+	postConditionMode?: "allow" | "deny"
+	postConditions?: PostCondition[]
+	sponsored?: boolean
+};
+declare function buildTokenTransfer(options: BuildTokenTransferOptions): StacksTransaction;
+declare function buildContractCall(options: BuildContractCallOptions): StacksTransaction;
+declare function buildContractDeploy(options: BuildContractDeployOptions): StacksTransaction;
+declare function serializeTransaction(tx: StacksTransaction): Uint8Array;
+declare function serializeTransactionHex(tx: StacksTransaction): string;
+declare function deserializeTransaction(input: string | Uint8Array): StacksTransaction;
+/** Check if hash mode is non-sequential (SIP-027) */
+declare function isNonSequential(hashMode: number): boolean;
+/** Derive a multi-sig address from public keys */
+declare function makeMultiSigAddress(publicKeys: string[], signaturesRequired: number, chain?: StacksChain): string;
+/** Create an empty multi-sig spending condition */
+declare function createMultiSigSpendingCondition(publicKeys: string[], signaturesRequired: number, nonce: bigint, fee: bigint, hashMode?: MultiSigHashMode): MultiSigSpendingCondition;
+/** Replay sighash through existing auth fields of a multi-sig tx */
+declare function replayMultiSigSigHash(tx: StacksTransaction): string;
+/** Sign one position of a multi-sig transaction with a private key */
+declare function signMultiSig(tx: StacksTransaction, privateKey: string, publicKeys: string[]): StacksTransaction;
+/** Sign one position of a multi-sig transaction with an account */
+declare function signMultiSigWithAccount(tx: StacksTransaction, account: LocalAccount | CustomAccount, publicKeys: string[]): Promise<StacksTransaction>;
+/** Fill remaining slots with pubkey fields after all signatures are collected */
+declare function finalizeMultiSig(tx: StacksTransaction, publicKeys: string[]): StacksTransaction;
+/** Combine independently-signed non-sequential multi-sig transactions */
+declare function combineMultiSigSignatures(baseTx: StacksTransaction, signedTxs: StacksTransaction[]): StacksTransaction;
+export { signTransactionWithAccount, signTransaction, signSponsorWithAccount, signSponsor, signMultiSigWithAccount, signMultiSig, signBegin, sigHashPreSign, sigHashPostSign, serializeTransactionHex, serializeTransaction, replayMultiSigSigHash, nextSignature, makeMultiSigAddress, isNonSequential, getTransactionId, getOriginSigHash, finalizeMultiSig, deserializeTransaction, createStandardAuth, createSponsoredAuth, createSingleSigSpendingCondition, createMultiSigSpendingCondition, combineMultiSigSignatures, buildTokenTransfer, buildContractDeploy, buildContractCall, TransactionPayload, TransactionAuthField, TokenTransferPayload, StandardAuthorization, StacksTransaction, SponsoredAuthorization, SpendingCondition, SmartContractPayload, SingleSigSpendingCondition, RECOVERABLE_ECDSA_SIG_LENGTH_BYTES, PubKeyEncoding, PostConditionWire, PostConditionPrincipalId, PostConditionModeWire, PayloadType, NonFungibleConditionCode, MultiSigSpendingCondition, MultiSigHashMode, MEMO_MAX_LENGTH_BYTES, MAX_STRING_LENGTH_BYTES, FungibleConditionCode, ContractCallPayload, ClarityVersion, BuildTokenTransferOptions, BuildContractDeployOptions, BuildContractCallOptions, Authorization, AuthType, AuthFieldType, AssetType, AnchorMode, AddressHashMode };

package/dist/src/transactions/index.js

@@ -0,0 +1,101 @@
+import {
+  deserializeTransaction
+} from "../../shared/stacks-dxhntr76.js";
+import {
+  buildContractCall,
+  buildContractDeploy,
+  buildTokenTransfer,
+  getOriginSigHash,
+  getTransactionId,
+  signBegin,
+  signSponsor,
+  signSponsorWithAccount,
+  signTransaction,
+  signTransactionWithAccount
+} from "../../shared/stacks-f7wdrzs3.js";
+import {
+  AddressHashMode,
+  AnchorMode,
+  AssetType,
+  AuthFieldType,
+  AuthType,
+  ClarityVersion,
+  FungibleConditionCode,
+  MAX_STRING_LENGTH_BYTES,
+  MEMO_MAX_LENGTH_BYTES,
+  NonFungibleConditionCode,
+  PayloadType,
+  PostConditionModeWire,
+  PostConditionPrincipalId,
+  PubKeyEncoding,
+  RECOVERABLE_ECDSA_SIG_LENGTH_BYTES,
+  combineMultiSigSignatures,
+  createMultiSigSpendingCondition,
+  createSingleSigSpendingCondition,
+  createSponsoredAuth,
+  createStandardAuth,
+  finalizeMultiSig,
+  isNonSequential,
+  makeMultiSigAddress,
+  nextSignature,
+  replayMultiSigSigHash,
+  serializeTransaction,
+  serializeTransactionHex,
+  sigHashPostSign,
+  sigHashPreSign,
+  signMultiSig,
+  signMultiSigWithAccount
+} from "../../shared/stacks-yfgsm6ap.js";
+import"../../shared/stacks-j2cy7qtt.js";
+import"../../shared/stacks-8yykgdww.js";
+import"../../shared/stacks-bycy6t9k.js";
+import"../../shared/stacks-gjvbq6w7.js";
+import"../../shared/stacks-nqytwfcc.js";
+import"../../shared/stacks-8m9byk2j.js";
+export {
+  signTransactionWithAccount,
+  signTransaction,
+  signSponsorWithAccount,
+  signSponsor,
+  signMultiSigWithAccount,
+  signMultiSig,
+  signBegin,
+  sigHashPreSign,
+  sigHashPostSign,
+  serializeTransactionHex,
+  serializeTransaction,
+  replayMultiSigSigHash,
+  nextSignature,
+  makeMultiSigAddress,
+  isNonSequential,
+  getTransactionId,
+  getOriginSigHash,
+  finalizeMultiSig,
+  deserializeTransaction,
+  createStandardAuth,
+  createSponsoredAuth,
+  createSingleSigSpendingCondition,
+  createMultiSigSpendingCondition,
+  combineMultiSigSignatures,
+  buildTokenTransfer,
+  buildContractDeploy,
+  buildContractCall,
+  RECOVERABLE_ECDSA_SIG_LENGTH_BYTES,
+  PubKeyEncoding,
+  PostConditionPrincipalId,
+  PostConditionModeWire,
+  PayloadType,
+  NonFungibleConditionCode,
+  MEMO_MAX_LENGTH_BYTES,
+  MAX_STRING_LENGTH_BYTES,
+  FungibleConditionCode,
+  ClarityVersion,
+  AuthType,
+  AuthFieldType,
+  AssetType,
+  AnchorMode,
+  AddressHashMode
+};
+
+//# debugId=4E20CE27699281AF64756E2164756E21
+//# sourceMappingURL=index.js.map

package/dist/src/transactions/index.js.map

@@ -0,0 +1,9 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [
+  ],
+  "mappings": "",
+  "debugId": "4E20CE27699281AF64756E2164756E21",
+  "names": []
+}

package/dist/src/utils/index.cjs

@@ -0,0 +1,168 @@
+// src/utils/index.ts
+var exports_utils = {};
+__export(exports_utils, {
+  writeUInt8: () => writeUInt8,
+  writeUInt32BE: () => writeUInt32BE,
+  writeUInt16BE: () => writeUInt16BE,
+  without0x: () => without0x,
+  with0x: () => with0x,
+  verifySignature: () => verifySignature,
+  verifyMessageSignature: () => verifyMessageSignature,
+  validateStacksAddress: () => validateStacksAddress,
+  utf8ToBytes: () => utf8ToBytes,
+  uncompressPublicKey: () => uncompressPublicKey,
+  txidFromBytes: () => txidFromBytes,
+  toTwos: () => toTwos,
+  signatureVrsToRsv: () => signatureVrsToRsv,
+  signatureRsvToVrs: () => signatureRsvToVrs,
+  sha512_256: () => import_sha22.sha512_256,
+  sha256: () => import_sha2.sha256,
+  serializeSignature: () => serializeSignature,
+  ripemd160: () => import_legacy.ripemd160,
+  recoverPublicKey: () => recoverPublicKey,
+  recoverAddress: () => recoverAddress,
+  readUInt32BE: () => readUInt32BE,
+  readUInt16BE: () => readUInt16BE,
+  randomBytes: () => randomBytes,
+  parseUnits: () => parseUnits,
+  parseStx: () => parseStx,
+  parseSignature: () => parseSignature,
+  parseContractId: () => parseContractId,
+  isValidAddress: () => isValidAddress,
+  isCompressedPublicKey: () => isCompressedPublicKey,
+  isClarityName: () => isClarityName,
+  isAddressEqual: () => isAddressEqual,
+  intToHex: () => intToHex,
+  intToBytes: () => intToBytes,
+  intToBigInt: () => intToBigInt,
+  hexToBytes: () => hexToBytes,
+  hashP2PKH: () => hashP2PKH,
+  hash160: () => hash160,
+  getContractAddress: () => getContractAddress,
+  fromTwos: () => fromTwos,
+  formatUnits: () => formatUnits,
+  formatStx: () => formatStx,
+  concatBytes: () => concatBytes,
+  compressPublicKey: () => compressPublicKey,
+  c32addressDecode: () => c32addressDecode,
+  c32address: () => c32address,
+  bytesToUtf8: () => bytesToUtf8,
+  bytesToTwosBigInt: () => bytesToTwosBigInt,
+  bytesToHex: () => bytesToHex,
+  bytesToAscii: () => bytesToAscii,
+  bigIntToBytes: () => bigIntToBytes,
+  asciiToBytes: () => asciiToBytes,
+  addressToVersion: () => addressToVersion,
+  ZERO_ADDRESS: () => ZERO_ADDRESS,
+  TESTNET_ZERO_ADDRESS: () => TESTNET_ZERO_ADDRESS,
+  MIN_I128: () => MIN_I128,
+  MICROSTX_PER_STX: () => MICROSTX_PER_STX,
+  MAX_U128: () => MAX_U128,
+  MAX_I128: () => MAX_I128,
+  AddressVersion: () => AddressVersion
+});
+module.exports = __toCommonJS(exports_utils);
+
+// src/utils/signature.ts
+var import_secp256k1 = require("@noble/secp256k1");
+var import_sha23 = require("@noble/hashes/sha2.js");
+function parseSignature(hex) {
+  const clean = hex.startsWith("0x") ? hex.slice(2) : hex;
+  if (clean.length !== 130) {
+    throw new Error(`Invalid signature length: expected 130 hex chars, got ${clean.length}`);
+  }
+  return {
+    recovery: parseInt(clean.slice(0, 2), 16),
+    r: clean.slice(2, 66),
+    s: clean.slice(66, 130)
+  };
+}
+function serializeSignature(sig) {
+  const v = sig.recovery.toString(16).padStart(2, "0");
+  return v + sig.r + sig.s;
+}
+function signatureVrsToRsv(vrs) {
+  const clean = vrs.startsWith("0x") ? vrs.slice(2) : vrs;
+  return clean.slice(2) + clean.slice(0, 2);
+}
+function signatureRsvToVrs(rsv) {
+  const clean = rsv.startsWith("0x") ? rsv.slice(2) : rsv;
+  return clean.slice(-2) + clean.slice(0, -2);
+}
+function recoverPublicKey(hash, signature, compressed = true) {
+  const parsed = parseSignature(signature);
+  const rs = parsed.r + parsed.s;
+  const sig = import_secp256k1.Signature.fromCompact(rs).addRecoveryBit(parsed.recovery);
+  const msgHash = typeof hash === "string" ? hexToBytes(hash) : hash;
+  const point = sig.recoverPublicKey(msgHash);
+  return point.toHex(compressed);
+}
+function recoverAddress(hash, signature, addressVersion = AddressVersion.MainnetSingleSig) {
+  const pubkey = recoverPublicKey(hash, signature, true);
+  const pubkeyHash = hashP2PKH(hexToBytes(pubkey));
+  return c32address(addressVersion, pubkeyHash);
+}
+function verifySignature(hash, signature, publicKey) {
+  return import_secp256k1.verify(signature, hash, publicKey, { lowS: false });
+}
+function encodeVarint(n) {
+  if (n < 253)
+    return new Uint8Array([n]);
+  if (n <= 65535) {
+    const buf2 = new Uint8Array(3);
+    buf2[0] = 253;
+    buf2[1] = n & 255;
+    buf2[2] = n >> 8 & 255;
+    return buf2;
+  }
+  const buf = new Uint8Array(5);
+  buf[0] = 254;
+  buf[1] = n & 255;
+  buf[2] = n >> 8 & 255;
+  buf[3] = n >> 16 & 255;
+  buf[4] = n >> 24 & 255;
+  return buf;
+}
+var STACKS_MESSAGE_PREFIX = `\x17Stacks Signed Message:
+`;
+var LEGACY_MESSAGE_PREFIX = `\x18Stacks Message Signing:
+`;
+function hashMessage(message, prefix) {
+  const messageBytes = typeof message === "string" ? utf8ToBytes(message) : message;
+  const prefixBytes = utf8ToBytes(prefix);
+  const lengthBytes = encodeVarint(messageBytes.length);
+  return import_sha23.sha256(concatBytes(prefixBytes, lengthBytes, messageBytes));
+}
+function verifyMessageSignature(message, signature, publicKey) {
+  const parsed = parseSignature(signature);
+  const compactSig = parsed.r + parsed.s;
+  const msgHash = hashMessage(message, STACKS_MESSAGE_PREFIX);
+  if (import_secp256k1.verify(compactSig, msgHash, publicKey, { lowS: false }))
+    return true;
+  if (typeof message === "string") {
+    const legacyHash = hashMessage(message, LEGACY_MESSAGE_PREFIX);
+    if (import_secp256k1.verify(compactSig, legacyHash, publicKey, { lowS: false }))
+      return true;
+  }
+  return false;
+}
+// src/utils/keys.ts
+var import_secp256k12 = require("@noble/secp256k1");
+function compressPublicKey(publicKey) {
+  const hex = typeof publicKey === "string" ? publicKey : bytesToHex(publicKey);
+  return import_secp256k12.Point.fromHex(hex).toHex(true);
+}
+function uncompressPublicKey(publicKey) {
+  const hex = typeof publicKey === "string" ? publicKey : bytesToHex(publicKey);
+  return import_secp256k12.Point.fromHex(hex).toHex(false);
+}
+function isCompressedPublicKey(publicKey) {
+  const bytes = typeof publicKey === "string" ? hexToBytes(publicKey) : publicKey;
+  return bytes.length === 33 && (bytes[0] === 2 || bytes[0] === 3);
+}
+function randomBytes(length) {
+  return import_secp256k12.etc.randomBytes(length ?? 32);
+}
+
+//# debugId=F1D67D47267AF34764756E2164756E21
+//# sourceMappingURL=index.cjs.map