@secondlayer/stacks 6.1.0 → 6.1.2

package/dist/src/bitcoin/index.cjs

@@ -19,13 +19,15 @@ var __toESM = (mod, isNodeMode, target) => {
       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
-      });
+  const to = isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  if (mod && typeof mod === "object" || typeof mod === "function") {
+    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;
@@ -61,120 +63,42 @@ var __export = (target, all) => {
     });
 };
 
-// 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
+// src/bitcoin/index.ts
+var exports_bitcoin = {};
+__export(exports_bitcoin, {
+  BtcReader: () => BtcReader,
+  EPOCH_4_ACTIVATION_BURN_HEIGHT_MAINNET: () => EPOCH_4_ACTIVATION_BURN_HEIGHT_MAINNET,
+  SPV_ADAPTER_ABI: () => SPV_ADAPTER_ABI,
+  SPV_ADAPTER_CONTRACTS: () => SPV_ADAPTER_CONTRACTS,
+  bitcoinRpcSource: () => bitcoinRpcSource,
+  bitcoinTxid: () => bitcoinTxid,
+  bitcoinVerifier: () => bitcoinVerifier,
+  blockHash: () => blockHash,
+  buildMerkleProof: () => buildMerkleProof,
+  buildTxProof: () => buildTxProof,
+  decodeTxOutput: () => decodeTxOutput,
+  doubleSha256: () => doubleSha256,
+  encodeMerkleProofArgs: () => encodeMerkleProofArgs,
+  esploraSource: () => esploraSource,
+  fallbackProofSource: () => fallbackProofSource,
+  formatBitcoinAddress: () => formatBitcoinAddress,
+  getBurnBlockHeight: () => getBurnBlockHeight,
+  getSpvAdapter: () => getSpvAdapter,
+  isClarity6Active: () => isClarity6Active,
+  merkleRoot: () => merkleRoot,
+  parseBitcoinTx: () => parseBitcoinTx,
+  parseBlockHeader: () => parseBlockHeader,
+  parseOutputScript: () => parseOutputScript,
+  publicKeyToP2trAddress: () => publicKeyToP2trAddress,
+  publicKeyToP2wpkhAddress: () => publicKeyToP2wpkhAddress,
+  reverseBytes: () => reverseBytes,
+  rootFromProof: () => rootFromProof,
+  spvAdapterPrincipal: () => spvAdapterPrincipal,
+  stripWitness: () => stripWitness,
+  taprootTweakPubkey: () => taprootTweakPubkey,
+  verifyBitcoinPayment: () => verifyBitcoinPayment
 });
-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");
+module.exports = __toCommonJS(exports_bitcoin);
 
 // src/utils/encoding.ts
 var hexes = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
@@ -307,2112 +231,2187 @@ 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("");
+// src/utils/hash.ts
+var import_legacy = require("@noble/hashes/legacy.js");
+var import_sha2 = require("@noble/hashes/sha2.js");
+var import_sha22 = require("@noble/hashes/sha2.js");
+function hash160(input) {
+  return import_legacy.ripemd160(import_sha2.sha256(input));
 }
-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 txidFromBytes(data) {
+  return bytesToHex(import_sha22.sha512_256(data));
 }
-function c32checksum(dataHex) {
-  return bytesToHex(import_sha2.sha256(import_sha2.sha256(hexToBytes(dataHex))).slice(0, 4));
+function hashP2PKH(input) {
+  return bytesToHex(hash160(input));
 }
-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}`)}`;
+
+// src/bitcoin/serialize.ts
+function doubleSha256(bytes) {
+  return import_sha2.sha256(import_sha2.sha256(bytes));
 }
-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");
+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 [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";
+  return out;
 }
 
-// src/utils/bytes-reader.ts
-class BytesReader {
+class BtcReader {
   data;
+  view;
   offset = 0;
   constructor(data) {
     this.data = data;
+    this.view = new DataView(data.buffer, data.byteOffset, data.byteLength);
   }
-  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}`);
-    }
+  get length() {
+    return this.data.length;
   }
   readUInt8() {
-    this.ensure(1);
-    return this.data[this.offset++];
+    const v = this.view.getUint8(this.offset);
+    this.offset += 1;
+    return v;
   }
-  readUInt16BE() {
-    this.ensure(2);
-    const val = (this.data[this.offset] << 8 | this.data[this.offset + 1]) >>> 0;
-    this.offset += 2;
-    return val;
+  peekUInt8() {
+    return this.view.getUint8(this.offset);
   }
-  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;
+  readUInt32LE() {
+    const v = this.view.getUint32(this.offset, true);
     this.offset += 4;
-    return val;
+    return v;
   }
-  readBytes(length) {
-    this.ensure(length);
-    const slice = this.data.slice(this.offset, this.offset + length);
-    this.offset += length;
+  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;
   }
-  readBigUInt64BE() {
-    const hex = bytesToHex(this.readBytes(8));
-    return hex.length > 0 ? BigInt(`0x${hex}`) : 0n;
+  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);
   }
 }
-
-// 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();
+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;
   }
-  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`);
+  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 });
   }
-}
-function readCV(reader, depth = 0) {
-  if (depth > MAX_CV_DEPTH) {
-    throw new SerializationError(`Clarity value nests deeper than ${MAX_CV_DEPTH} levels`);
+  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 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);
+  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());
       }
-      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}`);
   }
+  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 deserializeCVBytes(input) {
-  const bytes = typeof input === "string" ? hexToBytes(without0x(input)) : input;
-  return readCV(new BytesReader(bytes));
+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 deserializeCV(input) {
-  return deserializeCVBytes(input);
+function stripWitness(rawTx) {
+  return scanTx(rawTx).legacy;
 }
-
-// src/clarity/serialize.ts
-var CLARITY_INT_SIZE = 128n;
-var CLARITY_INT_BYTE_SIZE = 16;
-function typeIdByte(type) {
-  return ClarityWireType[type];
+function bitcoinTxid(rawTx, { display = false } = {}) {
+  const txid = doubleSha256(scanTx(rawTx).legacy);
+  return display ? reverseBytes(txid) : txid;
 }
-function withTypeId(type, bytes) {
-  return concatBytes(new Uint8Array([typeIdByte(type)]), bytes);
+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 serializeAddress(c32Address) {
-  const [version, hash1602] = c32addressDecode(c32Address);
-  return concatBytes(new Uint8Array([version]), hexToBytes(hash1602));
+function blockHash(header, { display = false } = {}) {
+  const hash = doubleSha256(header);
+  return display ? reverseBytes(hash) : hash;
 }
-function serializeLPString(str, prefixBytes = 1) {
-  const content = utf8ToBytes(str);
-  const lengthPrefix = hexToBytes(intToHex(content.byteLength, prefixBytes));
-  return concatBytes(lengthPrefix, content);
+// src/bitcoin/merkle.ts
+function hashPair(left, right) {
+  return doubleSha256(concatBytes(left, right));
 }
-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 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 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));
+function merkleRoot(txidsInternal) {
+  if (txidsInternal.length === 0) {
+    throw new Error("merkleRoot: empty tx list");
   }
-  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");
+  let level = txidsInternal.slice();
+  while (level.length > 1) {
+    level = nextLevel(level);
   }
-  return { type: "buffer", value: bytesToHex(buffer) };
-}
-function standardPrincipalCV(address) {
-  const [version, hash1602] = c32addressDecode(address);
-  const normalized = c32address(version, hash1602);
-  return { type: "address", value: normalized };
+  const root = level[0];
+  if (root === undefined)
+    throw new Error("merkleRoot: no root");
+  return root;
 }
-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");
+function buildMerkleProof(txidsInternal, txIndex) {
+  const txCount = txidsInternal.length;
+  if (txCount === 0) {
+    throw new Error("buildMerkleProof: empty tx list");
   }
-  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`);
-    }
+  if (txIndex < 0 || txIndex >= txCount) {
+    throw new Error(`buildMerkleProof: txIndex ${txIndex} out of range for ${txCount} txs`);
   }
-  return { type: "tuple", value: data };
-}
-function stringAsciiCV(value) {
-  return { type: "ascii", value };
-}
-function stringUtf8CV(value) {
-  return { type: "utf8", value };
+  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 };
 }
-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 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;
 }
-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";
+
+// src/bitcoin/proof.ts
+function normalizeTxid(txid) {
+  return without0x(txid).toLowerCase();
 }
-function encodeStructuredData(opts) {
-  if (!isDomain(opts.domain)) {
-    throw new Error("domain must be a tuple { name: ascii, version: ascii, chain-id: uint }");
+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 concatBytes(SIP018_PREFIX, hashStructuredData(opts.domain), hashStructuredData(opts.message));
-}
-function structuredDataHash(opts) {
-  return import_sha24.sha256(encodeStructuredData(opts));
+  return {
+    header: hexToBytes(args.headerHex),
+    height: args.height,
+    txidsInternal: args.txidsDisplay.map((t) => reverseBytes(hexToBytes(t))),
+    txIndex
+  };
 }
-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}`);
+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}`);
   }
-  return bytesToHex(concatBytes(vrs.slice(1), vrs.slice(0, 1)));
+  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
+  };
 }
-// 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);
+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;
       }
-      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}"`;
+    }
+    throw lastError;
   }
+  return {
+    getRawTx: (txid) => firstSuccess((s) => s.getRawTx(txid)),
+    getBlockForTx: (txid) => firstSuccess((s) => s.getBlockForTx(txid))
+  };
 }
-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}`
-      };
+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}`;
     }
-    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 };
+    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}`);
     }
-    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
-      };
+    const json = await res.json();
+    if (json.error) {
+      throw new Error(`bitcoin rpc ${method} error: ${json.error.message}`);
+    }
+    return json.result;
   }
-}
-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 {
+    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)`);
       }
-      return result;
+      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
+      });
     }
-    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}`);
+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 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/, "_$&");
+  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/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";
+// src/clarity/index.ts
+var exports_clarity = {};
+__export(exports_clarity, {
+  CONTRACT_NAME_REGEX: () => CONTRACT_NAME_REGEX,
+  Cl: () => Cl,
+  ClarityConversionError: () => ClarityConversionError,
+  ClarityWireType: () => ClarityWireType,
+  SIP009_ABI: () => SIP009_ABI,
+  SIP010_ABI: () => SIP010_ABI,
+  SIP013_ABI: () => SIP013_ABI,
+  SIP018_PREFIX: () => SIP018_PREFIX,
+  TRAIT_STANDARDS: () => TRAIT_STANDARDS,
+  boolCV: () => boolCV,
+  bufferCV: () => bufferCV,
+  clarityTypeFromByte: () => clarityTypeFromByte,
+  clarityValueToJS: () => clarityValueToJS,
+  clarityValueToJSUntyped: () => clarityValueToJSUntyped,
+  classifyContract: () => classifyContract,
+  contractPrincipalCV: () => contractPrincipalCV,
+  cvToBigInt: () => cvToBigInt,
+  cvToBoolean: () => cvToBoolean,
+  cvToBuffer: () => cvToBuffer,
+  cvToJSON: () => cvToJSON,
+  cvToPrincipal: () => cvToPrincipal,
+  cvToString: () => cvToString,
+  cvToValue: () => cvToValue,
+  deserializeCV: () => deserializeCV,
+  deserializeCVBytes: () => deserializeCVBytes,
+  encodeStructuredData: () => encodeStructuredData,
+  falseCV: () => falseCV,
+  hashStructuredData: () => hashStructuredData,
+  intCV: () => intCV,
+  isAbiBuffer: () => isAbiBuffer,
+  isAbiList: () => isAbiList,
+  isAbiOptional: () => isAbiOptional,
+  isAbiResponse: () => isAbiResponse,
+  isAbiStringAscii: () => isAbiStringAscii,
+  isAbiStringUtf8: () => isAbiStringUtf8,
+  isAbiTraitReference: () => isAbiTraitReference,
+  isAbiTuple: () => isAbiTuple,
+  isArray: () => isArray,
+  isBool: () => isBool,
+  isClarityValue: () => isClarityValue,
+  isContractPrincipal: () => isContractPrincipal,
+  isErrResponse: () => isErrResponse,
+  isInt128: () => isInt128,
+  isOkResponse: () => isOkResponse,
+  isOptional: () => isOptional,
+  isPrincipal: () => isPrincipal,
+  isResponse: () => isResponse,
+  isStandardPrincipal: () => isStandardPrincipal,
+  isString: () => isString,
+  isTraitReference: () => isTraitReference,
+  isUint128: () => isUint128,
+  isUint8Array: () => isUint8Array,
+  jsToClarity: () => jsToClarity,
+  jsToClarityValue: () => jsToClarityValue,
+  listCV: () => listCV,
+  noneCV: () => noneCV,
+  normalizeAbi: () => normalizeAbi,
+  normalizeAccess: () => normalizeAccess,
+  normalizeType: () => normalizeType,
+  parseDeclaredStandards: () => parseDeclaredStandards,
+  prepareArgs: () => prepareArgs,
+  prettyPrint: () => prettyPrint,
+  responseErrorCV: () => responseErrorCV,
+  responseOkCV: () => responseOkCV,
+  serializeCV: () => serializeCV,
+  serializeCVBytes: () => serializeCVBytes,
+  signStructuredData: () => signStructuredData,
+  sip009Abi: () => sip009Abi,
+  sip010Abi: () => sip010Abi,
+  sip013Abi: () => sip013Abi,
+  someCV: () => someCV,
+  standardPrincipalCV: () => standardPrincipalCV,
+  stringAsciiCV: () => stringAsciiCV,
+  stringUtf8CV: () => stringUtf8CV,
+  structuredDataHash: () => structuredDataHash,
+  toCamelCase: () => toCamelCase,
+  trueCV: () => trueCV,
+  tupleCV: () => tupleCV,
+  uintCV: () => uintCV,
+  validateArgs: () => validateArgs,
+  validateArgsArray: () => validateArgsArray
+});
+
+// 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_sha23 = require("@noble/hashes/sha2.js");
+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 jsToClarity(type, value) {
-  if (type === "none")
+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_sha23.sha256(import_sha23.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/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;
-  if (type === "uint128") {
-    if (!isUint128(value))
-      throw new ClarityConversionError("Invalid uint128 value", type, value);
-    return value;
+  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 (type === "int128") {
-    if (!isInt128(value))
-      throw new ClarityConversionError("Invalid int128 value", type, value);
-    return value;
+  if (!isClarityName(contractName)) {
+    throw new Error(`Invalid contract name: ${contractName}`);
   }
-  if (type === "bool") {
-    if (!isBool(value))
-      throw new ClarityConversionError("Invalid bool value", type, value);
-    return value;
+  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;
   }
-  if (type === "principal") {
-    if (!isPrincipal(value))
-      throw new ClarityConversionError("Invalid principal value", type, value);
-    return value;
+  readBigUInt64BE() {
+    const hex = bytesToHex(this.readBytes(8));
+    return hex.length > 0 ? BigInt(`0x${hex}`) : 0n;
   }
-  if (type === "trait_reference") {
-    if (!isPrincipal(value))
-      throw new ClarityConversionError("Invalid trait_reference value", type, value);
-    return value;
+}
+
+// src/clarity/deserialize.ts
+function readAddress(reader) {
+  const version = reader.readUInt8();
+  const hash160 = bytesToHex(reader.readBytes(20));
+  return c32address(version, hash160);
+}
+function readLPString(reader, prefixBytes = 1) {
+  let length = 0;
+  for (let i = 0;i < prefixBytes; i++) {
+    length = length << 8 | reader.readUInt8();
   }
-  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;
+  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`);
   }
-  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;
+}
+function readCV(reader, depth = 0) {
+  if (depth > MAX_CV_DEPTH) {
+    throw new SerializationError(`Clarity value nests deeper than ${MAX_CV_DEPTH} levels`);
   }
-  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);
+  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));
     }
-    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);
+    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);
     }
-    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);
+    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));
       }
-      const fieldValue = hasOriginal ? value[field.name] : value[camelKey];
-      result[field.name] = jsToClarity(field.type, fieldValue);
+      return listCV(items);
     }
-    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)
-      };
+    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);
     }
-    if (hasErr && !hasOk) {
-      return {
-        err: jsToClarity(type.response.error, value.err)
-      };
+    case "ascii": {
+      const len = reader.readUInt32BE();
+      return stringAsciiCV(bytesToAscii(reader.readBytes(len)));
     }
-    throw new ClarityConversionError("Response must have exactly 'ok' or 'err' property", type, value);
+    case "utf8": {
+      const len = reader.readUInt32BE();
+      return stringUtf8CV(bytesToUtf8(reader.readBytes(len)));
+    }
+    default:
+      throw new SerializationError(`Cannot deserialize unknown clarity type: ${type}`);
   }
-  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 deserializeCVBytes(input) {
+  const bytes = typeof input === "string" ? hexToBytes(without0x(input)) : input;
+  return readCV(new BytesReader(bytes));
 }
-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 deserializeCV(input) {
+  return deserializeCVBytes(input);
 }
-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/serialize.ts
+var CLARITY_INT_SIZE = 128n;
+var CLARITY_INT_BYTE_SIZE = 16;
+function typeIdByte(type) {
+  return ClarityWireType[type];
 }
-// 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"
-        }
-      }
+function withTypeId(type, bytes) {
+  return concatBytes(new Uint8Array([typeIdByte(type)]), bytes);
+}
+function serializeAddress(c32Address) {
+  const [version, hash160] = c32addressDecode(c32Address);
+  return concatBytes(new Uint8Array([version]), hexToBytes(hash160));
+}
+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);
     }
-  ],
-  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"
-        }
+    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));
     }
-  ],
-  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"
-        }
+    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));
     }
-  ],
-  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"
-    ])
+    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 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;
+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 true;
+  return { type: "buffer", value: bytesToHex(buffer) };
 }
-function classifyContract(abi) {
-  if (!abi || !Array.isArray(abi.functions))
-    return [];
-  return STANDARDS.filter((s) => conformsTo(abi, s)).map((s) => s.id);
+function standardPrincipalCV(address) {
+  const [version, hash160] = c32addressDecode(address);
+  const normalized = c32address(version, hash160);
+  return { type: "address", value: normalized };
 }
-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");
+function contractPrincipalCV(address, contractName) {
+  const [version, hash160] = c32addressDecode(address);
+  const normalized = c32address(version, hash160);
+  if (utf8ToBytes(contractName).byteLength >= 128) {
+    throw new Error("Contract name must be less than 128 bytes");
   }
-  return [...out];
+  return { type: "contract", value: `${normalized}.${contractName}` };
 }
-// src/clarity/abi/normalize.ts
-function normalizeAccess(access) {
-  if (access === "read_only")
-    return "read-only";
-  return access;
+function noneCV() {
+  return { type: "none" };
 }
-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;
+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`);
     }
   }
-  if (typeof type !== "object" || type === null) {
-    throw new Error(`Invalid ABI type: expected object, got ${typeof type}`);
+  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 }");
   }
-  const typeObj = type;
-  if ("buffer" in typeObj) {
-    const buffer = typeObj.buffer;
-    return {
-      buff: {
-        length: buffer?.length ?? 32
-      }
-    };
+  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}`);
   }
-  if ("buff" in typeObj) {
-    const buff = typeObj.buff;
-    return {
-      buff: {
-        length: buff?.length ?? 32
+  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}"`;
   }
-  if ("string-ascii" in typeObj) {
-    const strAscii = typeObj["string-ascii"];
-    return {
-      "string-ascii": {
-        length: strAscii?.length ?? 256
+}
+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
+      };
   }
-  if ("string-utf8" in typeObj) {
-    const strUtf8 = typeObj["string-utf8"];
-    return {
-      "string-utf8": {
-        length: strUtf8?.length ?? 256
+}
+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;
   }
-  if ("response" in typeObj) {
-    const response = typeObj.response;
-    return {
-      response: {
-        ok: normalizeType(response?.ok ?? "bool"),
-        error: normalizeType(response?.error ?? "uint128")
-      }
-    };
+}
+function cvToBigInt(val) {
+  if (val.type !== "int" && val.type !== "uint") {
+    throw new Error(`cvToBigInt: expected int or uint, got ${val.type}`);
   }
-  if ("optional" in typeObj) {
-    return {
-      optional: normalizeType(typeObj.optional)
-    };
+  return val.value;
+}
+function cvToString(val) {
+  if (val.type !== "ascii" && val.type !== "utf8") {
+    throw new Error(`cvToString: expected ascii or utf8, got ${val.type}`);
   }
-  if ("list" in typeObj) {
-    const list = typeObj.list;
-    return {
-      list: {
-        type: normalizeType(list?.type ?? "uint128"),
-        length: list?.length ?? 100
-      }
-    };
+  return val.value;
+}
+function cvToBuffer(val) {
+  if (val.type !== "buffer") {
+    throw new Error(`cvToBuffer: expected buffer, got ${val.type}`);
   }
-  if ("tuple" in typeObj) {
-    const tuple = typeObj.tuple;
-    return {
-      tuple: tuple.map((field) => ({
-        name: field.name,
-        type: normalizeType(field.type)
-      }))
-    };
+  return val.value;
+}
+function cvToBoolean(val) {
+  if (val.type !== "true" && val.type !== "false") {
+    throw new Error(`cvToBoolean: expected bool, got ${val.type}`);
   }
-  throw new Error(`Unknown ABI type structure: ${JSON.stringify(type)}`);
+  return val.type === "true";
 }
-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 cvToPrincipal(val) {
+  if (val.type !== "address" && val.type !== "contract") {
+    throw new Error(`cvToPrincipal: expected principal or contract, got ${val.type}`);
+  }
+  return val.value;
 }
-function normalizeMap(map) {
-  return {
-    name: map.name,
-    key: normalizeType(map.key),
-    value: normalizeType(map.value)
-  };
+// src/clarity/abi/guards.ts
+function isUint128(value) {
+  return typeof value === "bigint" && value >= 0n && value <= MAX_U128;
 }
-function normalizeVariable(variable) {
-  return {
-    name: variable.name,
-    type: normalizeType(variable.type),
-    access: variable.access
-  };
+function isInt128(value) {
+  return typeof value === "bigint" && value >= MIN_I128 && value <= MAX_I128;
 }
-function normalizeFungibleToken(token) {
-  return { name: token.name };
+function isBool(value) {
+  return typeof value === "boolean";
 }
-function normalizeNonFungibleToken(token) {
-  return { name: token.name, type: normalizeType(token.type) };
+function isPrincipal(value) {
+  return typeof value === "string" && parsePrincipal(value) !== null;
 }
-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);
+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;
   }
-  return { name: trait.name, functions };
-}
-function normalizeAbi(abi) {
-  if (typeof abi !== "object" || abi === null) {
-    return { functions: [] };
+  if (type === "principal") {
+    if (!isPrincipal(value))
+      throw new ClarityConversionError("Invalid principal value", type, value);
+    return value;
   }
-  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 (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 (Array.isArray(abiObj.maps)) {
-    for (const map of abiObj.maps) {
-      if (typeof map === "object" && map !== null) {
-        maps.push(normalizeMap(map));
-      }
+  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 (Array.isArray(abiObj.variables)) {
-    for (const variable of abiObj.variables) {
-      if (typeof variable === "object" && variable !== null) {
-        variables.push(normalizeVariable(variable));
-      }
+  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 (Array.isArray(abiObj.fungible_tokens)) {
-    for (const token of abiObj.fungible_tokens) {
-      if (typeof token === "object" && token !== null) {
-        fungibleTokens.push(normalizeFungibleToken(token));
-      }
+  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 (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 (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 (Array.isArray(abiObj.implemented_traits)) {
-    for (const trait of abiObj.implemented_traits) {
-      if (typeof trait === "string")
-        implementedTraits.push(trait);
+  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);
   }
-  if (Array.isArray(abiObj.defined_traits)) {
-    for (const trait of abiObj.defined_traits) {
-      if (typeof trait === "object" && trait !== null) {
-        definedTraits.push(normalizeTraitDefinition(trait));
-      }
+  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]);
   }
-  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;
+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]);
+  });
 }
-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);
+// 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"
+        }
+      }
     }
-    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}`);
+  ],
+  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"
+        }
       }
-      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));
+  ],
+  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"
+    ])
   }
-  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");
+];
+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;
   }
-  throw new Error(`Unknown ABI type: ${JSON.stringify(abiType)}`);
+  return true;
 }
-function clarityValueToJS(abiType, cv) {
-  return clarityValueToJSInner(abiType, cv);
+function classifyContract(abi) {
+  if (!abi || !Array.isArray(abi.functions))
+    return [];
+  return STANDARDS.filter((s) => conformsTo(abi, s)).map((s) => s.id);
 }
-function clarityValueToJSUntyped(abiType, cv) {
-  return clarityValueToJSInner(abiType, cv);
+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];
 }
-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;
+// 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 (abiType === "bool") {
-    if (cv.type === "true")
-      return true;
-    if (cv.type === "false")
-      return false;
-    throw new Error(`Expected bool CV, got ${cv.type}`);
+  if (typeof type !== "object" || type === null) {
+    throw new Error(`Invalid ABI type: expected object, got ${typeof 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;
+  const typeObj = type;
+  if ("buffer" in typeObj) {
+    const buffer = typeObj.buffer;
+    return {
+      buff: {
+        length: buffer?.length ?? 32
+      }
+    };
   }
-  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 ("buff" in typeObj) {
+    const buff = typeObj.buff;
+    return {
+      buff: {
+        length: buff?.length ?? 32
+      }
+    };
   }
-  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 ("string-ascii" in typeObj) {
+    const strAscii = typeObj["string-ascii"];
+    return {
+      "string-ascii": {
+        length: strAscii?.length ?? 256
+      }
+    };
   }
-  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 ("string-utf8" in typeObj) {
+    const strUtf8 = typeObj["string-utf8"];
+    return {
+      "string-utf8": {
+        length: strUtf8?.length ?? 256
+      }
+    };
   }
-  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 ("response" in typeObj) {
+    const response = typeObj.response;
+    return {
+      response: {
+        ok: normalizeType(response?.ok ?? "bool"),
+        error: normalizeType(response?.error ?? "uint128")
+      }
+    };
   }
-  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 ("optional" in typeObj) {
+    return {
+      optional: normalizeType(typeObj.optional)
+    };
   }
-  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}`);
+  if ("list" in typeObj) {
+    const list = typeObj.list;
+    return {
+      list: {
+        type: normalizeType(list?.type ?? "uint128"),
+        length: list?.length ?? 100
+      }
+    };
   }
-  throw new Error(`Unknown ABI type: ${JSON.stringify(abiType)}`);
+  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)}`);
 }
-// src/bitcoin/index.ts
-var exports_bitcoin = {};
-__export(exports_bitcoin, {
-  verifyBitcoinPayment: () => verifyBitcoinPayment,
-  taprootTweakPubkey: () => taprootTweakPubkey,
-  stripWitness: () => stripWitness,
-  spvAdapterPrincipal: () => spvAdapterPrincipal,
-  rootFromProof: () => rootFromProof,
-  reverseBytes: () => reverseBytes,
-  publicKeyToP2wpkhAddress: () => publicKeyToP2wpkhAddress,
-  publicKeyToP2trAddress: () => publicKeyToP2trAddress,
-  parseOutputScript: () => parseOutputScript,
-  parseBlockHeader: () => parseBlockHeader,
-  parseBitcoinTx: () => parseBitcoinTx,
-  merkleRoot: () => merkleRoot,
-  isClarity6Active: () => isClarity6Active,
-  getSpvAdapter: () => getSpvAdapter,
-  getBurnBlockHeight: () => getBurnBlockHeight,
-  formatBitcoinAddress: () => formatBitcoinAddress,
-  fallbackProofSource: () => fallbackProofSource,
-  esploraSource: () => esploraSource,
-  encodeMerkleProofArgs: () => encodeMerkleProofArgs,
-  doubleSha256: () => doubleSha256,
-  decodeTxOutput: () => decodeTxOutput,
-  buildTxProof: () => buildTxProof,
-  buildMerkleProof: () => buildMerkleProof,
-  blockHash: () => blockHash,
-  bitcoinVerifier: () => bitcoinVerifier,
-  bitcoinTxid: () => bitcoinTxid,
-  bitcoinRpcSource: () => bitcoinRpcSource,
-  SPV_ADAPTER_CONTRACTS: () => SPV_ADAPTER_CONTRACTS,
-  SPV_ADAPTER_ABI: () => SPV_ADAPTER_ABI,
-  EPOCH_4_ACTIVATION_BURN_HEIGHT_MAINNET: () => EPOCH_4_ACTIVATION_BURN_HEIGHT_MAINNET,
-  BtcReader: () => BtcReader
-});
-module.exports = __toCommonJS(exports_bitcoin);
-
-// src/bitcoin/serialize.ts
-function doubleSha256(bytes) {
-  return import_sha22.sha256(import_sha22.sha256(bytes));
+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 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;
+function normalizeMap(map) {
+  return {
+    name: map.name,
+    key: normalizeType(map.key),
+    value: normalizeType(map.value)
+  };
 }
-
-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;
+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);
   }
-  readUInt64LE() {
-    const v = this.view.getBigUint64(this.offset, true);
-    this.offset += 8;
-    return v;
+  return { name: trait.name, functions };
+}
+function normalizeAbi(abi) {
+  if (typeof abi !== "object" || abi === null) {
+    return { functions: [] };
   }
-  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 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));
+      }
     }
-    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();
+  if (Array.isArray(abiObj.maps)) {
+    for (const map of abiObj.maps) {
+      if (typeof map === "object" && map !== null) {
+        maps.push(normalizeMap(map));
+      }
     }
-    const big = this.readUInt64LE();
-    if (big > BigInt(Number.MAX_SAFE_INTEGER)) {
-      throw new Error("Bitcoin varint exceeds safe integer range");
+  }
+  if (Array.isArray(abiObj.variables)) {
+    for (const variable of abiObj.variables) {
+      if (typeof variable === "object" && variable !== null) {
+        variables.push(normalizeVariable(variable));
+      }
     }
-    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)}`);
+  if (Array.isArray(abiObj.fungible_tokens)) {
+    for (const token of abiObj.fungible_tokens) {
+      if (typeof token === "object" && token !== null) {
+        fungibleTokens.push(normalizeFungibleToken(token));
+      }
     }
-    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 });
+  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));
+      }
+    }
   }
-  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 });
+  if (Array.isArray(abiObj.implemented_traits)) {
+    for (const trait of abiObj.implemented_traits) {
+      if (typeof trait === "string")
+        implementedTraits.push(trait);
+    }
   }
-  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());
+  if (Array.isArray(abiObj.defined_traits)) {
+    for (const trait of abiObj.defined_traits) {
+      if (typeof trait === "object" && trait !== null) {
+        definedTraits.push(normalizeTraitDefinition(trait));
       }
     }
   }
-  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)
+    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
   };
 }
-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;
+// 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;
 }
-function merkleRoot(txidsInternal) {
-  if (txidsInternal.length === 0) {
-    throw new Error("merkleRoot: empty tx list");
+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)}`);
   }
-  let level = txidsInternal.slice();
-  while (level.length > 1) {
-    level = nextLevel(level);
+  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);
   }
-  const root = level[0];
-  if (root === undefined)
-    throw new Error("merkleRoot: no root");
-  return root;
+  throw new Error("buffer arg expects Uint8Array, hex string, { type, value }, or BufferCV");
 }
-function buildMerkleProof(txidsInternal, txIndex) {
-  const txCount = txidsInternal.length;
-  if (txCount === 0) {
-    throw new Error("buildMerkleProof: empty tx list");
+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 (txIndex < 0 || txIndex >= txCount) {
-    throw new Error(`buildMerkleProof: txIndex ${txIndex} out of range for ${txCount} txs`);
+  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);
   }
-  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);
+  if (isAbiOptional(abiType)) {
+    if (value === null || value === undefined)
+      return noneCV();
+    return someCV(jsToClarityValue(abiType.optional, value));
   }
-  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);
+  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");
   }
-  return hash;
+  throw new Error(`Unknown ABI type: ${JSON.stringify(abiType)}`);
 }
-
-// src/bitcoin/proof.ts
-function normalizeTxid(txid) {
-  return without0x(txid).toLowerCase();
+function clarityValueToJS(abiType, cv) {
+  return clarityValueToJSInner(abiType, cv);
 }
-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
-  };
+function clarityValueToJSUntyped(abiType, cv) {
+  return clarityValueToJSInner(abiType, cv);
 }
-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}`);
+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;
   }
-  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}`);
+  if (abiType === "bool") {
+    if (cv.type === "true")
+      return true;
+    if (cv.type === "false")
+      return false;
+    throw new Error(`Expected bool CV, got ${cv.type}`);
   }
-  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");
+  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;
   }
-  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");
+  if (isAbiStringAscii(abiType) || isAbiStringUtf8(abiType)) {
+    if (cv.type !== "ascii" && cv.type !== "utf8")
+      throw new Error(`Expected string CV, got ${cv.type}`);
+    return cv.value;
   }
-  async function firstSuccess(fn) {
-    let lastError;
-    for (const source of sources) {
-      try {
-        return await fn(source);
-      } catch (error) {
-        lastError = error;
-      }
+  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);
     }
-    throw lastError;
+    return bytes;
   }
-  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;
+  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));
   }
-  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}`);
+  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 res;
+    return result;
   }
-  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
-      });
-    }
-  };
+  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/codec.ts
 function merkleDepth(txCount) {
@@ -2799,5 +2798,5 @@ async function verifyBitcoinPayment(client, params) {
   return { verified, mined, output, proof };
 }
 
-//# debugId=DE7406CAE6FEF1BF64756E2164756E21
+//# debugId=A75A612053B8AE0464756E2164756E21
 //# sourceMappingURL=index.cjs.map