@secondlayer/stacks 5.1.3 → 6.1.0

package/dist/src/bitcoin/index.cjs

@@ -1,3 +1,2021 @@
+var import_node_module = require("node:module");
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/clarity/index.ts
+var exports_clarity = {};
+__export(exports_clarity, {
+  validateArgsArray: () => validateArgsArray,
+  validateArgs: () => validateArgs,
+  uintCV: () => uintCV,
+  tupleCV: () => tupleCV,
+  trueCV: () => trueCV,
+  toCamelCase: () => toCamelCase,
+  structuredDataHash: () => structuredDataHash,
+  stringUtf8CV: () => stringUtf8CV,
+  stringAsciiCV: () => stringAsciiCV,
+  standardPrincipalCV: () => standardPrincipalCV,
+  someCV: () => someCV,
+  sip013Abi: () => sip013Abi,
+  sip010Abi: () => sip010Abi,
+  sip009Abi: () => sip009Abi,
+  signStructuredData: () => signStructuredData,
+  serializeCVBytes: () => serializeCVBytes,
+  serializeCV: () => serializeCV,
+  responseOkCV: () => responseOkCV,
+  responseErrorCV: () => responseErrorCV,
+  prettyPrint: () => prettyPrint,
+  prepareArgs: () => prepareArgs,
+  parseDeclaredStandards: () => parseDeclaredStandards,
+  normalizeType: () => normalizeType,
+  normalizeAccess: () => normalizeAccess,
+  normalizeAbi: () => normalizeAbi,
+  noneCV: () => noneCV,
+  listCV: () => listCV,
+  jsToClarityValue: () => jsToClarityValue,
+  jsToClarity: () => jsToClarity,
+  isUint8Array: () => isUint8Array,
+  isUint128: () => isUint128,
+  isTraitReference: () => isTraitReference,
+  isString: () => isString,
+  isStandardPrincipal: () => isStandardPrincipal,
+  isResponse: () => isResponse,
+  isPrincipal: () => isPrincipal,
+  isOptional: () => isOptional,
+  isOkResponse: () => isOkResponse,
+  isInt128: () => isInt128,
+  isErrResponse: () => isErrResponse,
+  isContractPrincipal: () => isContractPrincipal,
+  isClarityValue: () => isClarityValue,
+  isBool: () => isBool,
+  isArray: () => isArray,
+  isAbiTuple: () => isAbiTuple,
+  isAbiTraitReference: () => isAbiTraitReference,
+  isAbiStringUtf8: () => isAbiStringUtf8,
+  isAbiStringAscii: () => isAbiStringAscii,
+  isAbiResponse: () => isAbiResponse,
+  isAbiOptional: () => isAbiOptional,
+  isAbiList: () => isAbiList,
+  isAbiBuffer: () => isAbiBuffer,
+  intCV: () => intCV,
+  hashStructuredData: () => hashStructuredData,
+  falseCV: () => falseCV,
+  encodeStructuredData: () => encodeStructuredData,
+  deserializeCVBytes: () => deserializeCVBytes,
+  deserializeCV: () => deserializeCV,
+  cvToValue: () => cvToValue,
+  cvToString: () => cvToString,
+  cvToPrincipal: () => cvToPrincipal,
+  cvToJSON: () => cvToJSON,
+  cvToBuffer: () => cvToBuffer,
+  cvToBoolean: () => cvToBoolean,
+  cvToBigInt: () => cvToBigInt,
+  contractPrincipalCV: () => contractPrincipalCV,
+  classifyContract: () => classifyContract,
+  clarityValueToJSUntyped: () => clarityValueToJSUntyped,
+  clarityValueToJS: () => clarityValueToJS,
+  clarityTypeFromByte: () => clarityTypeFromByte,
+  bufferCV: () => bufferCV,
+  boolCV: () => boolCV,
+  TRAIT_STANDARDS: () => TRAIT_STANDARDS,
+  SIP018_PREFIX: () => SIP018_PREFIX,
+  SIP013_ABI: () => SIP013_ABI,
+  SIP010_ABI: () => SIP010_ABI,
+  SIP009_ABI: () => SIP009_ABI,
+  ClarityWireType: () => ClarityWireType,
+  ClarityConversionError: () => ClarityConversionError,
+  Cl: () => Cl,
+  CONTRACT_NAME_REGEX: () => CONTRACT_NAME_REGEX
+});
+module.exports = __toCommonJS(exports_clarity);
+
+// src/clarity/types.ts
+var ClarityWireType = {
+  int: 0,
+  uint: 1,
+  buffer: 2,
+  true: 3,
+  false: 4,
+  address: 5,
+  contract: 6,
+  ok: 7,
+  err: 8,
+  none: 9,
+  some: 10,
+  list: 11,
+  tuple: 12,
+  ascii: 13,
+  utf8: 14
+};
+var wireTypeToClarity = Object.fromEntries(Object.entries(ClarityWireType).map(([k, v]) => [v, k]));
+function clarityTypeFromByte(byte) {
+  const type = wireTypeToClarity[byte];
+  if (!type)
+    throw new Error(`Unknown clarity wire type: ${byte}`);
+  return type;
+}
+// src/utils/c32.ts
+var import_sha2 = require("@noble/hashes/sha2.js");
+
+// src/utils/encoding.ts
+var hexes = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+function bytesToHex(bytes) {
+  let hex = "";
+  for (const b of bytes) {
+    hex += hexes[b];
+  }
+  return hex;
+}
+function hexToBytes(hex) {
+  let h = without0x(hex);
+  if (h.length % 2)
+    h = `0${h}`;
+  const array = new Uint8Array(h.length / 2);
+  for (let i = 0;i < array.length; i++) {
+    const j = i * 2;
+    const byte = Number.parseInt(h.slice(j, j + 2), 16);
+    if (Number.isNaN(byte) || byte < 0)
+      throw new Error("Invalid byte sequence");
+    array[i] = byte;
+  }
+  return array;
+}
+function with0x(value) {
+  return /^0x/i.test(value) ? value : `0x${value}`;
+}
+function without0x(value) {
+  return /^0x/i.test(value) ? value.slice(2) : value;
+}
+function utf8ToBytes(str) {
+  return new TextEncoder().encode(str);
+}
+function bytesToUtf8(bytes) {
+  return new TextDecoder().decode(bytes);
+}
+function asciiToBytes(str) {
+  const bytes = new Uint8Array(str.length);
+  for (let i = 0;i < str.length; i++) {
+    bytes[i] = str.charCodeAt(i) & 255;
+  }
+  return bytes;
+}
+function bytesToAscii(bytes) {
+  return String.fromCharCode(...bytes);
+}
+function concatBytes(...arrays) {
+  if (arrays.length === 1)
+    return arrays[0];
+  const length = arrays.reduce((a, arr) => a + arr.length, 0);
+  const result = new Uint8Array(length);
+  let pad = 0;
+  for (const arr of arrays) {
+    result.set(arr, pad);
+    pad += arr.length;
+  }
+  return result;
+}
+function intToBigInt(value) {
+  if (typeof value === "bigint")
+    return value;
+  if (typeof value === "string")
+    return BigInt(value);
+  if (typeof value === "number") {
+    if (!Number.isInteger(value))
+      throw new RangeError("Values of type 'number' must be an integer.");
+    if (value > Number.MAX_SAFE_INTEGER)
+      throw new RangeError(`Values of type 'number' must be <= ${Number.MAX_SAFE_INTEGER}. Use BigInt instead.`);
+    return BigInt(value);
+  }
+  if (value instanceof Uint8Array)
+    return BigInt(`0x${bytesToHex(value)}`);
+  throw new TypeError("Must be a number, bigint, string, or Uint8Array.");
+}
+function intToBytes(value, byteLength) {
+  return bigIntToBytes(intToBigInt(value), byteLength);
+}
+function bigIntToBytes(value, length = 16) {
+  const hex = value.toString(16).padStart(length * 2, "0");
+  return hexToBytes(hex);
+}
+function intToHex(integer, byteLength = 8) {
+  const value = typeof integer === "bigint" ? integer : intToBigInt(integer);
+  return value.toString(16).padStart(byteLength * 2, "0");
+}
+function toTwos(value, width) {
+  const limit = BigInt(1) << width - BigInt(1);
+  if (value < -limit || value > limit - BigInt(1)) {
+    throw new Error(`Unable to represent integer in width: ${width}`);
+  }
+  if (value >= BigInt(0))
+    return value;
+  return value + (BigInt(1) << width);
+}
+function fromTwos(value, width) {
+  if (value & BigInt(1) << width - BigInt(1)) {
+    return value - (BigInt(1) << width);
+  }
+  return value;
+}
+function bytesToTwosBigInt(bytes) {
+  if (bytes.length === 0)
+    return 0n;
+  const hex = bytesToHex(bytes);
+  if (hex.length === 0)
+    return 0n;
+  return fromTwos(BigInt(`0x${hex}`), BigInt(bytes.byteLength * 8));
+}
+function writeUInt32BE(value) {
+  const buf = new Uint8Array(4);
+  buf[0] = value >>> 24 & 255;
+  buf[1] = value >>> 16 & 255;
+  buf[2] = value >>> 8 & 255;
+  buf[3] = value & 255;
+  return buf;
+}
+function readUInt32BE(bytes, offset = 0) {
+  return (bytes[offset] << 24 | bytes[offset + 1] << 16 | bytes[offset + 2] << 8 | bytes[offset + 3]) >>> 0;
+}
+function writeUInt16BE(value) {
+  const buf = new Uint8Array(2);
+  buf[0] = value >>> 8 & 255;
+  buf[1] = value & 255;
+  return buf;
+}
+function readUInt16BE(bytes, offset = 0) {
+  return (bytes[offset] << 8 | bytes[offset + 1]) >>> 0;
+}
+function writeUInt8(value) {
+  return new Uint8Array([value & 255]);
+}
+
+// src/utils/c32.ts
+var C32 = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+var HEX = "0123456789abcdef";
+function c32normalize(input) {
+  return input.toUpperCase().replace(/O/g, "0").replace(/L|I/g, "1");
+}
+function c32encode(inputHex) {
+  let hex = inputHex;
+  if (hex.length % 2 !== 0)
+    hex = `0${hex}`;
+  hex = hex.toLowerCase();
+  const res = [];
+  let carry = 0;
+  for (let i = hex.length - 1;i >= 0; i--) {
+    if (carry < 4) {
+      const currentCode = HEX.indexOf(hex[i]) >> carry;
+      const nextCode = i !== 0 ? HEX.indexOf(hex[i - 1]) : 0;
+      const nextBits = 1 + carry;
+      const nextLowBits = nextCode % (1 << nextBits) << 5 - nextBits;
+      res.unshift(C32[currentCode + nextLowBits]);
+      carry = nextBits;
+    } else {
+      carry = 0;
+    }
+  }
+  let leadingZeros = 0;
+  while (leadingZeros < res.length && res[leadingZeros] === "0")
+    leadingZeros++;
+  const stripped = res.slice(leadingZeros);
+  const bytes = hexToBytes(hex);
+  let zeroBytesCount = 0;
+  while (zeroBytesCount < bytes.length && bytes[zeroBytesCount] === 0)
+    zeroBytesCount++;
+  const prefix = Array(zeroBytesCount).fill(C32[0]);
+  return [...prefix, ...stripped].join("");
+}
+function c32decode(c32input) {
+  const input = c32normalize(c32input);
+  if (!input.match(`^[${C32}]*$`))
+    throw new Error("Not a c32-encoded string");
+  const zeroPrefix = input.match(`^${C32[0]}*`);
+  const numLeadingZeroBytes = zeroPrefix ? zeroPrefix[0]?.length : 0;
+  const res = [];
+  let carry = 0;
+  let carryBits = 0;
+  for (let i = input.length - 1;i >= 0; i--) {
+    if (carryBits === 4) {
+      res.unshift(HEX[carry]);
+      carryBits = 0;
+      carry = 0;
+    }
+    const currentValue = (C32.indexOf(input[i]) << carryBits) + carry;
+    res.unshift(HEX[currentValue % 16]);
+    carryBits += 1;
+    carry = currentValue >> 4;
+    if (carry > 1 << carryBits)
+      throw new Error("Panic error in c32 decoding");
+  }
+  res.unshift(HEX[carry]);
+  if (res.length % 2 === 1)
+    res.unshift("0");
+  let hexLeadingZeros = 0;
+  while (hexLeadingZeros < res.length && res[hexLeadingZeros] === "0")
+    hexLeadingZeros++;
+  let hexStr = res.slice(hexLeadingZeros - hexLeadingZeros % 2).join("");
+  for (let i = 0;i < numLeadingZeroBytes; i++)
+    hexStr = `00${hexStr}`;
+  return hexStr;
+}
+function c32checksum(dataHex) {
+  return bytesToHex(import_sha2.sha256(import_sha2.sha256(hexToBytes(dataHex))).slice(0, 4));
+}
+function c32checkEncode(version, data) {
+  if (version < 0 || version >= 32)
+    throw new Error("Invalid version (must be between 0 and 31)");
+  if (!data.match(/^[0-9a-fA-F]*$/))
+    throw new Error("Invalid data (not a hex string)");
+  let d = data.toLowerCase();
+  if (d.length % 2 !== 0)
+    d = `0${d}`;
+  let versionHex = version.toString(16);
+  if (versionHex.length === 1)
+    versionHex = `0${versionHex}`;
+  const checksumHex = c32checksum(`${versionHex}${d}`);
+  return `${C32[version]}${c32encode(`${d}${checksumHex}`)}`;
+}
+function c32checkDecode(c32data) {
+  const normalized = c32normalize(c32data);
+  const dataHex = c32decode(normalized.slice(1));
+  const version = C32.indexOf(normalized[0]);
+  const checksum = dataHex.slice(-8);
+  let versionHex = version.toString(16);
+  if (versionHex.length === 1)
+    versionHex = `0${versionHex}`;
+  if (c32checksum(`${versionHex}${dataHex.substring(0, dataHex.length - 8)}`) !== checksum) {
+    throw new Error("Invalid c32check string: checksum mismatch");
+  }
+  return [version, dataHex.substring(0, dataHex.length - 8)];
+}
+function c32address(version, hash160hex) {
+  if (!hash160hex.match(/^[0-9a-fA-F]{40}$/)) {
+    throw new Error("Invalid argument: not a hash160 hex string");
+  }
+  return `S${c32checkEncode(version, hash160hex)}`;
+}
+function c32addressDecode(c32addr) {
+  if (c32addr.length <= 5)
+    throw new Error("Invalid c32 address: invalid length");
+  if (c32addr[0] !== "S")
+    throw new Error('Invalid c32 address: must start with "S"');
+  return c32checkDecode(c32addr.slice(1));
+}
+
+// src/utils/constants.ts
+var MAX_U128 = (1n << 128n) - 1n;
+var MAX_I128 = (1n << 127n) - 1n;
+var MIN_I128 = -(1n << 127n);
+var AddressVersion = {
+  MainnetSingleSig: 22,
+  MainnetMultiSig: 20,
+  TestnetSingleSig: 26,
+  TestnetMultiSig: 21
+};
+var ZERO_ADDRESS = "SP000000000000000000002Q6VF78";
+var TESTNET_ZERO_ADDRESS = "ST000000000000000000002AMW42H";
+var MICROSTX_PER_STX = 1000000n;
+
+// src/utils/hash.ts
+var import_legacy = require("@noble/hashes/legacy.js");
+var import_sha22 = require("@noble/hashes/sha2.js");
+var import_sha23 = require("@noble/hashes/sha2.js");
+function hash160(input) {
+  return import_legacy.ripemd160(import_sha22.sha256(input));
+}
+function txidFromBytes(data) {
+  return bytesToHex(import_sha23.sha512_256(data));
+}
+function hashP2PKH(input) {
+  return bytesToHex(hash160(input));
+}
+
+// src/utils/address.ts
+function publicKeyToAddress(publicKey, network = "mainnet") {
+  const bytes = typeof publicKey === "string" ? hexToBytes(without0x(publicKey)) : publicKey;
+  const version = network === "mainnet" ? AddressVersion.MainnetSingleSig : AddressVersion.TestnetSingleSig;
+  return c32address(version, bytesToHex(hash160(bytes)));
+}
+var CONTRACT_NAME_REGEX = /^[a-zA-Z][a-zA-Z0-9_-]{0,127}$/;
+function validateStacksAddress(address) {
+  try {
+    c32addressDecode(address);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var isValidAddress = validateStacksAddress;
+function parsePrincipal(value) {
+  const parts = value.split(".");
+  if (parts.length > 2)
+    return null;
+  const [address, contractName] = parts;
+  if (!validateStacksAddress(address))
+    return null;
+  if (contractName === undefined)
+    return { address };
+  if (!CONTRACT_NAME_REGEX.test(contractName))
+    return null;
+  return { address, contractName };
+}
+function parseContractId(contractId) {
+  const parsed = parsePrincipal(contractId);
+  if (!parsed?.contractName)
+    throw new Error(`Invalid contract identifier: ${contractId}`);
+  return [parsed.address, parsed.contractName];
+}
+function isClarityName(name) {
+  const regex = /^[a-zA-Z]([a-zA-Z0-9]|[-_!?+<>=/*])*$|^[-+=/*]$|^[<>]=?$/;
+  return regex.test(name) && name.length < 128;
+}
+function isAddressEqual(a, b) {
+  const [versionA, hashA] = c32addressDecode(a);
+  const [versionB, hashB] = c32addressDecode(b);
+  return versionA === versionB && hashA.toLowerCase() === hashB.toLowerCase();
+}
+function addressToVersion(address) {
+  return c32addressDecode(address)[0];
+}
+function getContractAddress(deployer, contractName) {
+  if (!validateStacksAddress(deployer)) {
+    throw new Error(`Invalid deployer address: ${deployer}`);
+  }
+  if (!isClarityName(contractName)) {
+    throw new Error(`Invalid contract name: ${contractName}`);
+  }
+  return `${deployer}.${contractName}`;
+}
+
+// src/errors/base.ts
+function codeFromName(name) {
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").toUpperCase();
+}
+
+class BaseError extends Error {
+  name = "StacksError";
+  #code;
+  shortMessage;
+  details;
+  constructor(shortMessage, options) {
+    const message = [
+      shortMessage,
+      options?.details ? `
+${options.details}` : ""
+    ].join("");
+    super(message, { cause: options?.cause });
+    if (options?.code !== undefined)
+      this.#code = options.code;
+    this.shortMessage = shortMessage;
+    this.details = options?.details;
+  }
+  get code() {
+    return this.#code ?? codeFromName(this.name);
+  }
+  set code(value) {
+    this.#code = value;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      shortMessage: this.shortMessage,
+      details: this.details,
+      cause: this.cause instanceof Error ? this.cause.message : undefined
+    };
+  }
+}
+
+// src/errors/transaction.ts
+class TransactionError extends BaseError {
+  name = "TransactionError";
+}
+
+class BroadcastError extends BaseError {
+  name = "BroadcastError";
+  txid;
+  reason;
+  reasonData;
+  constructor(message, options) {
+    super(message, options);
+    this.txid = options?.txid;
+    this.reason = options?.reason;
+    this.reasonData = options?.reasonData;
+  }
+}
+
+class TransactionAbortedError extends BaseError {
+  name = "TransactionAbortedError";
+  receipt;
+  constructor(message, options) {
+    super(message, options);
+    this.receipt = options.receipt;
+  }
+}
+
+class TransactionDroppedError extends BaseError {
+  name = "TransactionDroppedError";
+  txid;
+  constructor(message, options) {
+    super(message, options);
+    this.txid = options.txid;
+  }
+}
+
+class WaitForTransactionTimeoutError extends BaseError {
+  name = "WaitForTransactionTimeoutError";
+  txid;
+  constructor(message, options) {
+    super(message, options);
+    this.txid = options.txid;
+  }
+}
+
+class SerializationError extends BaseError {
+  name = "SerializationError";
+}
+
+class SigningError extends BaseError {
+  name = "SigningError";
+}
+
+// src/utils/bytes-reader.ts
+class BytesReader {
+  data;
+  offset = 0;
+  constructor(data) {
+    this.data = data;
+  }
+  remaining() {
+    return this.data.length - this.offset;
+  }
+  ensure(length) {
+    if (this.offset + length > this.data.length) {
+      throw new SerializationError(`Buffer underflow: need ${length} bytes at offset ${this.offset}, have ${this.data.length}`);
+    }
+  }
+  readUInt8() {
+    this.ensure(1);
+    return this.data[this.offset++];
+  }
+  readUInt16BE() {
+    this.ensure(2);
+    const val = (this.data[this.offset] << 8 | this.data[this.offset + 1]) >>> 0;
+    this.offset += 2;
+    return val;
+  }
+  readUInt32BE() {
+    this.ensure(4);
+    const val = (this.data[this.offset] << 24 | this.data[this.offset + 1] << 16 | this.data[this.offset + 2] << 8 | this.data[this.offset + 3]) >>> 0;
+    this.offset += 4;
+    return val;
+  }
+  readBytes(length) {
+    this.ensure(length);
+    const slice = this.data.slice(this.offset, this.offset + length);
+    this.offset += length;
+    return slice;
+  }
+  readBigUInt64BE() {
+    const hex = bytesToHex(this.readBytes(8));
+    return hex.length > 0 ? BigInt(`0x${hex}`) : 0n;
+  }
+}
+
+// src/clarity/deserialize.ts
+function readAddress(reader) {
+  const version = reader.readUInt8();
+  const hash1602 = bytesToHex(reader.readBytes(20));
+  return c32address(version, hash1602);
+}
+function readLPString(reader, prefixBytes = 1) {
+  let length = 0;
+  for (let i = 0;i < prefixBytes; i++) {
+    length = length << 8 | reader.readUInt8();
+  }
+  return bytesToUtf8(reader.readBytes(length));
+}
+var MAX_CV_DEPTH = 64;
+var MIN_LIST_ITEM_BYTES = 1;
+var MIN_TUPLE_ENTRY_BYTES = 2;
+function checkCount(reader, count, minBytes) {
+  if (count * minBytes > reader.remaining()) {
+    throw new SerializationError(`Clarity value declares ${count} elements but only ${reader.remaining()} bytes remain`);
+  }
+}
+function readCV(reader, depth = 0) {
+  if (depth > MAX_CV_DEPTH) {
+    throw new SerializationError(`Clarity value nests deeper than ${MAX_CV_DEPTH} levels`);
+  }
+  const typeByte = reader.readUInt8();
+  const type = clarityTypeFromByte(typeByte);
+  switch (type) {
+    case "int":
+      return intCV(bytesToTwosBigInt(reader.readBytes(16)));
+    case "uint":
+      return uintCV(reader.readBytes(16));
+    case "true":
+      return trueCV();
+    case "false":
+      return falseCV();
+    case "buffer": {
+      const len = reader.readUInt32BE();
+      return bufferCV(reader.readBytes(len));
+    }
+    case "none":
+      return noneCV();
+    case "some":
+      return someCV(readCV(reader, depth + 1));
+    case "ok":
+      return responseOkCV(readCV(reader, depth + 1));
+    case "err":
+      return responseErrorCV(readCV(reader, depth + 1));
+    case "address":
+      return standardPrincipalCV(readAddress(reader));
+    case "contract": {
+      const addr = readAddress(reader);
+      const name = readLPString(reader);
+      return contractPrincipalCV(addr, name);
+    }
+    case "list": {
+      const len = reader.readUInt32BE();
+      checkCount(reader, len, MIN_LIST_ITEM_BYTES);
+      const items = [];
+      for (let i = 0;i < len; i++) {
+        items.push(readCV(reader, depth + 1));
+      }
+      return listCV(items);
+    }
+    case "tuple": {
+      const len = reader.readUInt32BE();
+      checkCount(reader, len, MIN_TUPLE_ENTRY_BYTES);
+      const data = {};
+      for (let i = 0;i < len; i++) {
+        const key = readLPString(reader);
+        data[key] = readCV(reader, depth + 1);
+      }
+      return tupleCV(data);
+    }
+    case "ascii": {
+      const len = reader.readUInt32BE();
+      return stringAsciiCV(bytesToAscii(reader.readBytes(len)));
+    }
+    case "utf8": {
+      const len = reader.readUInt32BE();
+      return stringUtf8CV(bytesToUtf8(reader.readBytes(len)));
+    }
+    default:
+      throw new SerializationError(`Cannot deserialize unknown clarity type: ${type}`);
+  }
+}
+function deserializeCVBytes(input) {
+  const bytes = typeof input === "string" ? hexToBytes(without0x(input)) : input;
+  return readCV(new BytesReader(bytes));
+}
+function deserializeCV(input) {
+  return deserializeCVBytes(input);
+}
+
+// src/clarity/serialize.ts
+var CLARITY_INT_SIZE = 128n;
+var CLARITY_INT_BYTE_SIZE = 16;
+function typeIdByte(type) {
+  return ClarityWireType[type];
+}
+function withTypeId(type, bytes) {
+  return concatBytes(new Uint8Array([typeIdByte(type)]), bytes);
+}
+function serializeAddress(c32Address) {
+  const [version, hash1602] = c32addressDecode(c32Address);
+  return concatBytes(new Uint8Array([version]), hexToBytes(hash1602));
+}
+function serializeLPString(str, prefixBytes = 1) {
+  const content = utf8ToBytes(str);
+  const lengthPrefix = hexToBytes(intToHex(content.byteLength, prefixBytes));
+  return concatBytes(lengthPrefix, content);
+}
+function serializeCVBytes(value) {
+  switch (value.type) {
+    case "true":
+    case "false":
+      return new Uint8Array([typeIdByte(value.type)]);
+    case "int": {
+      const bytes = bigIntToBytes(toTwos(BigInt(value.value), CLARITY_INT_SIZE), CLARITY_INT_BYTE_SIZE);
+      return withTypeId(value.type, bytes);
+    }
+    case "uint": {
+      const bytes = bigIntToBytes(BigInt(value.value), CLARITY_INT_BYTE_SIZE);
+      return withTypeId(value.type, bytes);
+    }
+    case "buffer": {
+      const bufBytes = hexToBytes(value.value);
+      return withTypeId(value.type, concatBytes(writeUInt32BE(bufBytes.length), bufBytes));
+    }
+    case "none":
+      return new Uint8Array([typeIdByte(value.type)]);
+    case "some":
+      return withTypeId(value.type, serializeCVBytes(value.value));
+    case "ok":
+    case "err":
+      return withTypeId(value.type, serializeCVBytes(value.value));
+    case "address":
+      return withTypeId(value.type, serializeAddress(value.value));
+    case "contract": {
+      const [addr, name] = value.value.split(".");
+      if (!addr || !name)
+        throw new Error(`Invalid contract principal: ${value.value}`);
+      return withTypeId(value.type, concatBytes(serializeAddress(addr), serializeLPString(name)));
+    }
+    case "list": {
+      const parts = [writeUInt32BE(value.value.length)];
+      for (const item of value.value) {
+        parts.push(serializeCVBytes(item));
+      }
+      return withTypeId(value.type, concatBytes(...parts));
+    }
+    case "tuple": {
+      const keys = Object.keys(value.value).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+      const parts = [writeUInt32BE(keys.length)];
+      for (const key of keys) {
+        parts.push(serializeLPString(key));
+        parts.push(serializeCVBytes(value.value[key]));
+      }
+      return withTypeId(value.type, concatBytes(...parts));
+    }
+    case "ascii": {
+      const strBytes = asciiToBytes(value.value);
+      return withTypeId(value.type, concatBytes(writeUInt32BE(strBytes.length), strBytes));
+    }
+    case "utf8": {
+      const strBytes = utf8ToBytes(value.value);
+      return withTypeId(value.type, concatBytes(writeUInt32BE(strBytes.length), strBytes));
+    }
+    default:
+      throw new Error("Cannot serialize unknown clarity type");
+  }
+}
+function serializeCV(value) {
+  return bytesToHex(serializeCVBytes(value));
+}
+
+// src/clarity/values.ts
+var MAX_U1282 = BigInt("0xffffffffffffffffffffffffffffffff");
+var MIN_I1282 = BigInt("-170141183460469231731687303715884105728");
+var MAX_I1282 = BigInt("0x7fffffffffffffffffffffffffffffff");
+function intCV(value) {
+  let v = value;
+  if (typeof v === "string" && v.toLowerCase().startsWith("0x")) {
+    v = bytesToTwosBigInt(hexToBytes(v));
+  }
+  if (v instanceof Uint8Array)
+    v = bytesToTwosBigInt(v);
+  const n = intToBigInt(v);
+  if (n > MAX_I1282)
+    throw new RangeError(`Int exceeds max i128: ${MAX_I1282}`);
+  if (n < MIN_I1282)
+    throw new RangeError(`Int below min i128: ${MIN_I1282}`);
+  return { type: "int", value: n };
+}
+function uintCV(value) {
+  const n = intToBigInt(value);
+  if (n < 0n)
+    throw new RangeError("Cannot construct unsigned int from negative value");
+  if (n > MAX_U1282)
+    throw new RangeError(`UInt exceeds max u128: ${MAX_U1282}`);
+  return { type: "uint", value: n };
+}
+var trueCV = () => ({ type: "true" });
+var falseCV = () => ({ type: "false" });
+var boolCV = (v) => v ? trueCV() : falseCV();
+function bufferCV(buffer) {
+  if (buffer.byteLength > 1048576) {
+    throw new Error("Buffer exceeds max size of 1MB");
+  }
+  return { type: "buffer", value: bytesToHex(buffer) };
+}
+function standardPrincipalCV(address) {
+  const [version, hash1602] = c32addressDecode(address);
+  const normalized = c32address(version, hash1602);
+  return { type: "address", value: normalized };
+}
+function contractPrincipalCV(address, contractName) {
+  const [version, hash1602] = c32addressDecode(address);
+  const normalized = c32address(version, hash1602);
+  if (utf8ToBytes(contractName).byteLength >= 128) {
+    throw new Error("Contract name must be less than 128 bytes");
+  }
+  return { type: "contract", value: `${normalized}.${contractName}` };
+}
+function noneCV() {
+  return { type: "none" };
+}
+function someCV(value) {
+  return { type: "some", value };
+}
+function responseOkCV(value) {
+  return { type: "ok", value };
+}
+function responseErrorCV(value) {
+  return { type: "err", value };
+}
+function listCV(values) {
+  return { type: "list", value: values };
+}
+function tupleCV(data) {
+  for (const key in data) {
+    if (!isClarityName(key)) {
+      throw new Error(`"${key}" is not a valid Clarity name`);
+    }
+  }
+  return { type: "tuple", value: data };
+}
+function stringAsciiCV(value) {
+  return { type: "ascii", value };
+}
+function stringUtf8CV(value) {
+  return { type: "utf8", value };
+}
+var Cl = {
+  int: intCV,
+  uint: uintCV,
+  bool: boolCV,
+  principal(address) {
+    const parsed = parsePrincipal(address);
+    if (!parsed)
+      throw new Error(`Invalid principal: ${address}`);
+    return parsed.contractName ? contractPrincipalCV(parsed.address, parsed.contractName) : standardPrincipalCV(parsed.address);
+  },
+  address(address) {
+    return Cl.principal(address);
+  },
+  contractPrincipal: contractPrincipalCV,
+  standardPrincipal: standardPrincipalCV,
+  buffer: bufferCV,
+  bufferFromHex: (hex) => bufferCV(hexToBytes(hex)),
+  bufferFromAscii: (ascii) => bufferCV(asciiToBytes(ascii)),
+  bufferFromUtf8: (utf8) => bufferCV(utf8ToBytes(utf8)),
+  none: noneCV,
+  some: someCV,
+  ok: responseOkCV,
+  error: responseErrorCV,
+  list: listCV,
+  tuple: tupleCV,
+  stringAscii: stringAsciiCV,
+  stringUtf8: stringUtf8CV,
+  serialize(value) {
+    return bytesToHex(serializeCVBytes(value));
+  },
+  deserialize: deserializeCVBytes
+};
+// src/clarity/structuredData.ts
+var import_sha24 = require("@noble/hashes/sha2.js");
+var SIP018_PREFIX = new Uint8Array([
+  83,
+  73,
+  80,
+  48,
+  49,
+  56
+]);
+function hashStructuredData(structuredData) {
+  return import_sha24.sha256(serializeCVBytes(structuredData));
+}
+function isDomain(value) {
+  if (value.type !== "tuple")
+    return false;
+  const { name, version, "chain-id": chainId } = value.value;
+  return name?.type === "ascii" && version?.type === "ascii" && chainId?.type === "uint";
+}
+function encodeStructuredData(opts) {
+  if (!isDomain(opts.domain)) {
+    throw new Error("domain must be a tuple { name: ascii, version: ascii, chain-id: uint }");
+  }
+  return concatBytes(SIP018_PREFIX, hashStructuredData(opts.domain), hashStructuredData(opts.message));
+}
+function structuredDataHash(opts) {
+  return import_sha24.sha256(encodeStructuredData(opts));
+}
+async function signStructuredData(account, opts) {
+  const vrs = await account.sign(structuredDataHash(opts));
+  if (vrs.length !== 65) {
+    throw new Error(`Expected 65-byte recoverable signature, got ${vrs.length}`);
+  }
+  return bytesToHex(concatBytes(vrs.slice(1), vrs.slice(0, 1)));
+}
+// src/clarity/prettyPrint.ts
+function prettyPrint(val, encoding = "hex") {
+  switch (val.type) {
+    case "true":
+      return "true";
+    case "false":
+      return "false";
+    case "int":
+      return val.value.toString();
+    case "uint":
+      return `u${val.value.toString()}`;
+    case "buffer":
+      if (encoding === "tryAscii") {
+        const str = bytesToAscii(hexToBytes(val.value));
+        if (/^[ -~]*$/.test(str))
+          return JSON.stringify(str);
+      }
+      return `0x${val.value}`;
+    case "none":
+      return "none";
+    case "some":
+      return `(some ${prettyPrint(val.value, encoding)})`;
+    case "ok":
+      return `(ok ${prettyPrint(val.value, encoding)})`;
+    case "err":
+      return `(err ${prettyPrint(val.value, encoding)})`;
+    case "address":
+    case "contract":
+      return val.value;
+    case "list":
+      return `(list ${val.value.map((v) => prettyPrint(v, encoding)).join(" ")})`;
+    case "tuple":
+      return `(tuple ${Object.keys(val.value).map((key) => `(${key} ${prettyPrint(val.value[key], encoding)})`).join(" ")})`;
+    case "ascii":
+      return `"${val.value}"`;
+    case "utf8":
+      return `u"${val.value}"`;
+  }
+}
+function cvToJSON(val) {
+  switch (val.type) {
+    case "true":
+      return { type: "bool", value: true };
+    case "false":
+      return { type: "bool", value: false };
+    case "int":
+      return { type: "int", value: val.value.toString() };
+    case "uint":
+      return { type: "uint", value: val.value.toString() };
+    case "buffer": {
+      const hex = without0x(val.value);
+      return {
+        type: `(buff ${Math.ceil(hex.length / 2)})`,
+        value: `0x${hex}`
+      };
+    }
+    case "none":
+      return { type: "(optional none)", value: null };
+    case "some":
+      return { type: "(optional)", value: cvToJSON(val.value) };
+    case "ok":
+      return { type: "(response)", value: cvToJSON(val.value), success: true };
+    case "err":
+      return { type: "(response)", value: cvToJSON(val.value), success: false };
+    case "address":
+    case "contract":
+      return { type: "principal", value: val.value };
+    case "list":
+      return { type: "(list)", value: val.value.map(cvToJSON) };
+    case "tuple": {
+      const result = {};
+      for (const key of Object.keys(val.value)) {
+        result[key] = cvToJSON(val.value[key]);
+      }
+      return { type: "(tuple)", value: result };
+    }
+    case "ascii":
+      return {
+        type: `(string-ascii ${asciiToBytes(val.value).length})`,
+        value: val.value
+      };
+    case "utf8":
+      return {
+        type: `(string-utf8 ${utf8ToBytes(val.value).length})`,
+        value: val.value
+      };
+  }
+}
+function cvToValue(val) {
+  switch (val.type) {
+    case "true":
+      return true;
+    case "false":
+      return false;
+    case "int":
+    case "uint":
+      return val.value;
+    case "buffer":
+      return `0x${val.value}`;
+    case "none":
+      return null;
+    case "some":
+      return cvToValue(val.value);
+    case "ok":
+    case "err":
+      return cvToValue(val.value);
+    case "address":
+    case "contract":
+      return val.value;
+    case "list":
+      return val.value.map(cvToValue);
+    case "tuple": {
+      const result = {};
+      for (const key of Object.keys(val.value)) {
+        result[key] = cvToValue(val.value[key]);
+      }
+      return result;
+    }
+    case "ascii":
+    case "utf8":
+      return val.value;
+  }
+}
+function cvToBigInt(val) {
+  if (val.type !== "int" && val.type !== "uint") {
+    throw new Error(`cvToBigInt: expected int or uint, got ${val.type}`);
+  }
+  return val.value;
+}
+function cvToString(val) {
+  if (val.type !== "ascii" && val.type !== "utf8") {
+    throw new Error(`cvToString: expected ascii or utf8, got ${val.type}`);
+  }
+  return val.value;
+}
+function cvToBuffer(val) {
+  if (val.type !== "buffer") {
+    throw new Error(`cvToBuffer: expected buffer, got ${val.type}`);
+  }
+  return val.value;
+}
+function cvToBoolean(val) {
+  if (val.type !== "true" && val.type !== "false") {
+    throw new Error(`cvToBoolean: expected bool, got ${val.type}`);
+  }
+  return val.type === "true";
+}
+function cvToPrincipal(val) {
+  if (val.type !== "address" && val.type !== "contract") {
+    throw new Error(`cvToPrincipal: expected principal or contract, got ${val.type}`);
+  }
+  return val.value;
+}
+// src/clarity/abi/guards.ts
+function isUint128(value) {
+  return typeof value === "bigint" && value >= 0n && value <= MAX_U128;
+}
+function isInt128(value) {
+  return typeof value === "bigint" && value >= MIN_I128 && value <= MAX_I128;
+}
+function isBool(value) {
+  return typeof value === "boolean";
+}
+function isPrincipal(value) {
+  return typeof value === "string" && parsePrincipal(value) !== null;
+}
+function isStandardPrincipal(value) {
+  if (typeof value !== "string")
+    return false;
+  const parsed = parsePrincipal(value);
+  return parsed !== null && parsed.contractName === undefined;
+}
+function isContractPrincipal(value) {
+  if (typeof value !== "string")
+    return false;
+  const parsed = parsePrincipal(value);
+  return parsed !== null && parsed.contractName !== undefined;
+}
+function isTraitReference(value) {
+  return isContractPrincipal(value);
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isUint8Array(value) {
+  return value instanceof Uint8Array;
+}
+function isArray(value, itemGuard) {
+  return Array.isArray(value) && value.every(itemGuard);
+}
+function isOptional(value, guard) {
+  return value === null || guard(value);
+}
+function isOkResponse(response) {
+  return "ok" in response && !("err" in response);
+}
+function isErrResponse(response) {
+  return "err" in response && !("ok" in response);
+}
+function isResponse(value, okGuard, errGuard) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const obj = value;
+  if ("ok" in value && !("err" in value))
+    return okGuard(obj.ok);
+  if ("err" in value && !("ok" in value))
+    return errGuard(obj.err);
+  return false;
+}
+function isAbiList(type) {
+  return typeof type === "object" && type !== null && "list" in type;
+}
+function isAbiTuple(type) {
+  return typeof type === "object" && type !== null && "tuple" in type;
+}
+function isAbiOptional(type) {
+  return typeof type === "object" && type !== null && "optional" in type;
+}
+function isAbiResponse(type) {
+  return typeof type === "object" && type !== null && "response" in type;
+}
+function isAbiBuffer(type) {
+  return typeof type === "object" && type !== null && "buff" in type;
+}
+function isAbiStringAscii(type) {
+  return typeof type === "object" && type !== null && "string-ascii" in type;
+}
+function isAbiStringUtf8(type) {
+  return typeof type === "object" && type !== null && "string-utf8" in type;
+}
+function isAbiTraitReference(type) {
+  return type === "trait_reference";
+}
+// src/clarity/abi/utils.ts
+function toCamelCase(str) {
+  return str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase()).replace(/-([A-Z])/g, (_, letter) => letter).replace(/-(\d)/g, (_, digit) => digit).replace(/-/g, "").replace(/^\d/, "_$&");
+}
+
+// src/clarity/abi/converters.ts
+class ClarityConversionError extends Error {
+  type;
+  value;
+  constructor(message, type, value) {
+    super(message);
+    this.type = type;
+    this.value = value;
+    this.name = "ClarityConversionError";
+  }
+}
+function jsToClarity(type, value) {
+  if (type === "none")
+    return null;
+  if (type === "uint128") {
+    if (!isUint128(value))
+      throw new ClarityConversionError("Invalid uint128 value", type, value);
+    return value;
+  }
+  if (type === "int128") {
+    if (!isInt128(value))
+      throw new ClarityConversionError("Invalid int128 value", type, value);
+    return value;
+  }
+  if (type === "bool") {
+    if (!isBool(value))
+      throw new ClarityConversionError("Invalid bool value", type, value);
+    return value;
+  }
+  if (type === "principal") {
+    if (!isPrincipal(value))
+      throw new ClarityConversionError("Invalid principal value", type, value);
+    return value;
+  }
+  if (type === "trait_reference") {
+    if (!isPrincipal(value))
+      throw new ClarityConversionError("Invalid trait_reference value", type, value);
+    return value;
+  }
+  if (isAbiStringAscii(type)) {
+    if (!isString(value))
+      throw new ClarityConversionError("Invalid string-ascii value", type, value);
+    const str = value;
+    for (let i = 0;i < str.length; i++) {
+      if (str.charCodeAt(i) > 127) {
+        throw new ClarityConversionError(`Non-ASCII character at position ${i}: '${str[i]}' (code ${str.charCodeAt(i)})`, type, value);
+      }
+    }
+    if (str.length > type["string-ascii"].length) {
+      throw new ClarityConversionError(`String length ${str.length} exceeds max ${type["string-ascii"].length}`, type, value);
+    }
+    return value;
+  }
+  if (isAbiStringUtf8(type)) {
+    if (!isString(value))
+      throw new ClarityConversionError("Invalid string-utf8 value", type, value);
+    const str = value;
+    const byteLength = new TextEncoder().encode(str).length;
+    if (byteLength > type["string-utf8"].length) {
+      throw new ClarityConversionError(`String byte length ${byteLength} exceeds max ${type["string-utf8"].length}`, type, value);
+    }
+    return value;
+  }
+  if (isAbiBuffer(type)) {
+    if (!isUint8Array(value))
+      throw new ClarityConversionError("Invalid buffer value", type, value);
+    const buff = value;
+    if (buff.length > type.buff.length) {
+      throw new ClarityConversionError(`Buffer length ${buff.length} exceeds max ${type.buff.length}`, type, value);
+    }
+    return value;
+  }
+  if (isAbiList(type)) {
+    if (!Array.isArray(value))
+      throw new ClarityConversionError("Expected array for list type", type, value);
+    if (value.length > type.list.length) {
+      throw new ClarityConversionError(`List length ${value.length} exceeds max ${type.list.length}`, type, value);
+    }
+    return value.map((item) => jsToClarity(type.list.type, item));
+  }
+  if (isAbiTuple(type)) {
+    if (typeof value !== "object" || value === null)
+      throw new ClarityConversionError("Expected object for tuple type", type, value);
+    const result = {};
+    for (const field of type.tuple) {
+      const camelKey = toCamelCase(field.name);
+      const hasOriginal = field.name in value;
+      const hasCamel = camelKey in value;
+      if (!hasOriginal && !hasCamel) {
+        throw new ClarityConversionError(`Missing tuple field: ${field.name}`, type, value);
+      }
+      const fieldValue = hasOriginal ? value[field.name] : value[camelKey];
+      result[field.name] = jsToClarity(field.type, fieldValue);
+    }
+    return result;
+  }
+  if (isAbiOptional(type)) {
+    if (value === null || value === undefined)
+      return null;
+    return jsToClarity(type.optional, value);
+  }
+  if (isAbiResponse(type)) {
+    if (typeof value !== "object" || value === null)
+      throw new ClarityConversionError("Expected object for response type", type, value);
+    const hasOk = "ok" in value;
+    const hasErr = "err" in value;
+    if (hasOk && !hasErr) {
+      return {
+        ok: jsToClarity(type.response.ok, value.ok)
+      };
+    }
+    if (hasErr && !hasOk) {
+      return {
+        err: jsToClarity(type.response.error, value.err)
+      };
+    }
+    throw new ClarityConversionError("Response must have exactly 'ok' or 'err' property", type, value);
+  }
+  throw new ClarityConversionError("Unknown Clarity type", type, value);
+}
+function prepareArgs(func, args) {
+  return func.args.map((arg) => {
+    if (!(arg.name in args)) {
+      throw new ClarityConversionError(`Missing argument: ${arg.name}`, arg.type, undefined);
+    }
+    return jsToClarity(arg.type, args[arg.name]);
+  });
+}
+function validateArgs(func, args) {
+  for (const arg of func.args) {
+    if (!(arg.name in args)) {
+      throw new ClarityConversionError(`Missing argument: ${arg.name}`, arg.type, undefined);
+    }
+    jsToClarity(arg.type, args[arg.name]);
+  }
+}
+function validateArgsArray(func, args) {
+  if (args.length !== func.args.length) {
+    throw new ClarityConversionError(`Expected ${func.args.length} arguments, got ${args.length}`, func.args[0]?.type ?? "bool", args);
+  }
+  func.args.forEach((arg, i) => {
+    jsToClarity(arg.type, args[i]);
+  });
+}
+// src/clarity/abi/standards.ts
+var SIP010_ABI = {
+  functions: [
+    {
+      name: "transfer",
+      access: "public",
+      args: [
+        { name: "amount", type: "uint128" },
+        { name: "sender", type: "principal" },
+        { name: "recipient", type: "principal" },
+        { name: "memo", type: { optional: { buff: { length: 34 } } } }
+      ],
+      outputs: { response: { ok: "bool", error: "uint128" } }
+    },
+    {
+      name: "get-balance",
+      access: "read-only",
+      args: [{ name: "account", type: "principal" }],
+      outputs: { response: { ok: "uint128", error: "uint128" } }
+    },
+    {
+      name: "get-total-supply",
+      access: "read-only",
+      args: [],
+      outputs: { response: { ok: "uint128", error: "uint128" } }
+    },
+    {
+      name: "get-name",
+      access: "read-only",
+      args: [],
+      outputs: {
+        response: {
+          ok: { "string-ascii": { length: 32 } },
+          error: "uint128"
+        }
+      }
+    },
+    {
+      name: "get-symbol",
+      access: "read-only",
+      args: [],
+      outputs: {
+        response: {
+          ok: { "string-ascii": { length: 10 } },
+          error: "uint128"
+        }
+      }
+    },
+    {
+      name: "get-decimals",
+      access: "read-only",
+      args: [],
+      outputs: { response: { ok: "uint128", error: "uint128" } }
+    },
+    {
+      name: "get-token-uri",
+      access: "read-only",
+      args: [],
+      outputs: {
+        response: {
+          ok: { optional: { "string-utf8": { length: 256 } } },
+          error: "uint128"
+        }
+      }
+    }
+  ],
+  fungible_tokens: [{ name: "token" }]
+};
+var SIP009_ABI = {
+  functions: [
+    {
+      name: "transfer",
+      access: "public",
+      args: [
+        { name: "id", type: "uint128" },
+        { name: "sender", type: "principal" },
+        { name: "recipient", type: "principal" }
+      ],
+      outputs: { response: { ok: "bool", error: "uint128" } }
+    },
+    {
+      name: "get-owner",
+      access: "read-only",
+      args: [{ name: "id", type: "uint128" }],
+      outputs: {
+        response: { ok: { optional: "principal" }, error: "uint128" }
+      }
+    },
+    {
+      name: "get-last-token-id",
+      access: "read-only",
+      args: [],
+      outputs: { response: { ok: "uint128", error: "uint128" } }
+    },
+    {
+      name: "get-token-uri",
+      access: "read-only",
+      args: [{ name: "id", type: "uint128" }],
+      outputs: {
+        response: {
+          ok: { optional: { "string-utf8": { length: 256 } } },
+          error: "uint128"
+        }
+      }
+    }
+  ],
+  non_fungible_tokens: [{ name: "nft", type: "uint128" }]
+};
+var SIP013_ABI = {
+  functions: [
+    {
+      name: "transfer",
+      access: "public",
+      args: [
+        { name: "token-id", type: "uint128" },
+        { name: "amount", type: "uint128" },
+        { name: "sender", type: "principal" },
+        { name: "recipient", type: "principal" }
+      ],
+      outputs: { response: { ok: "bool", error: "uint128" } }
+    },
+    {
+      name: "transfer-memo",
+      access: "public",
+      args: [
+        { name: "token-id", type: "uint128" },
+        { name: "amount", type: "uint128" },
+        { name: "sender", type: "principal" },
+        { name: "recipient", type: "principal" },
+        { name: "memo", type: { buff: { length: 34 } } }
+      ],
+      outputs: { response: { ok: "bool", error: "uint128" } }
+    },
+    {
+      name: "transfer-many",
+      access: "public",
+      args: [
+        {
+          name: "transfers",
+          type: {
+            list: {
+              type: {
+                tuple: [
+                  { name: "token-id", type: "uint128" },
+                  { name: "amount", type: "uint128" },
+                  { name: "sender", type: "principal" },
+                  { name: "recipient", type: "principal" }
+                ]
+              },
+              length: 200
+            }
+          }
+        }
+      ],
+      outputs: { response: { ok: "bool", error: "uint128" } }
+    },
+    {
+      name: "transfer-many-memo",
+      access: "public",
+      args: [
+        {
+          name: "transfers",
+          type: {
+            list: {
+              type: {
+                tuple: [
+                  { name: "token-id", type: "uint128" },
+                  { name: "amount", type: "uint128" },
+                  { name: "sender", type: "principal" },
+                  { name: "recipient", type: "principal" },
+                  { name: "memo", type: { buff: { length: 34 } } }
+                ]
+              },
+              length: 200
+            }
+          }
+        }
+      ],
+      outputs: { response: { ok: "bool", error: "uint128" } }
+    },
+    {
+      name: "get-balance",
+      access: "read-only",
+      args: [
+        { name: "token-id", type: "uint128" },
+        { name: "account", type: "principal" }
+      ],
+      outputs: { response: { ok: "uint128", error: "uint128" } }
+    },
+    {
+      name: "get-overall-balance",
+      access: "read-only",
+      args: [{ name: "account", type: "principal" }],
+      outputs: { response: { ok: "uint128", error: "uint128" } }
+    },
+    {
+      name: "get-total-supply",
+      access: "read-only",
+      args: [{ name: "token-id", type: "uint128" }],
+      outputs: { response: { ok: "uint128", error: "uint128" } }
+    },
+    {
+      name: "get-overall-supply",
+      access: "read-only",
+      args: [],
+      outputs: { response: { ok: "uint128", error: "uint128" } }
+    },
+    {
+      name: "get-decimals",
+      access: "read-only",
+      args: [{ name: "token-id", type: "uint128" }],
+      outputs: { response: { ok: "uint128", error: "uint128" } }
+    },
+    {
+      name: "get-token-uri",
+      access: "read-only",
+      args: [{ name: "token-id", type: "uint128" }],
+      outputs: {
+        response: {
+          ok: { optional: { "string-utf8": { length: 256 } } },
+          error: "uint128"
+        }
+      }
+    }
+  ],
+  fungible_tokens: [],
+  non_fungible_tokens: []
+};
+var sip010Abi = SIP010_ABI;
+var sip009Abi = SIP009_ABI;
+var sip013Abi = SIP013_ABI;
+// src/clarity/abi/classify.ts
+var TRAIT_STANDARDS = ["sip-009", "sip-010", "sip-013"];
+var STANDARDS = [
+  { id: "sip-010", abi: SIP010_ABI, optional: new Set(["get-token-uri"]) },
+  { id: "sip-009", abi: SIP009_ABI, optional: new Set(["get-token-uri"]) },
+  {
+    id: "sip-013",
+    abi: SIP013_ABI,
+    optional: new Set([
+      "transfer-memo",
+      "transfer-many",
+      "transfer-many-memo",
+      "get-token-uri",
+      "get-overall-balance",
+      "get-overall-supply"
+    ])
+  }
+];
+function indexByName(abi) {
+  const m = new Map;
+  for (const f of abi.functions)
+    m.set(f.name, f);
+  return m;
+}
+function conformsTo(candidate, spec) {
+  const fns = indexByName(candidate);
+  for (const required of spec.abi.functions) {
+    if (spec.optional.has(required.name))
+      continue;
+    const got = fns.get(required.name);
+    if (!got)
+      return false;
+    if (got.access !== required.access)
+      return false;
+    if (got.args.length !== required.args.length)
+      return false;
+  }
+  return true;
+}
+function classifyContract(abi) {
+  if (!abi || !Array.isArray(abi.functions))
+    return [];
+  return STANDARDS.filter((s) => conformsTo(abi, s)).map((s) => s.id);
+}
+function parseDeclaredStandards(claritySource) {
+  const out = new Set;
+  const matches = claritySource.matchAll(/\(impl-trait\s+[^)]+\)/gi);
+  for (const m of matches) {
+    const ref = m[0].toLowerCase();
+    if (ref.includes("sip-010") || ref.includes(".ft-trait"))
+      out.add("sip-010");
+    if (ref.includes("sip-009") || ref.includes("nft-trait"))
+      out.add("sip-009");
+    if (ref.includes("sip-013") || ref.includes("semi-fungible"))
+      out.add("sip-013");
+  }
+  return [...out];
+}
+// src/clarity/abi/normalize.ts
+function normalizeAccess(access) {
+  if (access === "read_only")
+    return "read-only";
+  return access;
+}
+function normalizeType(type) {
+  if (typeof type === "string") {
+    switch (type) {
+      case "uint128":
+      case "int128":
+      case "bool":
+      case "principal":
+      case "trait_reference":
+        return type;
+      default:
+        return type;
+    }
+  }
+  if (typeof type !== "object" || type === null) {
+    throw new Error(`Invalid ABI type: expected object, got ${typeof type}`);
+  }
+  const typeObj = type;
+  if ("buffer" in typeObj) {
+    const buffer = typeObj.buffer;
+    return {
+      buff: {
+        length: buffer?.length ?? 32
+      }
+    };
+  }
+  if ("buff" in typeObj) {
+    const buff = typeObj.buff;
+    return {
+      buff: {
+        length: buff?.length ?? 32
+      }
+    };
+  }
+  if ("string-ascii" in typeObj) {
+    const strAscii = typeObj["string-ascii"];
+    return {
+      "string-ascii": {
+        length: strAscii?.length ?? 256
+      }
+    };
+  }
+  if ("string-utf8" in typeObj) {
+    const strUtf8 = typeObj["string-utf8"];
+    return {
+      "string-utf8": {
+        length: strUtf8?.length ?? 256
+      }
+    };
+  }
+  if ("response" in typeObj) {
+    const response = typeObj.response;
+    return {
+      response: {
+        ok: normalizeType(response?.ok ?? "bool"),
+        error: normalizeType(response?.error ?? "uint128")
+      }
+    };
+  }
+  if ("optional" in typeObj) {
+    return {
+      optional: normalizeType(typeObj.optional)
+    };
+  }
+  if ("list" in typeObj) {
+    const list = typeObj.list;
+    return {
+      list: {
+        type: normalizeType(list?.type ?? "uint128"),
+        length: list?.length ?? 100
+      }
+    };
+  }
+  if ("tuple" in typeObj) {
+    const tuple = typeObj.tuple;
+    return {
+      tuple: tuple.map((field) => ({
+        name: field.name,
+        type: normalizeType(field.type)
+      }))
+    };
+  }
+  throw new Error(`Unknown ABI type structure: ${JSON.stringify(type)}`);
+}
+function normalizeFunction(func) {
+  const access = normalizeAccess(func.access);
+  const args = func.args ?? [];
+  const outputs = func.outputs;
+  return {
+    name: func.name,
+    access,
+    args: args.map((arg) => ({
+      name: arg.name,
+      type: normalizeType(arg.type)
+    })),
+    outputs: normalizeType(typeof outputs === "object" && outputs !== null && "type" in outputs ? outputs.type : outputs)
+  };
+}
+function normalizeMap(map) {
+  return {
+    name: map.name,
+    key: normalizeType(map.key),
+    value: normalizeType(map.value)
+  };
+}
+function normalizeVariable(variable) {
+  return {
+    name: variable.name,
+    type: normalizeType(variable.type),
+    access: variable.access
+  };
+}
+function normalizeFungibleToken(token) {
+  return { name: token.name };
+}
+function normalizeNonFungibleToken(token) {
+  return { name: token.name, type: normalizeType(token.type) };
+}
+function normalizeTraitDefinition(trait) {
+  const rawFunctions = Array.isArray(trait.functions) ? trait.functions : [];
+  const functions = [];
+  for (const func of rawFunctions) {
+    if (typeof func !== "object" || func === null)
+      continue;
+    const normalized = normalizeFunction(func);
+    if (normalized.access === "private")
+      continue;
+    functions.push(normalized);
+  }
+  return { name: trait.name, functions };
+}
+function normalizeAbi(abi) {
+  if (typeof abi !== "object" || abi === null) {
+    return { functions: [] };
+  }
+  const abiObj = abi;
+  const functions = [];
+  const maps = [];
+  const variables = [];
+  const fungibleTokens = [];
+  const nonFungibleTokens = [];
+  const implementedTraits = [];
+  const definedTraits = [];
+  if (Array.isArray(abiObj.functions)) {
+    for (const func of abiObj.functions) {
+      if (typeof func === "object" && func !== null) {
+        functions.push(normalizeFunction(func));
+      }
+    }
+  }
+  if (Array.isArray(abiObj.maps)) {
+    for (const map of abiObj.maps) {
+      if (typeof map === "object" && map !== null) {
+        maps.push(normalizeMap(map));
+      }
+    }
+  }
+  if (Array.isArray(abiObj.variables)) {
+    for (const variable of abiObj.variables) {
+      if (typeof variable === "object" && variable !== null) {
+        variables.push(normalizeVariable(variable));
+      }
+    }
+  }
+  if (Array.isArray(abiObj.fungible_tokens)) {
+    for (const token of abiObj.fungible_tokens) {
+      if (typeof token === "object" && token !== null) {
+        fungibleTokens.push(normalizeFungibleToken(token));
+      }
+    }
+  }
+  if (Array.isArray(abiObj.non_fungible_tokens)) {
+    for (const token of abiObj.non_fungible_tokens) {
+      if (typeof token === "object" && token !== null) {
+        nonFungibleTokens.push(normalizeNonFungibleToken(token));
+      }
+    }
+  }
+  if (Array.isArray(abiObj.implemented_traits)) {
+    for (const trait of abiObj.implemented_traits) {
+      if (typeof trait === "string")
+        implementedTraits.push(trait);
+    }
+  }
+  if (Array.isArray(abiObj.defined_traits)) {
+    for (const trait of abiObj.defined_traits) {
+      if (typeof trait === "object" && trait !== null) {
+        definedTraits.push(normalizeTraitDefinition(trait));
+      }
+    }
+  }
+  return {
+    functions,
+    maps: maps.length > 0 ? maps : undefined,
+    variables: variables.length > 0 ? variables : undefined,
+    fungible_tokens: fungibleTokens.length > 0 ? fungibleTokens : undefined,
+    non_fungible_tokens: nonFungibleTokens.length > 0 ? nonFungibleTokens : undefined,
+    implemented_traits: implementedTraits.length > 0 ? implementedTraits : undefined,
+    defined_traits: definedTraits.length > 0 ? definedTraits : undefined
+  };
+}
+// src/clarity/bridge.ts
+var CV_TYPE_TAGS = new Set([
+  "int",
+  "uint",
+  "true",
+  "false",
+  "address",
+  "contract",
+  "ascii",
+  "utf8",
+  "buffer",
+  "list",
+  "tuple",
+  "none",
+  "some",
+  "ok",
+  "err"
+]);
+function isClarityValue(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const type = value.type;
+  if (typeof type !== "string" || !CV_TYPE_TAGS.has(type))
+    return false;
+  if (type === "true" || type === "false" || type === "none")
+    return true;
+  return "value" in value;
+}
+var HEX_PAIRS_REGEX = /^(?:[0-9a-fA-F]{2})+$/;
+function coerceBuffer(value) {
+  if (value instanceof Uint8Array)
+    return bufferCV(value);
+  if (typeof value === "object" && value !== null && "type" in value) {
+    const tagged = value;
+    if (tagged.type === "buffer" && isClarityValue(value))
+      return value;
+    if (typeof tagged.value === "string") {
+      if (tagged.type === "ascii")
+        return Cl.bufferFromAscii(tagged.value);
+      if (tagged.type === "utf8")
+        return Cl.bufferFromUtf8(tagged.value);
+      if (tagged.type === "hex")
+        return Cl.bufferFromHex(tagged.value);
+    }
+    throw new Error(`Unsupported buffer input: ${JSON.stringify(value)}`);
+  }
+  if (typeof value === "string") {
+    const hex = value.startsWith("0x") ? value.slice(2) : value;
+    if (HEX_PAIRS_REGEX.test(hex))
+      return Cl.bufferFromHex(hex);
+    return Cl.bufferFromUtf8(value);
+  }
+  throw new Error("buffer arg expects Uint8Array, hex string, { type, value }, or BufferCV");
+}
+function jsToClarityValue(abiType, value) {
+  if (isAbiBuffer(abiType))
+    return coerceBuffer(value);
+  if (isClarityValue(value))
+    return value;
+  if (abiType === "uint128")
+    return uintCV(value);
+  if (abiType === "int128")
+    return intCV(value);
+  if (abiType === "bool")
+    return boolCV(value);
+  if (abiType === "principal" || abiType === "trait_reference")
+    return Cl.principal(value);
+  if (isAbiStringAscii(abiType))
+    return stringAsciiCV(value);
+  if (isAbiStringUtf8(abiType))
+    return stringUtf8CV(value);
+  if (isAbiList(abiType)) {
+    const arr = value;
+    return listCV(arr.map((item) => jsToClarityValue(abiType.list.type, item)));
+  }
+  if (isAbiTuple(abiType)) {
+    const obj = value;
+    const data = {};
+    for (const field of abiType.tuple) {
+      const camelKey = toCamelCase(field.name);
+      const hasOriginal = field.name in obj;
+      const hasCamel = camelKey in obj;
+      const fieldValue = hasOriginal ? obj[field.name] : hasCamel ? obj[camelKey] : undefined;
+      if (fieldValue === undefined && !isAbiOptional(field.type)) {
+        throw new Error(`Missing tuple field: ${field.name}`);
+      }
+      data[field.name] = jsToClarityValue(field.type, fieldValue);
+    }
+    return tupleCV(data);
+  }
+  if (isAbiOptional(abiType)) {
+    if (value === null || value === undefined)
+      return noneCV();
+    return someCV(jsToClarityValue(abiType.optional, value));
+  }
+  if (isAbiResponse(abiType)) {
+    const obj = value;
+    if ("ok" in obj && !("err" in obj))
+      return responseOkCV(jsToClarityValue(abiType.response.ok, obj.ok));
+    if ("err" in obj && !("ok" in obj))
+      return responseErrorCV(jsToClarityValue(abiType.response.error, obj.err));
+    throw new Error("Response must have exactly 'ok' or 'err' property");
+  }
+  throw new Error(`Unknown ABI type: ${JSON.stringify(abiType)}`);
+}
+function clarityValueToJS(abiType, cv) {
+  return clarityValueToJSInner(abiType, cv);
+}
+function clarityValueToJSUntyped(abiType, cv) {
+  return clarityValueToJSInner(abiType, cv);
+}
+function clarityValueToJSInner(abiType, cv) {
+  if (abiType === "uint128" || abiType === "int128") {
+    if (cv.type !== "int" && cv.type !== "uint")
+      throw new Error(`Expected int/uint CV, got ${cv.type}`);
+    return cv.value;
+  }
+  if (abiType === "bool") {
+    if (cv.type === "true")
+      return true;
+    if (cv.type === "false")
+      return false;
+    throw new Error(`Expected bool CV, got ${cv.type}`);
+  }
+  if (abiType === "principal" || abiType === "trait_reference") {
+    if (cv.type !== "address" && cv.type !== "contract")
+      throw new Error(`Expected principal CV, got ${cv.type}`);
+    return cv.value;
+  }
+  if (isAbiStringAscii(abiType) || isAbiStringUtf8(abiType)) {
+    if (cv.type !== "ascii" && cv.type !== "utf8")
+      throw new Error(`Expected string CV, got ${cv.type}`);
+    return cv.value;
+  }
+  if (isAbiBuffer(abiType)) {
+    if (cv.type !== "buffer")
+      throw new Error(`Expected buffer CV, got ${cv.type}`);
+    const hex = cv.value;
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0;i < bytes.length; i++) {
+      bytes[i] = Number.parseInt(hex.substring(i * 2, i * 2 + 2), 16);
+    }
+    return bytes;
+  }
+  if (isAbiList(abiType)) {
+    if (cv.type !== "list")
+      throw new Error(`Expected list CV, got ${cv.type}`);
+    return cv.value.map((item) => clarityValueToJSInner(abiType.list.type, item));
+  }
+  if (isAbiTuple(abiType)) {
+    if (cv.type !== "tuple")
+      throw new Error(`Expected tuple CV, got ${cv.type}`);
+    const result = {};
+    for (const field of abiType.tuple) {
+      const fieldCV = cv.value[field.name];
+      if (!fieldCV)
+        throw new Error(`Missing tuple field in CV: ${field.name}`);
+      const camelKey = toCamelCase(field.name);
+      result[camelKey] = clarityValueToJSInner(field.type, fieldCV);
+    }
+    return result;
+  }
+  if (isAbiOptional(abiType)) {
+    if (cv.type === "none")
+      return null;
+    if (cv.type === "some")
+      return clarityValueToJSInner(abiType.optional, cv.value);
+    throw new Error(`Expected optional CV, got ${cv.type}`);
+  }
+  if (isAbiResponse(abiType)) {
+    if (cv.type === "ok")
+      return { ok: clarityValueToJSInner(abiType.response.ok, cv.value) };
+    if (cv.type === "err")
+      return { err: clarityValueToJSInner(abiType.response.error, cv.value) };
+    throw new Error(`Expected response CV, got ${cv.type}`);
+  }
+  throw new Error(`Unknown ABI type: ${JSON.stringify(abiType)}`);
+}
 // src/bitcoin/index.ts
 var exports_bitcoin = {};
 __export(exports_bitcoin, {
@@ -35,6 +2053,367 @@ __export(exports_bitcoin, {
 });
 module.exports = __toCommonJS(exports_bitcoin);
 
+// src/bitcoin/serialize.ts
+function doubleSha256(bytes) {
+  return import_sha22.sha256(import_sha22.sha256(bytes));
+}
+function reverseBytes(bytes) {
+  const out = new Uint8Array(bytes.length);
+  for (let i = 0;i < bytes.length; i++) {
+    out[i] = bytes[bytes.length - 1 - i];
+  }
+  return out;
+}
+
+class BtcReader {
+  data;
+  view;
+  offset = 0;
+  constructor(data) {
+    this.data = data;
+    this.view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  }
+  get length() {
+    return this.data.length;
+  }
+  readUInt8() {
+    const v = this.view.getUint8(this.offset);
+    this.offset += 1;
+    return v;
+  }
+  peekUInt8() {
+    return this.view.getUint8(this.offset);
+  }
+  readUInt32LE() {
+    const v = this.view.getUint32(this.offset, true);
+    this.offset += 4;
+    return v;
+  }
+  readUInt64LE() {
+    const v = this.view.getBigUint64(this.offset, true);
+    this.offset += 8;
+    return v;
+  }
+  readBytes(n) {
+    if (this.offset + n > this.data.length) {
+      throw new Error(`Bitcoin tx underflow: need ${n} bytes at offset ${this.offset}, have ${this.data.length}`);
+    }
+    const slice = this.data.slice(this.offset, this.offset + n);
+    this.offset += n;
+    return slice;
+  }
+  readVarInt() {
+    const first = this.readUInt8();
+    if (first < 253)
+      return first;
+    if (first === 253) {
+      const v = this.view.getUint16(this.offset, true);
+      this.offset += 2;
+      return v;
+    }
+    if (first === 254) {
+      return this.readUInt32LE();
+    }
+    const big = this.readUInt64LE();
+    if (big > BigInt(Number.MAX_SAFE_INTEGER)) {
+      throw new Error("Bitcoin varint exceeds safe integer range");
+    }
+    return Number(big);
+  }
+}
+function scanTx(rawTx) {
+  const r = new BtcReader(rawTx);
+  const version = r.readUInt32LE();
+  let hasWitness = false;
+  if (r.peekUInt8() === 0) {
+    r.readUInt8();
+    const flag = r.readUInt8();
+    if (flag !== 1) {
+      throw new Error(`Unexpected SegWit flag 0x${flag.toString(16)}`);
+    }
+    hasWitness = true;
+  }
+  const bodyStart = r.offset;
+  const inputCount = r.readVarInt();
+  const inputs = [];
+  for (let i = 0;i < inputCount; i++) {
+    const prevTxid = r.readBytes(32);
+    const vout = r.readUInt32LE();
+    const scriptSig = r.readBytes(r.readVarInt());
+    const sequence = r.readUInt32LE();
+    inputs.push({ prevTxid, vout, scriptSig, sequence });
+  }
+  const outputCount = r.readVarInt();
+  const outputs = [];
+  for (let i = 0;i < outputCount; i++) {
+    const value = r.readUInt64LE();
+    const scriptPubKey = r.readBytes(r.readVarInt());
+    outputs.push({ value, scriptPubKey });
+  }
+  const bodyEnd = r.offset;
+  if (hasWitness) {
+    for (let i = 0;i < inputCount; i++) {
+      const itemCount = r.readVarInt();
+      for (let j = 0;j < itemCount; j++) {
+        r.readBytes(r.readVarInt());
+      }
+    }
+  }
+  const locktime = r.readUInt32LE();
+  const legacy = concatBytes(rawTx.slice(0, 4), rawTx.slice(bodyStart, bodyEnd), rawTx.slice(r.offset - 4, r.offset));
+  return { version, hasWitness, inputs, outputs, locktime, legacy };
+}
+function parseBitcoinTx(rawTx) {
+  const s = scanTx(rawTx);
+  return {
+    version: s.version,
+    hasWitness: s.hasWitness,
+    inputs: s.inputs,
+    outputs: s.outputs,
+    locktime: s.locktime,
+    txidInternal: doubleSha256(s.legacy)
+  };
+}
+function stripWitness(rawTx) {
+  return scanTx(rawTx).legacy;
+}
+function bitcoinTxid(rawTx, { display = false } = {}) {
+  const txid = doubleSha256(scanTx(rawTx).legacy);
+  return display ? reverseBytes(txid) : txid;
+}
+function parseBlockHeader(header) {
+  if (header.length !== 80) {
+    throw new Error(`Bitcoin block header must be 80 bytes, got ${header.length}`);
+  }
+  const r = new BtcReader(header);
+  const version = r.readUInt32LE();
+  const prevBlock = r.readBytes(32);
+  const merkleRoot = r.readBytes(32);
+  const timestamp = r.readUInt32LE();
+  const bits = r.readUInt32LE();
+  const nonce = r.readUInt32LE();
+  return { version, prevBlock, merkleRoot, timestamp, bits, nonce };
+}
+function blockHash(header, { display = false } = {}) {
+  const hash = doubleSha256(header);
+  return display ? reverseBytes(hash) : hash;
+}
+// src/bitcoin/merkle.ts
+function hashPair(left, right) {
+  return doubleSha256(concatBytes(left, right));
+}
+function nextLevel(level) {
+  const next = [];
+  for (let i = 0;i < level.length; i += 2) {
+    const left = level[i];
+    if (left === undefined)
+      throw new Error("merkle: missing left node");
+    const right = level[i + 1] ?? left;
+    next.push(hashPair(left, right));
+  }
+  return next;
+}
+function merkleRoot(txidsInternal) {
+  if (txidsInternal.length === 0) {
+    throw new Error("merkleRoot: empty tx list");
+  }
+  let level = txidsInternal.slice();
+  while (level.length > 1) {
+    level = nextLevel(level);
+  }
+  const root = level[0];
+  if (root === undefined)
+    throw new Error("merkleRoot: no root");
+  return root;
+}
+function buildMerkleProof(txidsInternal, txIndex) {
+  const txCount = txidsInternal.length;
+  if (txCount === 0) {
+    throw new Error("buildMerkleProof: empty tx list");
+  }
+  if (txIndex < 0 || txIndex >= txCount) {
+    throw new Error(`buildMerkleProof: txIndex ${txIndex} out of range for ${txCount} txs`);
+  }
+  const siblings = [];
+  let index = txIndex;
+  let level = txidsInternal.slice();
+  while (level.length > 1) {
+    const isRight = index % 2 === 1;
+    const siblingIndex = isRight ? index - 1 : index + 1;
+    const self = level[index];
+    if (self === undefined)
+      throw new Error("buildMerkleProof: missing node");
+    siblings.push(level[siblingIndex] ?? self);
+    level = nextLevel(level);
+    index = Math.floor(index / 2);
+  }
+  return { siblings, txIndex, txCount };
+}
+function rootFromProof(leafInternal, proof) {
+  let hash = leafInternal;
+  let index = proof.txIndex;
+  for (const sibling of proof.siblings) {
+    hash = index % 2 === 1 ? hashPair(sibling, hash) : hashPair(hash, sibling);
+    index = Math.floor(index / 2);
+  }
+  return hash;
+}
+
+// src/bitcoin/proof.ts
+function normalizeTxid(txid) {
+  return without0x(txid).toLowerCase();
+}
+function assembleBlockForTx(args) {
+  const txIndex = args.txidsDisplay.indexOf(normalizeTxid(args.txid));
+  if (txIndex < 0) {
+    throw new Error(`tx ${args.txid} not found in block ${args.blockId}`);
+  }
+  return {
+    header: hexToBytes(args.headerHex),
+    height: args.height,
+    txidsInternal: args.txidsDisplay.map((t) => reverseBytes(hexToBytes(t))),
+    txIndex
+  };
+}
+async function buildTxProof(source, params) {
+  const { txid, vout } = params;
+  const want = normalizeTxid(txid);
+  const [rawTx, block] = await Promise.all([
+    source.getRawTx(txid),
+    source.getBlockForTx(txid)
+  ]);
+  const parsed = parseBitcoinTx(rawTx);
+  const gotDisplay = bytesToHex(reverseBytes(parsed.txidInternal));
+  if (gotDisplay !== want) {
+    throw new Error(`source returned a tx whose id ${gotDisplay} does not match requested ${want}`);
+  }
+  const atIndex = block.txidsInternal[block.txIndex];
+  if (!atIndex || bytesToHex(atIndex) !== bytesToHex(parsed.txidInternal)) {
+    throw new Error(`source txIndex ${block.txIndex} does not point at tx ${want}`);
+  }
+  const merkle = buildMerkleProof(block.txidsInternal, block.txIndex);
+  const headerRoot = parseBlockHeader(block.header).merkleRoot;
+  const computed = rootFromProof(parsed.txidInternal, merkle);
+  if (bytesToHex(computed) !== bytesToHex(headerRoot)) {
+    throw new Error("constructed merkle proof does not reconcile with the block header merkle root");
+  }
+  return {
+    rawTx,
+    txidInternal: parsed.txidInternal,
+    vout,
+    merkle,
+    header: block.header,
+    height: block.height
+  };
+}
+function fallbackProofSource(sources) {
+  if (sources.length === 0) {
+    throw new Error("fallbackProofSource: at least one source is required");
+  }
+  async function firstSuccess(fn) {
+    let lastError;
+    for (const source of sources) {
+      try {
+        return await fn(source);
+      } catch (error) {
+        lastError = error;
+      }
+    }
+    throw lastError;
+  }
+  return {
+    getRawTx: (txid) => firstSuccess((s) => s.getRawTx(txid)),
+    getBlockForTx: (txid) => firstSuccess((s) => s.getBlockForTx(txid))
+  };
+}
+function bitcoinRpcSource(config) {
+  const doFetch = config.fetch ?? fetch;
+  async function rpc(method, rpcParams) {
+    const headers = {
+      "content-type": "application/json"
+    };
+    if (config.auth) {
+      const basic = typeof config.auth === "string" ? config.auth : btoa(`${config.auth.username}:${config.auth.password}`);
+      headers.authorization = `Basic ${basic}`;
+    }
+    const res = await doFetch(config.url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        jsonrpc: "1.0",
+        id: "secondlayer",
+        method,
+        params: rpcParams
+      })
+    });
+    if (!res.ok) {
+      throw new Error(`bitcoin rpc ${method} failed: HTTP ${res.status}`);
+    }
+    const json = await res.json();
+    if (json.error) {
+      throw new Error(`bitcoin rpc ${method} error: ${json.error.message}`);
+    }
+    return json.result;
+  }
+  return {
+    async getRawTx(txid) {
+      return hexToBytes(await rpc("getrawtransaction", [txid, false]));
+    },
+    async getBlockForTx(txid) {
+      const tx = await rpc("getrawtransaction", [
+        txid,
+        true
+      ]);
+      if (!tx.blockhash) {
+        throw new Error(`tx ${txid} is not in a block (node needs -txindex, or the tx is unconfirmed)`);
+      }
+      const block = await rpc("getblock", [
+        tx.blockhash,
+        1
+      ]);
+      const header = await rpc("getblockheader", [tx.blockhash, false]);
+      return assembleBlockForTx({
+        txid,
+        blockId: tx.blockhash,
+        headerHex: header,
+        height: block.height,
+        txidsDisplay: block.tx
+      });
+    }
+  };
+}
+function esploraSource(config) {
+  const doFetch = config.fetch ?? fetch;
+  const base = config.url.replace(/\/+$/, "");
+  async function get(path) {
+    const res = await doFetch(`${base}${path}`);
+    if (!res.ok) {
+      throw new Error(`esplora GET ${path} failed: HTTP ${res.status}`);
+    }
+    return res;
+  }
+  return {
+    async getRawTx(txid) {
+      return hexToBytes((await (await get(`/tx/${txid}/hex`)).text()).trim());
+    },
+    async getBlockForTx(txid) {
+      const status = await (await get(`/tx/${txid}`)).json();
+      if (!status.status.confirmed) {
+        throw new Error(`tx ${txid} is unconfirmed`);
+      }
+      const blockHashHex = status.status.block_hash;
+      const header = (await (await get(`/block/${blockHashHex}/header`)).text()).trim();
+      const txids = await (await get(`/block/${blockHashHex}/txids`)).json();
+      return assembleBlockForTx({
+        txid,
+        blockId: blockHashHex,
+        headerHex: header,
+        height: status.status.block_height,
+        txidsDisplay: txids
+      });
+    }
+  };
+}
 // src/bitcoin/codec.ts
 function merkleDepth(txCount) {
   let depth = 0;
@@ -203,6 +2582,18 @@ var SPV_ADAPTER_ABI = {
     }
   ]
 };
+// src/epochs.ts
+var EPOCH_4_ACTIVATION_BURN_HEIGHT_MAINNET = 960230;
+
+// src/errors/response.ts
+class MalformedResponseError extends BaseError {
+  name = "MalformedResponseError";
+}
+
+class ReadContractError extends BaseError {
+  name = "ReadContractError";
+}
+
 // src/bitcoin/activation.ts
 async function getBurnBlockHeight(client) {
   const info = await client.request("/v2/info");
@@ -219,6 +2610,28 @@ async function isClarity6Active(client, gate = {}) {
   const current = await getBurnBlockHeight(client);
   return current >= activation;
 }
+// src/actions/public/readContract.ts
+async function readContract(client, params) {
+  const [address, name] = parseContractId(params.contract);
+  const sender = params.sender ?? address;
+  const serializedArgs = (params.args ?? []).map((arg) => with0x(bytesToHex(serializeCVBytes(arg))));
+  const path = `/v2/contracts/call-read/${encodeURIComponent(address)}/${encodeURIComponent(name)}/${encodeURIComponent(params.functionName)}`;
+  const data = await client.request(params.tip ? `${path}?tip=${encodeURIComponent(params.tip)}` : path, {
+    method: "POST",
+    body: {
+      sender,
+      arguments: serializedArgs
+    }
+  });
+  if (data.okay) {
+    if (typeof data.result !== "string") {
+      throw new MalformedResponseError(`readContract: /v2/contracts/call-read response is missing "result"`);
+    }
+    return deserializeCVBytes(data.result);
+  }
+  throw new ReadContractError(data.cause ?? "Read-only call failed");
+}
+
 // src/bitcoin/verifier.ts
 function clarityToBool(cv) {
   const value = cv.type === "ok" ? cv.value : cv;
@@ -282,6 +2695,69 @@ function bitcoinVerifier(client, config) {
     }
   };
 }
+// src/bitcoin/address.ts
+var import_secp256k1 = require("@noble/curves/secp256k1.js");
+var import_base3 = require("@scure/base");
+var BITCOIN_NETWORK_PARAMS = {
+  mainnet: { p2pkh: 0, p2sh: 5, hrp: "bc" },
+  testnet: { p2pkh: 111, p2sh: 196, hrp: "tb" },
+  regtest: { p2pkh: 111, p2sh: 196, hrp: "bcrt" }
+};
+var NETWORK_PARAMS = BITCOIN_NETWORK_PARAMS;
+function base58CheckEncode(version, payload) {
+  const data = concatBytes(Uint8Array.of(version), payload);
+  const checksum = doubleSha256(data).slice(0, 4);
+  return import_base3.base58.encode(concatBytes(data, checksum));
+}
+function formatBitcoinAddress(parsed, network = "mainnet") {
+  const params = NETWORK_PARAMS[network];
+  const hash = parsed.hash;
+  if (!hash)
+    return;
+  switch (parsed.type) {
+    case "p2pkh":
+      return base58CheckEncode(params.p2pkh, hash);
+    case "p2sh":
+      return base58CheckEncode(params.p2sh, hash);
+    case "p2wpkh":
+    case "p2wsh":
+      return import_base3.bech32.encode(params.hrp, [0, ...import_base3.bech32.toWords(hash)]);
+    case "p2tr":
+      return import_base3.bech32m.encode(params.hrp, [1, ...import_base3.bech32m.toWords(hash)]);
+    default:
+      return;
+  }
+}
+function toPubkeyBytes(publicKey) {
+  return typeof publicKey === "string" ? hexToBytes(publicKey) : publicKey;
+}
+function taprootTweakPubkey(xonly) {
+  if (xonly.length !== 32)
+    throw new Error(`Expected 32-byte x-only pubkey, got ${xonly.length}`);
+  const tweak = import_secp256k1.schnorr.utils.taggedHash("TapTweak", xonly);
+  const t = BigInt(`0x${Array.from(tweak, (b) => b.toString(16).padStart(2, "0")).join("")}`);
+  if (t >= import_secp256k1.secp256k1.Point.Fn.ORDER)
+    throw new Error("Invalid tap tweak (exceeds curve order)");
+  const internal = import_secp256k1.secp256k1.Point.fromBytes(concatBytes(Uint8Array.of(2), xonly));
+  const output = internal.add(import_secp256k1.secp256k1.Point.BASE.multiply(t));
+  return output.toBytes(true).slice(1);
+}
+function publicKeyToP2wpkhAddress(publicKey, network = "mainnet") {
+  const pubkey = toPubkeyBytes(publicKey);
+  if (pubkey.length !== 33)
+    throw new Error(`Expected 33-byte compressed pubkey, got ${pubkey.length}`);
+  const params = NETWORK_PARAMS[network];
+  return import_base3.bech32.encode(params.hrp, [0, ...import_base3.bech32.toWords(hash160(pubkey))]);
+}
+function publicKeyToP2trAddress(publicKey, network = "mainnet") {
+  const pubkey = toPubkeyBytes(publicKey);
+  const xonly = pubkey.length === 33 ? pubkey.slice(1) : pubkey.length === 32 ? pubkey : undefined;
+  if (!xonly)
+    throw new Error(`Expected 33-byte compressed or 32-byte x-only pubkey, got ${pubkey.length}`);
+  const params = NETWORK_PARAMS[network];
+  const outputKey = taprootTweakPubkey(xonly);
+  return import_base3.bech32m.encode(params.hrp, [1, ...import_base3.bech32m.toWords(outputKey)]);
+}
 // src/bitcoin/actions.ts
 async function verifyBitcoinPayment(client, params) {
   const {
@@ -323,5 +2799,5 @@ async function verifyBitcoinPayment(client, params) {
   return { verified, mined, output, proof };
 }
 
-//# debugId=9351A7F6CE1E30D964756E2164756E21
+//# debugId=DE7406CAE6FEF1BF64756E2164756E21
 //# sourceMappingURL=index.cjs.map