@secondlayer/stacks 0.0.1

package/dist/src/utils/index.cjs.map

@@ -0,0 +1,11 @@
+{
+  "version": 3,
+  "sources": ["../src/utils/signature.ts", "../src/utils/keys.ts"],
+  "sourcesContent": [
+    "import { Signature as NobleSignature, verify, Point } from \"@noble/secp256k1\";\nimport { sha256 } from \"@noble/hashes/sha2.js\";\nimport { bytesToHex, hexToBytes, concatBytes, utf8ToBytes } from \"./encoding.ts\";\nimport { hash160, hashP2PKH } from \"./hash.ts\";\nimport { c32address } from \"./address.ts\";\nimport { AddressVersion } from \"./constants.ts\";\n\nexport interface RecoverableSignature {\n  /** Recovery id (0–3) */\n  recovery: number;\n  /** 32-byte r value as hex */\n  r: string;\n  /** 32-byte s value as hex */\n  s: string;\n}\n\n// --- Format conversion ---\n\n/**\n * Parse a 65-byte VRS hex signature into components.\n * VRS format: recovery (1 byte) + r (32 bytes) + s (32 bytes)\n */\nexport function parseSignature(hex: string): RecoverableSignature {\n  const clean = hex.startsWith(\"0x\") ? hex.slice(2) : hex;\n  if (clean.length !== 130) {\n    throw new Error(`Invalid signature length: expected 130 hex chars, got ${clean.length}`);\n  }\n  return {\n    recovery: parseInt(clean.slice(0, 2), 16),\n    r: clean.slice(2, 66),\n    s: clean.slice(66, 130),\n  };\n}\n\n/**\n * Serialize a recoverable signature to 65-byte VRS hex (130 chars).\n */\nexport function serializeSignature(sig: RecoverableSignature): string {\n  const v = sig.recovery.toString(16).padStart(2, \"0\");\n  return v + sig.r + sig.s;\n}\n\n/** Convert VRS hex to RSV hex: r+s (128 chars) + recovery (2 chars). */\nexport function signatureVrsToRsv(vrs: string): string {\n  const clean = vrs.startsWith(\"0x\") ? vrs.slice(2) : vrs;\n  return clean.slice(2) + clean.slice(0, 2);\n}\n\n/** Convert RSV hex to VRS hex: recovery (2 chars) + r+s (128 chars). */\nexport function signatureRsvToVrs(rsv: string): string {\n  const clean = rsv.startsWith(\"0x\") ? rsv.slice(2) : rsv;\n  return clean.slice(-2) + clean.slice(0, -2);\n}\n\n// --- Recovery ---\n\n/**\n * Recover a public key from a message hash and VRS signature.\n * @returns hex-encoded public key (33 bytes compressed, or 65 bytes uncompressed)\n */\nexport function recoverPublicKey(\n  hash: Uint8Array | string,\n  signature: string,\n  compressed = true\n): string {\n  const parsed = parseSignature(signature);\n  const rs = parsed.r + parsed.s;\n  const sig = NobleSignature.fromCompact(rs).addRecoveryBit(parsed.recovery);\n  const msgHash = typeof hash === \"string\" ? hexToBytes(hash) : hash;\n  const point = sig.recoverPublicKey(msgHash);\n  return point.toHex(compressed);\n}\n\n/**\n * Recover a Stacks address from a message hash and VRS signature.\n * @param addressVersion defaults to MainnetSingleSig (22)\n */\nexport function recoverAddress(\n  hash: Uint8Array | string,\n  signature: string,\n  addressVersion: number = AddressVersion.MainnetSingleSig\n): string {\n  const pubkey = recoverPublicKey(hash, signature, true);\n  const pubkeyHash = hashP2PKH(hexToBytes(pubkey));\n  return c32address(addressVersion, pubkeyHash);\n}\n\n// --- Verification ---\n\n/**\n * Verify an ECDSA signature against a message hash and public key.\n * Accepts compact (64-byte) signature as hex or Uint8Array.\n */\nexport function verifySignature(\n  hash: Uint8Array | string,\n  signature: string | Uint8Array,\n  publicKey: string | Uint8Array\n): boolean {\n  return verify(signature, hash, publicKey, { lowS: false });\n}\n\n/** Bitcoin-style varint encoding for message length prefix. */\nfunction encodeVarint(n: number): Uint8Array {\n  if (n < 0xfd) return new Uint8Array([n]);\n  if (n <= 0xffff) {\n    const buf = new Uint8Array(3);\n    buf[0] = 0xfd;\n    buf[1] = n & 0xff;\n    buf[2] = (n >> 8) & 0xff;\n    return buf;\n  }\n  const buf = new Uint8Array(5);\n  buf[0] = 0xfe;\n  buf[1] = n & 0xff;\n  buf[2] = (n >> 8) & 0xff;\n  buf[3] = (n >> 16) & 0xff;\n  buf[4] = (n >> 24) & 0xff;\n  return buf;\n}\n\nconst STACKS_MESSAGE_PREFIX = \"\\x17Stacks Signed Message:\\n\";\nconst LEGACY_MESSAGE_PREFIX = \"\\x18Stacks Message Signing:\\n\";\n\n/** Hash a message with the Stacks structured message prefix. */\nfunction hashMessage(message: string | Uint8Array, prefix: string): Uint8Array {\n  const messageBytes = typeof message === \"string\" ? utf8ToBytes(message) : message;\n  const prefixBytes = utf8ToBytes(prefix);\n  const lengthBytes = encodeVarint(messageBytes.length);\n  return sha256(concatBytes(prefixBytes, lengthBytes, messageBytes));\n}\n\n/**\n * Verify a signed Stacks message.\n * Parses a VRS signature, extracts r+s for verification.\n * Falls back to legacy prefix if standard prefix fails.\n */\nexport function verifyMessageSignature(\n  message: string | Uint8Array,\n  signature: string,\n  publicKey: string\n): boolean {\n  const parsed = parseSignature(signature);\n  const compactSig = parsed.r + parsed.s;\n\n  const msgHash = hashMessage(message, STACKS_MESSAGE_PREFIX);\n  if (verify(compactSig, msgHash, publicKey, { lowS: false })) return true;\n\n  // Fallback to legacy prefix\n  if (typeof message === \"string\") {\n    const legacyHash = hashMessage(message, LEGACY_MESSAGE_PREFIX);\n    if (verify(compactSig, legacyHash, publicKey, { lowS: false })) return true;\n  }\n\n  return false;\n}\n",
+    "import { Point, etc } from \"@noble/secp256k1\";\nimport { bytesToHex, hexToBytes } from \"./encoding.ts\";\n\n/** Compress a public key to 33 bytes (hex). */\nexport function compressPublicKey(publicKey: string | Uint8Array): string {\n  const hex = typeof publicKey === \"string\" ? publicKey : bytesToHex(publicKey);\n  return Point.fromHex(hex).toHex(true);\n}\n\n/** Uncompress a public key to 65 bytes (hex). */\nexport function uncompressPublicKey(publicKey: string | Uint8Array): string {\n  const hex = typeof publicKey === \"string\" ? publicKey : bytesToHex(publicKey);\n  return Point.fromHex(hex).toHex(false);\n}\n\n/** Check if a public key is in compressed format (starts with 0x02 or 0x03). */\nexport function isCompressedPublicKey(publicKey: string | Uint8Array): boolean {\n  const bytes = typeof publicKey === \"string\" ? hexToBytes(publicKey) : publicKey;\n  return bytes.length === 33 && (bytes[0] === 0x02 || bytes[0] === 0x03);\n}\n\n/** Generate cryptographically secure random bytes. Defaults to 32 bytes. */\nexport function randomBytes(length?: number): Uint8Array {\n  return etc.randomBytes(length ?? 32);\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "F1D67D47267AF34764756E2164756E21",
+  "names": []
+}

package/dist/src/utils/index.d.cts

@@ -0,0 +1,140 @@
+declare function bytesToHex(bytes: Uint8Array): string;
+declare function hexToBytes(hex: string): Uint8Array;
+declare function with0x(value: string): string;
+declare function without0x(value: string): string;
+declare function utf8ToBytes(str: string): Uint8Array;
+declare function bytesToUtf8(bytes: Uint8Array): string;
+declare function asciiToBytes(str: string): Uint8Array;
+declare function bytesToAscii(bytes: Uint8Array): string;
+declare function concatBytes(...arrays: Uint8Array[]): Uint8Array;
+type IntegerType = number | string | bigint | Uint8Array;
+declare function intToBigInt(value: IntegerType): bigint;
+declare function intToBytes(value: IntegerType, byteLength: number): Uint8Array;
+declare function bigIntToBytes(value: bigint, length?: number): Uint8Array;
+declare function intToHex(integer: IntegerType, byteLength?: number): string;
+declare function toTwos(value: bigint, width: bigint): bigint;
+declare function fromTwos(value: bigint, width: bigint): bigint;
+declare function bytesToTwosBigInt(bytes: Uint8Array): bigint;
+declare function writeUInt32BE(value: number): Uint8Array;
+declare function readUInt32BE(bytes: Uint8Array, offset?: number): number;
+declare function writeUInt16BE(value: number): Uint8Array;
+declare function readUInt16BE(bytes: Uint8Array, offset?: number): number;
+declare function writeUInt8(value: number): Uint8Array;
+import { ripemd160 } from "@noble/hashes/legacy";
+import { sha256 } from "@noble/hashes/sha2";
+import { sha512_256 } from "@noble/hashes/sha2";
+/** RIPEMD160(SHA256(input)) — standard Bitcoin/Stacks address hash */
+declare function hash160(input: Uint8Array): Uint8Array;
+/** Hash used for transaction IDs */
+declare function txidFromBytes(data: Uint8Array): string;
+/** hash160 as hex — used for P2PKH address derivation */
+declare function hashP2PKH(input: Uint8Array): string;
+declare function c32address(version: number, hash160hex: string): string;
+declare function c32addressDecode(c32addr: string): [number, string];
+declare function validateStacksAddress(address: string): boolean;
+/** Alias for validateStacksAddress — matches future.md naming. */
+declare const isValidAddress: unknown;
+declare function parseContractId(contractId: string): [string, string];
+declare function isClarityName(name: string): boolean;
+/**
+* Compare two Stacks addresses for equality (case-insensitive, version-aware).
+* Throws if either address is invalid.
+*/
+declare function isAddressEqual(a: string, b: string): boolean;
+/** Extract the version byte from a Stacks address (22, 20, 26, or 21). */
+declare function addressToVersion(address: string): number;
+/**
+* Build a contract address from deployer + contract name.
+* Validates both parts; returns `deployer.contractName`.
+*/
+declare function getContractAddress(deployer: string, contractName: string): string;
+declare const MAX_U128: unknown;
+declare const MAX_I128: unknown;
+declare const MIN_I128: unknown;
+/** C32-encoded address version bytes for single-sig and multi-sig on each network. */
+declare const AddressVersion: {
+	readonly MainnetSingleSig: 22
+	readonly MainnetMultiSig: 20
+	readonly TestnetSingleSig: 26
+	readonly TestnetMultiSig: 21
+};
+type AddressVersion = (typeof AddressVersion)[keyof typeof AddressVersion];
+/** Mainnet burn address (all-zero hash160). */
+declare const ZERO_ADDRESS = "SP000000000000000000002Q6VF78";
+/** Testnet burn address (all-zero hash160). */
+declare const TESTNET_ZERO_ADDRESS = "ST000000000000000000002AMW42H";
+/** Number of microSTX per 1 STX (10^6). */
+declare const MICROSTX_PER_STX = 1000000n;
+/**
+* Format a bigint value with decimal places.
+* @example formatUnits(1000000n, 6) → "1.0"
+* @example formatUnits(1500000n, 6) → "1.5"
+*/
+declare function formatUnits(value: bigint | number | string, decimals: number): string;
+/**
+* Parse a decimal string into a bigint with the given number of decimals.
+* @example parseUnits("1.5", 6) → 1500000n
+* @example parseUnits("1", 6) → 1000000n
+*/
+declare function parseUnits(value: string | number, decimals: number): bigint;
+/**
+* Format microSTX to STX string (6 decimals).
+* @example formatStx(1000000n) → "1.0"
+*/
+declare function formatStx(microStx: bigint | number | string): string;
+/**
+* Parse STX string to microSTX bigint (6 decimals).
+* @example parseStx("1.5") → 1500000n
+*/
+declare function parseStx(stx: string | number): bigint;
+interface RecoverableSignature {
+	/** Recovery id (0–3) */
+	recovery: number;
+	/** 32-byte r value as hex */
+	r: string;
+	/** 32-byte s value as hex */
+	s: string;
+}
+/**
+* Parse a 65-byte VRS hex signature into components.
+* VRS format: recovery (1 byte) + r (32 bytes) + s (32 bytes)
+*/
+declare function parseSignature(hex: string): RecoverableSignature;
+/**
+* Serialize a recoverable signature to 65-byte VRS hex (130 chars).
+*/
+declare function serializeSignature(sig: RecoverableSignature): string;
+/** Convert VRS hex to RSV hex: r+s (128 chars) + recovery (2 chars). */
+declare function signatureVrsToRsv(vrs: string): string;
+/** Convert RSV hex to VRS hex: recovery (2 chars) + r+s (128 chars). */
+declare function signatureRsvToVrs(rsv: string): string;
+/**
+* Recover a public key from a message hash and VRS signature.
+* @returns hex-encoded public key (33 bytes compressed, or 65 bytes uncompressed)
+*/
+declare function recoverPublicKey(hash: Uint8Array | string, signature: string, compressed?: boolean): string;
+/**
+* Recover a Stacks address from a message hash and VRS signature.
+* @param addressVersion defaults to MainnetSingleSig (22)
+*/
+declare function recoverAddress(hash: Uint8Array | string, signature: string, addressVersion?: number): string;
+/**
+* Verify an ECDSA signature against a message hash and public key.
+* Accepts compact (64-byte) signature as hex or Uint8Array.
+*/
+declare function verifySignature(hash: Uint8Array | string, signature: string | Uint8Array, publicKey: string | Uint8Array): boolean;
+/**
+* Verify a signed Stacks message.
+* Parses a VRS signature, extracts r+s for verification.
+* Falls back to legacy prefix if standard prefix fails.
+*/
+declare function verifyMessageSignature(message: string | Uint8Array, signature: string, publicKey: string): boolean;
+/** Compress a public key to 33 bytes (hex). */
+declare function compressPublicKey(publicKey: string | Uint8Array): string;
+/** Uncompress a public key to 65 bytes (hex). */
+declare function uncompressPublicKey(publicKey: string | Uint8Array): string;
+/** Check if a public key is in compressed format (starts with 0x02 or 0x03). */
+declare function isCompressedPublicKey(publicKey: string | Uint8Array): boolean;
+/** Generate cryptographically secure random bytes. Defaults to 32 bytes. */
+declare function randomBytes(length?: number): Uint8Array;
+export { writeUInt8, writeUInt32BE, writeUInt16BE, without0x, with0x, verifySignature, verifyMessageSignature, validateStacksAddress, utf8ToBytes, uncompressPublicKey, txidFromBytes, toTwos, signatureVrsToRsv, signatureRsvToVrs, sha512_256, sha256, serializeSignature, ripemd160, recoverPublicKey, recoverAddress, readUInt32BE, readUInt16BE, randomBytes, parseUnits, parseStx, parseSignature, parseContractId, isValidAddress, isCompressedPublicKey, isClarityName, isAddressEqual, intToHex, intToBytes, intToBigInt, hexToBytes, hashP2PKH, hash160, getContractAddress, fromTwos, formatUnits, formatStx, concatBytes, compressPublicKey, c32addressDecode, c32address, bytesToUtf8, bytesToTwosBigInt, bytesToHex, bytesToAscii, bigIntToBytes, asciiToBytes, addressToVersion, ZERO_ADDRESS, TESTNET_ZERO_ADDRESS, RecoverableSignature, MIN_I128, MICROSTX_PER_STX, MAX_U128, MAX_I128, IntegerType, AddressVersion };

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

@@ -0,0 +1,140 @@
+declare function bytesToHex(bytes: Uint8Array): string;
+declare function hexToBytes(hex: string): Uint8Array;
+declare function with0x(value: string): string;
+declare function without0x(value: string): string;
+declare function utf8ToBytes(str: string): Uint8Array;
+declare function bytesToUtf8(bytes: Uint8Array): string;
+declare function asciiToBytes(str: string): Uint8Array;
+declare function bytesToAscii(bytes: Uint8Array): string;
+declare function concatBytes(...arrays: Uint8Array[]): Uint8Array;
+type IntegerType = number | string | bigint | Uint8Array;
+declare function intToBigInt(value: IntegerType): bigint;
+declare function intToBytes(value: IntegerType, byteLength: number): Uint8Array;
+declare function bigIntToBytes(value: bigint, length?: number): Uint8Array;
+declare function intToHex(integer: IntegerType, byteLength?: number): string;
+declare function toTwos(value: bigint, width: bigint): bigint;
+declare function fromTwos(value: bigint, width: bigint): bigint;
+declare function bytesToTwosBigInt(bytes: Uint8Array): bigint;
+declare function writeUInt32BE(value: number): Uint8Array;
+declare function readUInt32BE(bytes: Uint8Array, offset?: number): number;
+declare function writeUInt16BE(value: number): Uint8Array;
+declare function readUInt16BE(bytes: Uint8Array, offset?: number): number;
+declare function writeUInt8(value: number): Uint8Array;
+import { ripemd160 } from "@noble/hashes/legacy";
+import { sha256 } from "@noble/hashes/sha2";
+import { sha512_256 } from "@noble/hashes/sha2";
+/** RIPEMD160(SHA256(input)) — standard Bitcoin/Stacks address hash */
+declare function hash160(input: Uint8Array): Uint8Array;
+/** Hash used for transaction IDs */
+declare function txidFromBytes(data: Uint8Array): string;
+/** hash160 as hex — used for P2PKH address derivation */
+declare function hashP2PKH(input: Uint8Array): string;
+declare function c32address(version: number, hash160hex: string): string;
+declare function c32addressDecode(c32addr: string): [number, string];
+declare function validateStacksAddress(address: string): boolean;
+/** Alias for validateStacksAddress — matches future.md naming. */
+declare const isValidAddress: unknown;
+declare function parseContractId(contractId: string): [string, string];
+declare function isClarityName(name: string): boolean;
+/**
+* Compare two Stacks addresses for equality (case-insensitive, version-aware).
+* Throws if either address is invalid.
+*/
+declare function isAddressEqual(a: string, b: string): boolean;
+/** Extract the version byte from a Stacks address (22, 20, 26, or 21). */
+declare function addressToVersion(address: string): number;
+/**
+* Build a contract address from deployer + contract name.
+* Validates both parts; returns `deployer.contractName`.
+*/
+declare function getContractAddress(deployer: string, contractName: string): string;
+declare const MAX_U128: unknown;
+declare const MAX_I128: unknown;
+declare const MIN_I128: unknown;
+/** C32-encoded address version bytes for single-sig and multi-sig on each network. */
+declare const AddressVersion: {
+	readonly MainnetSingleSig: 22
+	readonly MainnetMultiSig: 20
+	readonly TestnetSingleSig: 26
+	readonly TestnetMultiSig: 21
+};
+type AddressVersion = (typeof AddressVersion)[keyof typeof AddressVersion];
+/** Mainnet burn address (all-zero hash160). */
+declare const ZERO_ADDRESS = "SP000000000000000000002Q6VF78";
+/** Testnet burn address (all-zero hash160). */
+declare const TESTNET_ZERO_ADDRESS = "ST000000000000000000002AMW42H";
+/** Number of microSTX per 1 STX (10^6). */
+declare const MICROSTX_PER_STX = 1000000n;
+/**
+* Format a bigint value with decimal places.
+* @example formatUnits(1000000n, 6) → "1.0"
+* @example formatUnits(1500000n, 6) → "1.5"
+*/
+declare function formatUnits(value: bigint | number | string, decimals: number): string;
+/**
+* Parse a decimal string into a bigint with the given number of decimals.
+* @example parseUnits("1.5", 6) → 1500000n
+* @example parseUnits("1", 6) → 1000000n
+*/
+declare function parseUnits(value: string | number, decimals: number): bigint;
+/**
+* Format microSTX to STX string (6 decimals).
+* @example formatStx(1000000n) → "1.0"
+*/
+declare function formatStx(microStx: bigint | number | string): string;
+/**
+* Parse STX string to microSTX bigint (6 decimals).
+* @example parseStx("1.5") → 1500000n
+*/
+declare function parseStx(stx: string | number): bigint;
+interface RecoverableSignature {
+	/** Recovery id (0–3) */
+	recovery: number;
+	/** 32-byte r value as hex */
+	r: string;
+	/** 32-byte s value as hex */
+	s: string;
+}
+/**
+* Parse a 65-byte VRS hex signature into components.
+* VRS format: recovery (1 byte) + r (32 bytes) + s (32 bytes)
+*/
+declare function parseSignature(hex: string): RecoverableSignature;
+/**
+* Serialize a recoverable signature to 65-byte VRS hex (130 chars).
+*/
+declare function serializeSignature(sig: RecoverableSignature): string;
+/** Convert VRS hex to RSV hex: r+s (128 chars) + recovery (2 chars). */
+declare function signatureVrsToRsv(vrs: string): string;
+/** Convert RSV hex to VRS hex: recovery (2 chars) + r+s (128 chars). */
+declare function signatureRsvToVrs(rsv: string): string;
+/**
+* Recover a public key from a message hash and VRS signature.
+* @returns hex-encoded public key (33 bytes compressed, or 65 bytes uncompressed)
+*/
+declare function recoverPublicKey(hash: Uint8Array | string, signature: string, compressed?: boolean): string;
+/**
+* Recover a Stacks address from a message hash and VRS signature.
+* @param addressVersion defaults to MainnetSingleSig (22)
+*/
+declare function recoverAddress(hash: Uint8Array | string, signature: string, addressVersion?: number): string;
+/**
+* Verify an ECDSA signature against a message hash and public key.
+* Accepts compact (64-byte) signature as hex or Uint8Array.
+*/
+declare function verifySignature(hash: Uint8Array | string, signature: string | Uint8Array, publicKey: string | Uint8Array): boolean;
+/**
+* Verify a signed Stacks message.
+* Parses a VRS signature, extracts r+s for verification.
+* Falls back to legacy prefix if standard prefix fails.
+*/
+declare function verifyMessageSignature(message: string | Uint8Array, signature: string, publicKey: string): boolean;
+/** Compress a public key to 33 bytes (hex). */
+declare function compressPublicKey(publicKey: string | Uint8Array): string;
+/** Uncompress a public key to 65 bytes (hex). */
+declare function uncompressPublicKey(publicKey: string | Uint8Array): string;
+/** Check if a public key is in compressed format (starts with 0x02 or 0x03). */
+declare function isCompressedPublicKey(publicKey: string | Uint8Array): boolean;
+/** Generate cryptographically secure random bytes. Defaults to 32 bytes. */
+declare function randomBytes(length?: number): Uint8Array;
+export { writeUInt8, writeUInt32BE, writeUInt16BE, without0x, with0x, verifySignature, verifyMessageSignature, validateStacksAddress, utf8ToBytes, uncompressPublicKey, txidFromBytes, toTwos, signatureVrsToRsv, signatureRsvToVrs, sha512_256, sha256, serializeSignature, ripemd160, recoverPublicKey, recoverAddress, readUInt32BE, readUInt16BE, randomBytes, parseUnits, parseStx, parseSignature, parseContractId, isValidAddress, isCompressedPublicKey, isClarityName, isAddressEqual, intToHex, intToBytes, intToBigInt, hexToBytes, hashP2PKH, hash160, getContractAddress, fromTwos, formatUnits, formatStx, concatBytes, compressPublicKey, c32addressDecode, c32address, bytesToUtf8, bytesToTwosBigInt, bytesToHex, bytesToAscii, bigIntToBytes, asciiToBytes, addressToVersion, ZERO_ADDRESS, TESTNET_ZERO_ADDRESS, RecoverableSignature, MIN_I128, MICROSTX_PER_STX, MAX_U128, MAX_I128, IntegerType, AddressVersion };

package/dist/src/utils/index.js

@@ -0,0 +1,222 @@
+import {
+  formatStx,
+  formatUnits,
+  parseStx,
+  parseUnits
+} from "../../shared/stacks-k2p5tv6x.js";
+import {
+  AddressVersion,
+  MAX_I128,
+  MAX_U128,
+  MICROSTX_PER_STX,
+  MIN_I128,
+  TESTNET_ZERO_ADDRESS,
+  ZERO_ADDRESS
+} from "../../shared/stacks-v9jqcpd4.js";
+import {
+  hash160,
+  hashP2PKH,
+  ripemd160,
+  sha256,
+  sha512_256,
+  txidFromBytes
+} from "../../shared/stacks-bycy6t9k.js";
+import {
+  addressToVersion,
+  getContractAddress,
+  isAddressEqual,
+  isClarityName,
+  isValidAddress,
+  parseContractId,
+  validateStacksAddress
+} from "../../shared/stacks-gjvbq6w7.js";
+import {
+  asciiToBytes,
+  bigIntToBytes,
+  bytesToAscii,
+  bytesToHex,
+  bytesToTwosBigInt,
+  bytesToUtf8,
+  c32address,
+  c32addressDecode,
+  concatBytes,
+  fromTwos,
+  hexToBytes,
+  intToBigInt,
+  intToBytes,
+  intToHex,
+  readUInt16BE,
+  readUInt32BE,
+  toTwos,
+  utf8ToBytes,
+  with0x,
+  without0x,
+  writeUInt16BE,
+  writeUInt32BE,
+  writeUInt8
+} from "../../shared/stacks-nqytwfcc.js";
+import"../../shared/stacks-8m9byk2j.js";
+// src/utils/signature.ts
+import { Signature as NobleSignature, verify } from "@noble/secp256k1";
+import { sha256 as sha2562 } from "@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 = NobleSignature.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 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 sha2562(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 (verify(compactSig, msgHash, publicKey, { lowS: false }))
+    return true;
+  if (typeof message === "string") {
+    const legacyHash = hashMessage(message, LEGACY_MESSAGE_PREFIX);
+    if (verify(compactSig, legacyHash, publicKey, { lowS: false }))
+      return true;
+  }
+  return false;
+}
+// src/utils/keys.ts
+import { Point as Point2, etc } from "@noble/secp256k1";
+function compressPublicKey(publicKey) {
+  const hex = typeof publicKey === "string" ? publicKey : bytesToHex(publicKey);
+  return Point2.fromHex(hex).toHex(true);
+}
+function uncompressPublicKey(publicKey) {
+  const hex = typeof publicKey === "string" ? publicKey : bytesToHex(publicKey);
+  return Point2.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 etc.randomBytes(length ?? 32);
+}
+export {
+  writeUInt8,
+  writeUInt32BE,
+  writeUInt16BE,
+  without0x,
+  with0x,
+  verifySignature,
+  verifyMessageSignature,
+  validateStacksAddress,
+  utf8ToBytes,
+  uncompressPublicKey,
+  txidFromBytes,
+  toTwos,
+  signatureVrsToRsv,
+  signatureRsvToVrs,
+  sha512_256,
+  sha256,
+  serializeSignature,
+  ripemd160,
+  recoverPublicKey,
+  recoverAddress,
+  readUInt32BE,
+  readUInt16BE,
+  randomBytes,
+  parseUnits,
+  parseStx,
+  parseSignature,
+  parseContractId,
+  isValidAddress,
+  isCompressedPublicKey,
+  isClarityName,
+  isAddressEqual,
+  intToHex,
+  intToBytes,
+  intToBigInt,
+  hexToBytes,
+  hashP2PKH,
+  hash160,
+  getContractAddress,
+  fromTwos,
+  formatUnits,
+  formatStx,
+  concatBytes,
+  compressPublicKey,
+  c32addressDecode,
+  c32address,
+  bytesToUtf8,
+  bytesToTwosBigInt,
+  bytesToHex,
+  bytesToAscii,
+  bigIntToBytes,
+  asciiToBytes,
+  addressToVersion,
+  ZERO_ADDRESS,
+  TESTNET_ZERO_ADDRESS,
+  MIN_I128,
+  MICROSTX_PER_STX,
+  MAX_U128,
+  MAX_I128,
+  AddressVersion
+};
+
+//# debugId=5ED999593A751F3B64756E2164756E21
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,11 @@
+{
+  "version": 3,
+  "sources": ["../src/utils/signature.ts", "../src/utils/keys.ts"],
+  "sourcesContent": [
+    "import { Signature as NobleSignature, verify, Point } from \"@noble/secp256k1\";\nimport { sha256 } from \"@noble/hashes/sha2.js\";\nimport { bytesToHex, hexToBytes, concatBytes, utf8ToBytes } from \"./encoding.ts\";\nimport { hash160, hashP2PKH } from \"./hash.ts\";\nimport { c32address } from \"./address.ts\";\nimport { AddressVersion } from \"./constants.ts\";\n\nexport interface RecoverableSignature {\n  /** Recovery id (0–3) */\n  recovery: number;\n  /** 32-byte r value as hex */\n  r: string;\n  /** 32-byte s value as hex */\n  s: string;\n}\n\n// --- Format conversion ---\n\n/**\n * Parse a 65-byte VRS hex signature into components.\n * VRS format: recovery (1 byte) + r (32 bytes) + s (32 bytes)\n */\nexport function parseSignature(hex: string): RecoverableSignature {\n  const clean = hex.startsWith(\"0x\") ? hex.slice(2) : hex;\n  if (clean.length !== 130) {\n    throw new Error(`Invalid signature length: expected 130 hex chars, got ${clean.length}`);\n  }\n  return {\n    recovery: parseInt(clean.slice(0, 2), 16),\n    r: clean.slice(2, 66),\n    s: clean.slice(66, 130),\n  };\n}\n\n/**\n * Serialize a recoverable signature to 65-byte VRS hex (130 chars).\n */\nexport function serializeSignature(sig: RecoverableSignature): string {\n  const v = sig.recovery.toString(16).padStart(2, \"0\");\n  return v + sig.r + sig.s;\n}\n\n/** Convert VRS hex to RSV hex: r+s (128 chars) + recovery (2 chars). */\nexport function signatureVrsToRsv(vrs: string): string {\n  const clean = vrs.startsWith(\"0x\") ? vrs.slice(2) : vrs;\n  return clean.slice(2) + clean.slice(0, 2);\n}\n\n/** Convert RSV hex to VRS hex: recovery (2 chars) + r+s (128 chars). */\nexport function signatureRsvToVrs(rsv: string): string {\n  const clean = rsv.startsWith(\"0x\") ? rsv.slice(2) : rsv;\n  return clean.slice(-2) + clean.slice(0, -2);\n}\n\n// --- Recovery ---\n\n/**\n * Recover a public key from a message hash and VRS signature.\n * @returns hex-encoded public key (33 bytes compressed, or 65 bytes uncompressed)\n */\nexport function recoverPublicKey(\n  hash: Uint8Array | string,\n  signature: string,\n  compressed = true\n): string {\n  const parsed = parseSignature(signature);\n  const rs = parsed.r + parsed.s;\n  const sig = NobleSignature.fromCompact(rs).addRecoveryBit(parsed.recovery);\n  const msgHash = typeof hash === \"string\" ? hexToBytes(hash) : hash;\n  const point = sig.recoverPublicKey(msgHash);\n  return point.toHex(compressed);\n}\n\n/**\n * Recover a Stacks address from a message hash and VRS signature.\n * @param addressVersion defaults to MainnetSingleSig (22)\n */\nexport function recoverAddress(\n  hash: Uint8Array | string,\n  signature: string,\n  addressVersion: number = AddressVersion.MainnetSingleSig\n): string {\n  const pubkey = recoverPublicKey(hash, signature, true);\n  const pubkeyHash = hashP2PKH(hexToBytes(pubkey));\n  return c32address(addressVersion, pubkeyHash);\n}\n\n// --- Verification ---\n\n/**\n * Verify an ECDSA signature against a message hash and public key.\n * Accepts compact (64-byte) signature as hex or Uint8Array.\n */\nexport function verifySignature(\n  hash: Uint8Array | string,\n  signature: string | Uint8Array,\n  publicKey: string | Uint8Array\n): boolean {\n  return verify(signature, hash, publicKey, { lowS: false });\n}\n\n/** Bitcoin-style varint encoding for message length prefix. */\nfunction encodeVarint(n: number): Uint8Array {\n  if (n < 0xfd) return new Uint8Array([n]);\n  if (n <= 0xffff) {\n    const buf = new Uint8Array(3);\n    buf[0] = 0xfd;\n    buf[1] = n & 0xff;\n    buf[2] = (n >> 8) & 0xff;\n    return buf;\n  }\n  const buf = new Uint8Array(5);\n  buf[0] = 0xfe;\n  buf[1] = n & 0xff;\n  buf[2] = (n >> 8) & 0xff;\n  buf[3] = (n >> 16) & 0xff;\n  buf[4] = (n >> 24) & 0xff;\n  return buf;\n}\n\nconst STACKS_MESSAGE_PREFIX = \"\\x17Stacks Signed Message:\\n\";\nconst LEGACY_MESSAGE_PREFIX = \"\\x18Stacks Message Signing:\\n\";\n\n/** Hash a message with the Stacks structured message prefix. */\nfunction hashMessage(message: string | Uint8Array, prefix: string): Uint8Array {\n  const messageBytes = typeof message === \"string\" ? utf8ToBytes(message) : message;\n  const prefixBytes = utf8ToBytes(prefix);\n  const lengthBytes = encodeVarint(messageBytes.length);\n  return sha256(concatBytes(prefixBytes, lengthBytes, messageBytes));\n}\n\n/**\n * Verify a signed Stacks message.\n * Parses a VRS signature, extracts r+s for verification.\n * Falls back to legacy prefix if standard prefix fails.\n */\nexport function verifyMessageSignature(\n  message: string | Uint8Array,\n  signature: string,\n  publicKey: string\n): boolean {\n  const parsed = parseSignature(signature);\n  const compactSig = parsed.r + parsed.s;\n\n  const msgHash = hashMessage(message, STACKS_MESSAGE_PREFIX);\n  if (verify(compactSig, msgHash, publicKey, { lowS: false })) return true;\n\n  // Fallback to legacy prefix\n  if (typeof message === \"string\") {\n    const legacyHash = hashMessage(message, LEGACY_MESSAGE_PREFIX);\n    if (verify(compactSig, legacyHash, publicKey, { lowS: false })) return true;\n  }\n\n  return false;\n}\n",
+    "import { Point, etc } from \"@noble/secp256k1\";\nimport { bytesToHex, hexToBytes } from \"./encoding.ts\";\n\n/** Compress a public key to 33 bytes (hex). */\nexport function compressPublicKey(publicKey: string | Uint8Array): string {\n  const hex = typeof publicKey === \"string\" ? publicKey : bytesToHex(publicKey);\n  return Point.fromHex(hex).toHex(true);\n}\n\n/** Uncompress a public key to 65 bytes (hex). */\nexport function uncompressPublicKey(publicKey: string | Uint8Array): string {\n  const hex = typeof publicKey === \"string\" ? publicKey : bytesToHex(publicKey);\n  return Point.fromHex(hex).toHex(false);\n}\n\n/** Check if a public key is in compressed format (starts with 0x02 or 0x03). */\nexport function isCompressedPublicKey(publicKey: string | Uint8Array): boolean {\n  const bytes = typeof publicKey === \"string\" ? hexToBytes(publicKey) : publicKey;\n  return bytes.length === 33 && (bytes[0] === 0x02 || bytes[0] === 0x03);\n}\n\n/** Generate cryptographically secure random bytes. Defaults to 32 bytes. */\nexport function randomBytes(length?: number): Uint8Array {\n  return etc.randomBytes(length ?? 32);\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "5ED999593A751F3B64756E2164756E21",
+  "names": []
+}

package/package.json

@@ -0,0 +1,105 @@
+{
+  "name": "@secondlayer/stacks",
+  "version": "0.0.1",
+  "description": "A viem-style SDK for the Stacks blockchain",
+  "type": "module",
+  "main": "./dist/src/index.cjs",
+  "module": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js",
+      "require": "./dist/src/index.cjs"
+    },
+    "./accounts": {
+      "types": "./dist/src/accounts/index.d.ts",
+      "import": "./dist/src/accounts/index.js",
+      "require": "./dist/src/accounts/index.cjs"
+    },
+    "./chains": {
+      "types": "./dist/src/chains/index.d.ts",
+      "import": "./dist/src/chains/index.js",
+      "require": "./dist/src/chains/index.cjs"
+    },
+    "./clarity": {
+      "types": "./dist/src/clarity/index.d.ts",
+      "import": "./dist/src/clarity/index.js",
+      "require": "./dist/src/clarity/index.cjs"
+    },
+    "./actions": {
+      "types": "./dist/src/actions/index.d.ts",
+      "import": "./dist/src/actions/index.js",
+      "require": "./dist/src/actions/index.cjs"
+    },
+    "./postconditions": {
+      "types": "./dist/src/postconditions/index.d.ts",
+      "import": "./dist/src/postconditions/index.js",
+      "require": "./dist/src/postconditions/index.cjs"
+    },
+    "./transactions": {
+      "types": "./dist/src/transactions/index.d.ts",
+      "import": "./dist/src/transactions/index.js",
+      "require": "./dist/src/transactions/index.cjs"
+    },
+    "./utils": {
+      "types": "./dist/src/utils/index.d.ts",
+      "import": "./dist/src/utils/index.js",
+      "require": "./dist/src/utils/index.cjs"
+    },
+    "./connect": {
+      "types": "./dist/src/connect/index.d.ts",
+      "import": "./dist/src/connect/index.js",
+      "require": "./dist/src/connect/index.cjs"
+    },
+    "./bns": {
+      "types": "./dist/src/bns/index.d.ts",
+      "import": "./dist/src/bns/index.js",
+      "require": "./dist/src/bns/index.cjs"
+    },
+    "./pox": {
+      "types": "./dist/src/pox/index.d.ts",
+      "import": "./dist/src/pox/index.js",
+      "require": "./dist/src/pox/index.cjs"
+    },
+    "./stackingdao": {
+      "types": "./dist/src/stackingdao/index.d.ts",
+      "import": "./dist/src/stackingdao/index.js",
+      "require": "./dist/src/stackingdao/index.cjs"
+    },
+    "./subscriptions": {
+      "types": "./dist/src/subscriptions/index.d.ts",
+      "import": "./dist/src/subscriptions/index.js",
+      "require": "./dist/src/subscriptions/index.cjs"
+    },
+    "./connect/walletconnect": {
+      "types": "./dist/src/connect/walletconnect/index.d.ts",
+      "import": "./dist/src/connect/walletconnect/index.js",
+      "require": "./dist/src/connect/walletconnect/index.cjs"
+    }
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build": "bunup",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "bun run build"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@noble/hashes": "2.0.1",
+    "@noble/secp256k1": "2.3.0",
+    "@scure/bip32": "2.0.1",
+    "@noble/ciphers": "2.1.1",
+    "@noble/curves": "2.0.1",
+    "@scure/bip39": "2.0.1"
+  }
+}