@secondlayer/stacks 0.0.1

package/dist/shared/stacks-b008c3w8.cjs

@@ -0,0 +1,214 @@
+// src/clarity/deserialize.ts
+class BytesReader {
+  data;
+  offset = 0;
+  constructor(data) {
+    this.data = data;
+  }
+  readUInt8() {
+    const value = this.data[this.offset];
+    this.offset += 1;
+    return value;
+  }
+  readUInt32BE() {
+    const value = (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 value;
+  }
+  readBytes(length) {
+    const slice = this.data.slice(this.offset, this.offset + length);
+    this.offset += length;
+    return slice;
+  }
+}
+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();
+  }
+  return bytesToUtf8(reader.readBytes(length));
+}
+function readCV(reader) {
+  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));
+    case "ok":
+      return responseOkCV(readCV(reader));
+    case "err":
+      return responseErrorCV(readCV(reader));
+    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();
+      const items = [];
+      for (let i = 0;i < len; i++) {
+        items.push(readCV(reader));
+      }
+      return listCV(items);
+    }
+    case "tuple": {
+      const len = reader.readUInt32BE();
+      const data = {};
+      for (let i = 0;i < len; i++) {
+        const key = readLPString(reader);
+        data[key] = readCV(reader);
+      }
+      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 Error(`Cannot deserialize unknown clarity type: ${type}`);
+  }
+}
+function deserializeCVBytes(input) {
+  const bytes = typeof input === "string" ? hexToBytes(without0x(input)) : input;
+  return readCV(new BytesReader(bytes));
+}
+function deserializeCV(input) {
+  return deserializeCVBytes(input);
+}
+
+// src/clarity/values.ts
+var MAX_U128 = BigInt("0xffffffffffffffffffffffffffffffff");
+var MIN_I128 = BigInt("-170141183460469231731687303715884105728");
+var MAX_I128 = BigInt("0x7fffffffffffffffffffffffffffffff");
+function intCV(value) {
+  if (typeof value === "string" && value.toLowerCase().startsWith("0x")) {
+    value = bytesToTwosBigInt(hexToBytes(value));
+  }
+  if (value instanceof Uint8Array)
+    value = bytesToTwosBigInt(value);
+  const n = intToBigInt(value);
+  if (n > MAX_I128)
+    throw new RangeError(`Int exceeds max i128: ${MAX_I128}`);
+  if (n < MIN_I128)
+    throw new RangeError(`Int below min i128: ${MIN_I128}`);
+  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_U128)
+    throw new RangeError(`UInt exceeds max u128: ${MAX_U128}`);
+  return { type: "uint", value: n };
+}
+var trueCV = () => ({ type: "true" });
+var falseCV = () => ({ type: "false" });
+var boolCV = (v) => v ? trueCV() : falseCV();
+function bufferCV(buffer) {
+  if (buffer.byteLength > 1048576) {
+    throw new Error("Buffer exceeds max size of 1MB");
+  }
+  return { type: "buffer", value: bytesToHex(buffer) };
+}
+function standardPrincipalCV(address) {
+  const [version, hash160] = c32addressDecode(address);
+  const normalized = c32address(version, hash160);
+  return { type: "address", value: normalized };
+}
+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 { type: "contract", value: `${normalized}.${contractName}` };
+}
+function noneCV() {
+  return { type: "none" };
+}
+function someCV(value) {
+  return { type: "some", value };
+}
+function responseOkCV(value) {
+  return { type: "ok", value };
+}
+function responseErrorCV(value) {
+  return { type: "err", value };
+}
+function listCV(values) {
+  return { type: "list", value: values };
+}
+function tupleCV(data) {
+  for (const key in data) {
+    if (!isClarityName(key)) {
+      throw new Error(`"${key}" is not a valid Clarity name`);
+    }
+  }
+  return { type: "tuple", value: data };
+}
+function stringAsciiCV(value) {
+  return { type: "ascii", value };
+}
+function stringUtf8CV(value) {
+  return { type: "utf8", value };
+}
+var Cl = {
+  int: intCV,
+  uint: uintCV,
+  bool: boolCV,
+  principal(address) {
+    const [addr, name] = address.split(".");
+    if (!addr)
+      throw new Error("Invalid principal address");
+    return name ? contractPrincipalCV(addr, name) : standardPrincipalCV(addr);
+  },
+  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
+};
+
+//# debugId=9E0A409BD71E7ABA64756E2164756E21
+//# sourceMappingURL=stacks-b008c3w8.cjs.map

package/dist/shared/stacks-b008c3w8.cjs.map

@@ -0,0 +1,11 @@
+{
+  "version": 3,
+  "sources": ["../src/clarity/deserialize.ts", "../src/clarity/values.ts"],
+  "sourcesContent": [
+    "import {\n  hexToBytes,\n  bytesToHex,\n  bytesToAscii,\n  bytesToUtf8,\n  bytesToTwosBigInt,\n  without0x,\n} from \"../utils/encoding.ts\";\nimport { c32address } from \"../utils/c32.ts\";\nimport {\n  clarityTypeFromByte,\n  type ClarityValue,\n} from \"./types.ts\";\nimport {\n  intCV,\n  uintCV,\n  trueCV,\n  falseCV,\n  bufferCV,\n  noneCV,\n  someCV,\n  responseOkCV,\n  responseErrorCV,\n  standardPrincipalCV,\n  contractPrincipalCV,\n  listCV,\n  tupleCV,\n  stringAsciiCV,\n  stringUtf8CV,\n} from \"./values.ts\";\n\nclass BytesReader {\n  private data: Uint8Array;\n  private offset = 0;\n\n  constructor(data: Uint8Array) {\n    this.data = data;\n  }\n\n  readUInt8(): number {\n    const value = this.data[this.offset]!;\n    this.offset += 1;\n    return value;\n  }\n\n  readUInt32BE(): number {\n    const value =\n      ((this.data[this.offset]! << 24) |\n        (this.data[this.offset + 1]! << 16) |\n        (this.data[this.offset + 2]! << 8) |\n        this.data[this.offset + 3]!) >>>\n      0;\n    this.offset += 4;\n    return value;\n  }\n\n  readBytes(length: number): Uint8Array {\n    const slice = this.data.slice(this.offset, this.offset + length);\n    this.offset += length;\n    return slice;\n  }\n}\n\nfunction readAddress(reader: BytesReader): string {\n  const version = reader.readUInt8();\n  const hash160 = bytesToHex(reader.readBytes(20));\n  return c32address(version, hash160);\n}\n\nfunction readLPString(reader: BytesReader, prefixBytes = 1): string {\n  let length = 0;\n  for (let i = 0; i < prefixBytes; i++) {\n    length = (length << 8) | reader.readUInt8();\n  }\n  return bytesToUtf8(reader.readBytes(length));\n}\n\nfunction readCV(reader: BytesReader): ClarityValue {\n  const typeByte = reader.readUInt8();\n  const type = clarityTypeFromByte(typeByte);\n\n  switch (type) {\n    case \"int\":\n      return intCV(bytesToTwosBigInt(reader.readBytes(16)));\n\n    case \"uint\":\n      return uintCV(reader.readBytes(16));\n\n    case \"true\":\n      return trueCV();\n\n    case \"false\":\n      return falseCV();\n\n    case \"buffer\": {\n      const len = reader.readUInt32BE();\n      return bufferCV(reader.readBytes(len));\n    }\n\n    case \"none\":\n      return noneCV();\n\n    case \"some\":\n      return someCV(readCV(reader));\n\n    case \"ok\":\n      return responseOkCV(readCV(reader));\n\n    case \"err\":\n      return responseErrorCV(readCV(reader));\n\n    case \"address\":\n      return standardPrincipalCV(readAddress(reader));\n\n    case \"contract\": {\n      const addr = readAddress(reader);\n      const name = readLPString(reader);\n      return contractPrincipalCV(addr, name);\n    }\n\n    case \"list\": {\n      const len = reader.readUInt32BE();\n      const items: ClarityValue[] = [];\n      for (let i = 0; i < len; i++) {\n        items.push(readCV(reader));\n      }\n      return listCV(items);\n    }\n\n    case \"tuple\": {\n      const len = reader.readUInt32BE();\n      const data: Record<string, ClarityValue> = {};\n      for (let i = 0; i < len; i++) {\n        const key = readLPString(reader);\n        data[key] = readCV(reader);\n      }\n      return tupleCV(data);\n    }\n\n    case \"ascii\": {\n      const len = reader.readUInt32BE();\n      return stringAsciiCV(bytesToAscii(reader.readBytes(len)));\n    }\n\n    case \"utf8\": {\n      const len = reader.readUInt32BE();\n      return stringUtf8CV(bytesToUtf8(reader.readBytes(len)));\n    }\n\n    default:\n      throw new Error(`Cannot deserialize unknown clarity type: ${type}`);\n  }\n}\n\nexport function deserializeCVBytes<T extends ClarityValue = ClarityValue>(\n  input: Uint8Array | string\n): T {\n  const bytes =\n    typeof input === \"string\" ? hexToBytes(without0x(input)) : input;\n  return readCV(new BytesReader(bytes)) as T;\n}\n\nexport function deserializeCV<T extends ClarityValue = ClarityValue>(\n  input: Uint8Array | string\n): T {\n  return deserializeCVBytes(input);\n}\n",
+    "import { c32address, c32addressDecode } from \"../utils/c32.ts\";\nimport {\n  bytesToHex,\n  hexToBytes,\n  asciiToBytes,\n  utf8ToBytes,\n  intToBigInt,\n  bytesToTwosBigInt,\n  type IntegerType,\n} from \"../utils/encoding.ts\";\nimport { isClarityName } from \"../utils/address.ts\";\nimport type {\n  IntCV,\n  UIntCV,\n  BooleanCV,\n  TrueCV,\n  FalseCV,\n  BufferCV,\n  NoneCV,\n  SomeCV,\n  OptionalCV,\n  ResponseOkCV,\n  ResponseErrorCV,\n  StandardPrincipalCV,\n  ContractPrincipalCV,\n  ListCV,\n  TupleCV,\n  TupleData,\n  StringAsciiCV,\n  StringUtf8CV,\n  ClarityValue,\n} from \"./types.ts\";\nimport { serializeCVBytes } from \"./serialize.ts\";\nimport { deserializeCVBytes } from \"./deserialize.ts\";\n\nconst MAX_U128 = BigInt(\"0xffffffffffffffffffffffffffffffff\");\nconst MIN_I128 = BigInt(\"-170141183460469231731687303715884105728\");\nconst MAX_I128 = BigInt(\"0x7fffffffffffffffffffffffffffffff\");\n\n// Primitives\n\nexport function intCV(value: IntegerType): IntCV {\n  if (typeof value === \"string\" && value.toLowerCase().startsWith(\"0x\")) {\n    value = bytesToTwosBigInt(hexToBytes(value));\n  }\n  if (value instanceof Uint8Array) value = bytesToTwosBigInt(value);\n  const n = intToBigInt(value);\n  if (n > MAX_I128) throw new RangeError(`Int exceeds max i128: ${MAX_I128}`);\n  if (n < MIN_I128) throw new RangeError(`Int below min i128: ${MIN_I128}`);\n  return { type: \"int\", value: n };\n}\n\nexport function uintCV(value: IntegerType): UIntCV {\n  const n = intToBigInt(value);\n  if (n < 0n) throw new RangeError(\"Cannot construct unsigned int from negative value\");\n  if (n > MAX_U128) throw new RangeError(`UInt exceeds max u128: ${MAX_U128}`);\n  return { type: \"uint\", value: n };\n}\n\nexport const trueCV = (): TrueCV => ({ type: \"true\" });\nexport const falseCV = (): FalseCV => ({ type: \"false\" });\nexport const boolCV = (v: boolean): BooleanCV => (v ? trueCV() : falseCV());\n\nexport function bufferCV(buffer: Uint8Array): BufferCV {\n  if (buffer.byteLength > 1_048_576) {\n    throw new Error(\"Buffer exceeds max size of 1MB\");\n  }\n  return { type: \"buffer\", value: bytesToHex(buffer) };\n}\n\nexport function standardPrincipalCV(address: string): StandardPrincipalCV {\n  // Validate by decoding\n  const [version, hash160] = c32addressDecode(address);\n  const normalized = c32address(version, hash160);\n  return { type: \"address\", value: normalized };\n}\n\nexport function contractPrincipalCV(\n  address: string,\n  contractName: string\n): ContractPrincipalCV {\n  const [version, hash160] = c32addressDecode(address);\n  const normalized = c32address(version, hash160);\n  if (utf8ToBytes(contractName).byteLength >= 128) {\n    throw new Error(\"Contract name must be less than 128 bytes\");\n  }\n  return { type: \"contract\", value: `${normalized}.${contractName}` };\n}\n\nexport function noneCV(): NoneCV {\n  return { type: \"none\" };\n}\n\nexport function someCV(value: ClarityValue): SomeCV {\n  return { type: \"some\", value };\n}\n\nexport function responseOkCV(value: ClarityValue): ResponseOkCV {\n  return { type: \"ok\", value };\n}\n\nexport function responseErrorCV(value: ClarityValue): ResponseErrorCV {\n  return { type: \"err\", value };\n}\n\nexport function listCV(values: ClarityValue[]): ListCV {\n  return { type: \"list\", value: values };\n}\n\nexport function tupleCV(data: TupleData): TupleCV {\n  for (const key in data) {\n    if (!isClarityName(key)) {\n      throw new Error(`\"${key}\" is not a valid Clarity name`);\n    }\n  }\n  return { type: \"tuple\", value: data };\n}\n\nexport function stringAsciiCV(value: string): StringAsciiCV {\n  return { type: \"ascii\", value };\n}\n\nexport function stringUtf8CV(value: string): StringUtf8CV {\n  return { type: \"utf8\", value };\n}\n\n// Cl namespace — clean API\n\nexport const Cl = {\n  int: intCV,\n  uint: uintCV,\n  bool: boolCV,\n  principal(address: string): StandardPrincipalCV | ContractPrincipalCV {\n    const [addr, name] = address.split(\".\");\n    if (!addr) throw new Error(\"Invalid principal address\");\n    return name ? contractPrincipalCV(addr, name) : standardPrincipalCV(addr);\n  },\n  address(address: string) {\n    return Cl.principal(address);\n  },\n  contractPrincipal: contractPrincipalCV,\n  standardPrincipal: standardPrincipalCV,\n  buffer: bufferCV,\n  bufferFromHex: (hex: string) => bufferCV(hexToBytes(hex)),\n  bufferFromAscii: (ascii: string) => bufferCV(asciiToBytes(ascii)),\n  bufferFromUtf8: (utf8: string) => bufferCV(utf8ToBytes(utf8)),\n  none: noneCV,\n  some: someCV,\n  ok: responseOkCV,\n  error: responseErrorCV,\n  list: listCV,\n  tuple: tupleCV,\n  stringAscii: stringAsciiCV,\n  stringUtf8: stringUtf8CV,\n  serialize(value: ClarityValue): string {\n    return bytesToHex(serializeCVBytes(value));\n  },\n  deserialize: deserializeCVBytes,\n} as const;\n"
+  ],
+  "mappings": "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",
+  "debugId": "9E0A409BD71E7ABA64756E2164756E21",
+  "names": []
+}

package/dist/shared/stacks-bnvfmt7y.cjs

@@ -0,0 +1,31 @@
+var import_node_module = require("node:module");
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+//# debugId=5555BAAAF1009B9864756E2164756E21
+//# sourceMappingURL=stacks-bnvfmt7y.cjs.map

package/dist/shared/stacks-bnvfmt7y.cjs.map

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

package/dist/shared/stacks-bycy6t9k.js

@@ -0,0 +1,22 @@
+import {
+  bytesToHex
+} from "./stacks-nqytwfcc.js";
+
+// src/utils/hash.ts
+import { ripemd160 } from "@noble/hashes/legacy.js";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { sha512_256 } from "@noble/hashes/sha2.js";
+function hash160(input) {
+  return ripemd160(sha256(input));
+}
+function txidFromBytes(data) {
+  return bytesToHex(sha512_256(data));
+}
+function hashP2PKH(input) {
+  return bytesToHex(hash160(input));
+}
+
+export { ripemd160, sha256, sha512_256, hash160, txidFromBytes, hashP2PKH };
+
+//# debugId=E53549EA02A4B7DB64756E2164756E21
+//# sourceMappingURL=stacks-bycy6t9k.js.map

package/dist/shared/stacks-bycy6t9k.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/utils/hash.ts"],
+  "sourcesContent": [
+    "import { ripemd160 } from \"@noble/hashes/legacy.js\";\nimport { sha256 } from \"@noble/hashes/sha2.js\";\nimport { sha512_256 } from \"@noble/hashes/sha2.js\";\nimport { bytesToHex } from \"./encoding.ts\";\n\nexport { sha256, sha512_256, ripemd160 };\n\n/** RIPEMD160(SHA256(input)) — standard Bitcoin/Stacks address hash */\nexport function hash160(input: Uint8Array): Uint8Array {\n  return ripemd160(sha256(input));\n}\n\n/** Hash used for transaction IDs */\nexport function txidFromBytes(data: Uint8Array): string {\n  return bytesToHex(sha512_256(data));\n}\n\n/** hash160 as hex — used for P2PKH address derivation */\nexport function hashP2PKH(input: Uint8Array): string {\n  return bytesToHex(hash160(input));\n}\n"
+  ],
+  "mappings": ";;;;;AAAA;AACA;AACA;AAMO,SAAS,OAAO,CAAC,OAA+B;AAAA,EACrD,OAAO,UAAU,OAAO,KAAK,CAAC;AAAA;AAIzB,SAAS,aAAa,CAAC,MAA0B;AAAA,EACtD,OAAO,WAAW,WAAW,IAAI,CAAC;AAAA;AAI7B,SAAS,SAAS,CAAC,OAA2B;AAAA,EACnD,OAAO,WAAW,QAAQ,KAAK,CAAC;AAAA;",
+  "debugId": "E53549EA02A4B7DB64756E2164756E21",
+  "names": []
+}

package/dist/shared/stacks-d1fmkv3p.js

@@ -0,0 +1,258 @@
+import {
+  Cl,
+  boolCV,
+  bufferCV,
+  intCV,
+  listCV,
+  noneCV,
+  responseErrorCV,
+  responseOkCV,
+  someCV,
+  stringAsciiCV,
+  stringUtf8CV,
+  tupleCV,
+  uintCV
+} from "./stacks-j2cy7qtt.js";
+import {
+  MAX_I128,
+  MAX_U128,
+  MIN_I128
+} from "./stacks-v9jqcpd4.js";
+import {
+  validateStacksAddress
+} from "./stacks-gjvbq6w7.js";
+
+// src/clarity/abi/types.ts
+var CONTRACT_NAME_REGEX = /^[a-zA-Z][a-zA-Z0-9\-]{0,127}$/;
+
+// 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) {
+  if (typeof value !== "string")
+    return false;
+  const parts = value.split(".");
+  const address = parts[0];
+  const contractName = parts[1];
+  if (!validateStacksAddress(address))
+    return false;
+  if (contractName !== undefined) {
+    return CONTRACT_NAME_REGEX.test(contractName);
+  }
+  return true;
+}
+function isStandardPrincipal(value) {
+  if (typeof value !== "string")
+    return false;
+  if (value.includes("."))
+    return false;
+  return validateStacksAddress(value);
+}
+function isContractPrincipal(value) {
+  if (typeof value !== "string")
+    return false;
+  if (!value.includes("."))
+    return false;
+  const parts = value.split(".");
+  const address = parts[0];
+  const contractName = parts[1];
+  if (!validateStacksAddress(address))
+    return false;
+  return CONTRACT_NAME_REGEX.test(contractName);
+}
+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/bridge.ts
+function jsToClarityValue(abiType, 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 (isAbiBuffer(abiType))
+    return bufferCV(value);
+  if (isAbiList(abiType)) {
+    const arr = value;
+    return listCV(arr.map((item) => jsToClarityValue(abiType.list.type, item)));
+  }
+  if (isAbiTuple(abiType)) {
+    const obj = value;
+    const data = {};
+    for (const field of abiType.tuple) {
+      const camelKey = toCamelCase(field.name);
+      const hasOriginal = field.name in obj;
+      const hasCamel = camelKey in obj;
+      const fieldValue = hasOriginal ? obj[field.name] : hasCamel ? obj[camelKey] : undefined;
+      if (fieldValue === undefined && !isAbiOptional(field.type)) {
+        throw new Error(`Missing tuple field: ${field.name}`);
+      }
+      data[field.name] = jsToClarityValue(field.type, fieldValue);
+    }
+    return tupleCV(data);
+  }
+  if (isAbiOptional(abiType)) {
+    if (value === null || value === undefined)
+      return noneCV();
+    return someCV(jsToClarityValue(abiType.optional, value));
+  }
+  if (isAbiResponse(abiType)) {
+    const obj = value;
+    if ("ok" in obj && !("err" in obj))
+      return responseOkCV(jsToClarityValue(abiType.response.ok, obj.ok));
+    if ("err" in obj && !("ok" in obj))
+      return responseErrorCV(jsToClarityValue(abiType.response.error, obj.err));
+    throw new Error("Response must have exactly 'ok' or 'err' property");
+  }
+  throw new Error(`Unknown ABI type: ${JSON.stringify(abiType)}`);
+}
+function clarityValueToJS(abiType, cv) {
+  return clarityValueToJSInner(abiType, cv);
+}
+function clarityValueToJSUntyped(abiType, cv) {
+  return clarityValueToJSInner(abiType, cv);
+}
+function clarityValueToJSInner(abiType, cv) {
+  if (abiType === "uint128" || abiType === "int128") {
+    if (cv.type !== "int" && cv.type !== "uint")
+      throw new Error(`Expected int/uint CV, got ${cv.type}`);
+    return cv.value;
+  }
+  if (abiType === "bool") {
+    if (cv.type === "true")
+      return true;
+    if (cv.type === "false")
+      return false;
+    throw new Error(`Expected bool CV, got ${cv.type}`);
+  }
+  if (abiType === "principal" || abiType === "trait_reference") {
+    if (cv.type !== "address" && cv.type !== "contract")
+      throw new Error(`Expected principal CV, got ${cv.type}`);
+    return cv.value;
+  }
+  if (isAbiStringAscii(abiType) || isAbiStringUtf8(abiType)) {
+    if (cv.type !== "ascii" && cv.type !== "utf8")
+      throw new Error(`Expected string CV, got ${cv.type}`);
+    return cv.value;
+  }
+  if (isAbiBuffer(abiType)) {
+    if (cv.type !== "buffer")
+      throw new Error(`Expected buffer CV, got ${cv.type}`);
+    const hex = cv.value;
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0;i < bytes.length; i++) {
+      bytes[i] = parseInt(hex.substring(i * 2, i * 2 + 2), 16);
+    }
+    return bytes;
+  }
+  if (isAbiList(abiType)) {
+    if (cv.type !== "list")
+      throw new Error(`Expected list CV, got ${cv.type}`);
+    return cv.value.map((item) => clarityValueToJSInner(abiType.list.type, item));
+  }
+  if (isAbiTuple(abiType)) {
+    if (cv.type !== "tuple")
+      throw new Error(`Expected tuple CV, got ${cv.type}`);
+    const result = {};
+    for (const field of abiType.tuple) {
+      const fieldCV = cv.value[field.name];
+      if (!fieldCV)
+        throw new Error(`Missing tuple field in CV: ${field.name}`);
+      const camelKey = toCamelCase(field.name);
+      result[camelKey] = clarityValueToJSInner(field.type, fieldCV);
+    }
+    return result;
+  }
+  if (isAbiOptional(abiType)) {
+    if (cv.type === "none")
+      return null;
+    if (cv.type === "some")
+      return clarityValueToJSInner(abiType.optional, cv.value);
+    throw new Error(`Expected optional CV, got ${cv.type}`);
+  }
+  if (isAbiResponse(abiType)) {
+    if (cv.type === "ok")
+      return { ok: clarityValueToJSInner(abiType.response.ok, cv.value) };
+    if (cv.type === "err")
+      return { err: clarityValueToJSInner(abiType.response.error, cv.value) };
+    throw new Error(`Expected response CV, got ${cv.type}`);
+  }
+  throw new Error(`Unknown ABI type: ${JSON.stringify(abiType)}`);
+}
+
+export { CONTRACT_NAME_REGEX, isUint128, isInt128, isBool, isPrincipal, isStandardPrincipal, isContractPrincipal, isTraitReference, isString, isUint8Array, isArray, isOptional, isOkResponse, isErrResponse, isResponse, isAbiList, isAbiTuple, isAbiOptional, isAbiResponse, isAbiBuffer, isAbiStringAscii, isAbiStringUtf8, isAbiTraitReference, toCamelCase, jsToClarityValue, clarityValueToJS, clarityValueToJSUntyped };
+
+//# debugId=F8671962BA8FE8C064756E2164756E21
+//# sourceMappingURL=stacks-d1fmkv3p.js.map

package/dist/shared/stacks-d1fmkv3p.js.map

@@ -0,0 +1,13 @@
+{
+  "version": 3,
+  "sources": ["../src/clarity/abi/types.ts", "../src/clarity/abi/guards.ts", "../src/clarity/abi/utils.ts", "../src/clarity/bridge.ts"],
+  "sourcesContent": [
+    "import { MAX_U128, MAX_I128, MIN_I128 } from \"../../utils/constants.ts\";\n\nexport { MAX_U128, MAX_I128, MIN_I128 };\n\nexport const CONTRACT_NAME_REGEX: RegExp = /^[a-zA-Z][a-zA-Z0-9\\-]{0,127}$/;\n\n// Primitive types\n\nexport type AbiUInt128 = \"uint128\";\nexport type AbiInt128 = \"int128\";\nexport type AbiBool = \"bool\";\nexport type AbiPrincipal = \"principal\";\nexport type AbiTraitReference = \"trait_reference\";\nexport type AbiNone = \"none\";\n\nexport type AbiStringAscii<L extends number = number> = {\n  \"string-ascii\": { length: L };\n};\n\nexport type AbiStringUtf8<L extends number = number> = {\n  \"string-utf8\": { length: L };\n};\n\nexport type AbiBuffer<L extends number = number> = {\n  buff: { length: L };\n};\n\nexport type AbiPrimitiveType =\n  | AbiUInt128\n  | AbiInt128\n  | AbiBool\n  | AbiPrincipal\n  | AbiTraitReference\n  | AbiNone\n  | AbiStringAscii\n  | AbiStringUtf8\n  | AbiBuffer;\n\n// Composite types (interfaces for recursion)\n\nexport interface AbiListType {\n  list: { type: AbiType; length: number };\n}\n\nexport interface AbiTupleType {\n  tuple: ReadonlyArray<{ name: string; type: AbiType }>;\n}\n\nexport interface AbiOptionalType {\n  optional: AbiType;\n}\n\nexport interface AbiResponseType {\n  response: { ok: AbiType; error: AbiType };\n}\n\n/** Discriminated union of all Clarity value types (primitives, buffers, lists, tuples, optionals, responses). */\nexport type AbiType =\n  | AbiPrimitiveType\n  | AbiListType\n  | AbiTupleType\n  | AbiOptionalType\n  | AbiResponseType;\n\n// Generic versions for better type inference\n\nexport type AbiList<\n  T extends AbiType = AbiType,\n  L extends number = number,\n> = {\n  list: { type: T; length: L };\n};\n\nexport type AbiTuple<\n  T extends ReadonlyArray<{ name: string; type: AbiType }>,\n> = {\n  tuple: T;\n};\n\nexport type AbiOptional<T extends AbiType = AbiType> = {\n  optional: T;\n};\n\nexport type AbiResponse<\n  O extends AbiType = AbiType,\n  E extends AbiType = AbiType,\n> = {\n  response: { ok: O; error: E };\n};\n",
+    "import { validateStacksAddress } from \"../../utils/address.ts\";\nimport { MAX_U128, MIN_I128, MAX_I128, CONTRACT_NAME_REGEX } from \"./types.ts\";\nimport type { ResponseOk, ResponseErr } from \"./mappings.ts\";\nimport type {\n  AbiType,\n  AbiListType,\n  AbiTupleType,\n  AbiOptionalType,\n  AbiResponseType,\n  AbiBuffer,\n  AbiStringAscii,\n  AbiStringUtf8,\n  AbiTraitReference,\n} from \"./types.ts\";\n\n// Value guards\n\nexport function isUint128(value: unknown): value is bigint {\n  return typeof value === \"bigint\" && value >= 0n && value <= MAX_U128;\n}\n\nexport function isInt128(value: unknown): value is bigint {\n  return typeof value === \"bigint\" && value >= MIN_I128 && value <= MAX_I128;\n}\n\nexport function isBool(value: unknown): value is boolean {\n  return typeof value === \"boolean\";\n}\n\nexport function isPrincipal(value: unknown): value is string {\n  if (typeof value !== \"string\") return false;\n  const parts = value.split(\".\");\n  const address = parts[0]!;\n  const contractName = parts[1];\n  if (!validateStacksAddress(address)) return false;\n  if (contractName !== undefined) {\n    return CONTRACT_NAME_REGEX.test(contractName);\n  }\n  return true;\n}\n\nexport function isStandardPrincipal(value: unknown): value is string {\n  if (typeof value !== \"string\") return false;\n  if (value.includes(\".\")) return false;\n  return validateStacksAddress(value);\n}\n\nexport function isContractPrincipal(value: unknown): value is string {\n  if (typeof value !== \"string\") return false;\n  if (!value.includes(\".\")) return false;\n  const parts = value.split(\".\");\n  const address = parts[0]!;\n  const contractName = parts[1]!;\n  if (!validateStacksAddress(address)) return false;\n  return CONTRACT_NAME_REGEX.test(contractName);\n}\n\nexport function isTraitReference(value: unknown): value is string {\n  return isContractPrincipal(value);\n}\n\nexport function isString(value: unknown): value is string {\n  return typeof value === \"string\";\n}\n\nexport function isUint8Array(value: unknown): value is Uint8Array {\n  return value instanceof Uint8Array;\n}\n\nexport function isArray<T>(\n  value: unknown,\n  itemGuard: (item: unknown) => item is T,\n): value is T[] {\n  return Array.isArray(value) && value.every(itemGuard);\n}\n\nexport function isOptional<T>(\n  value: unknown,\n  guard: (val: unknown) => val is T,\n): value is T | null {\n  return value === null || guard(value);\n}\n\nexport function isOkResponse<T>(\n  response: { ok: T } | { err: any },\n): response is ResponseOk<T> {\n  return \"ok\" in response && !(\"err\" in response);\n}\n\nexport function isErrResponse<E>(\n  response: { ok: any } | { err: E },\n): response is ResponseErr<E> {\n  return \"err\" in response && !(\"ok\" in response);\n}\n\nexport function isResponse<T, E>(\n  value: unknown,\n  okGuard: (val: unknown) => val is T,\n  errGuard: (val: unknown) => val is E,\n): value is ResponseOk<T> | ResponseErr<E> {\n  if (typeof value !== \"object\" || value === null) return false;\n  const obj = value as Record<string, unknown>;\n  if (\"ok\" in value && !(\"err\" in value)) return okGuard(obj.ok);\n  if (\"err\" in value && !(\"ok\" in value)) return errGuard(obj.err);\n  return false;\n}\n\n// ABI type definition guards\n\nexport function isAbiList(type: AbiType): type is AbiListType {\n  return typeof type === \"object\" && type !== null && \"list\" in type;\n}\n\nexport function isAbiTuple(type: AbiType): type is AbiTupleType {\n  return typeof type === \"object\" && type !== null && \"tuple\" in type;\n}\n\nexport function isAbiOptional(type: AbiType): type is AbiOptionalType {\n  return typeof type === \"object\" && type !== null && \"optional\" in type;\n}\n\nexport function isAbiResponse(type: AbiType): type is AbiResponseType {\n  return typeof type === \"object\" && type !== null && \"response\" in type;\n}\n\nexport function isAbiBuffer(type: AbiType): type is AbiBuffer {\n  return typeof type === \"object\" && type !== null && \"buff\" in type;\n}\n\nexport function isAbiStringAscii(type: AbiType): type is AbiStringAscii {\n  return typeof type === \"object\" && type !== null && \"string-ascii\" in type;\n}\n\nexport function isAbiStringUtf8(type: AbiType): type is AbiStringUtf8 {\n  return typeof type === \"object\" && type !== null && \"string-utf8\" in type;\n}\n\nexport function isAbiTraitReference(type: AbiType): type is AbiTraitReference {\n  return type === \"trait_reference\";\n}\n",
+    "type CamelCaseInner<S extends string> =\n  S extends `${infer P1}-${infer P2}${infer P3}`\n    ? `${P1}${Capitalize<CamelCaseInner<`${P2}${P3}`>>}`\n    : S;\n\nexport type ToCamelCase<S extends string> =\n  CamelCaseInner<S> extends `${number}${string}`\n    ? `_${CamelCaseInner<S>}`\n    : CamelCaseInner<S>;\n\nexport function toCamelCase(str: string): string {\n  return str\n    .replace(/-([a-z])/g, (_, letter) => letter.toUpperCase())\n    .replace(/-([A-Z])/g, (_, letter) => letter)\n    .replace(/-(\\d)/g, (_, digit) => digit)\n    .replace(/-/g, \"\")\n    .replace(/^\\d/, \"_$&\");\n}\n",
+    "import type { AbiType } from \"./abi/types.ts\";\nimport type { AbiToTS } from \"./abi/mappings.ts\";\nimport {\n  isAbiList,\n  isAbiTuple,\n  isAbiOptional,\n  isAbiResponse,\n  isAbiBuffer,\n  isAbiStringAscii,\n  isAbiStringUtf8,\n} from \"./abi/guards.ts\";\nimport { toCamelCase } from \"./abi/utils.ts\";\nimport type { ClarityValue } from \"./types.ts\";\nimport {\n  intCV,\n  uintCV,\n  boolCV,\n  bufferCV,\n  noneCV,\n  someCV,\n  responseOkCV,\n  responseErrorCV,\n  listCV,\n  tupleCV,\n  stringAsciiCV,\n  stringUtf8CV,\n} from \"./values.ts\";\nimport { Cl } from \"./values.ts\";\n\n/**\n * Convert a JS value to a ClarityValue using ABI type information.\n */\nexport function jsToClarityValue(abiType: AbiType, value: unknown): ClarityValue {\n  if (abiType === \"uint128\") return uintCV(value as bigint | number);\n  if (abiType === \"int128\") return intCV(value as bigint | number);\n  if (abiType === \"bool\") return boolCV(value as boolean);\n  if (abiType === \"principal\" || abiType === \"trait_reference\")\n    return Cl.principal(value as string);\n\n  if (isAbiStringAscii(abiType)) return stringAsciiCV(value as string);\n  if (isAbiStringUtf8(abiType)) return stringUtf8CV(value as string);\n  if (isAbiBuffer(abiType)) return bufferCV(value as Uint8Array);\n\n  if (isAbiList(abiType)) {\n    const arr = value as unknown[];\n    return listCV(arr.map((item) => jsToClarityValue(abiType.list.type, item)));\n  }\n\n  if (isAbiTuple(abiType)) {\n    const obj = value as Record<string, unknown>;\n    const data: Record<string, ClarityValue> = {};\n    for (const field of abiType.tuple) {\n      const camelKey = toCamelCase(field.name);\n      const hasOriginal = field.name in obj;\n      const hasCamel = camelKey in obj;\n      const fieldValue = hasOriginal ? obj[field.name] : hasCamel ? obj[camelKey] : undefined;\n      if (fieldValue === undefined && !isAbiOptional(field.type)) {\n        throw new Error(`Missing tuple field: ${field.name}`);\n      }\n      data[field.name] = jsToClarityValue(field.type, fieldValue);\n    }\n    return tupleCV(data);\n  }\n\n  if (isAbiOptional(abiType)) {\n    if (value === null || value === undefined) return noneCV();\n    return someCV(jsToClarityValue(abiType.optional, value));\n  }\n\n  if (isAbiResponse(abiType)) {\n    const obj = value as Record<string, unknown>;\n    if (\"ok\" in obj && !(\"err\" in obj))\n      return responseOkCV(jsToClarityValue(abiType.response.ok, obj.ok));\n    if (\"err\" in obj && !(\"ok\" in obj))\n      return responseErrorCV(jsToClarityValue(abiType.response.error, obj.err));\n    throw new Error(\"Response must have exactly 'ok' or 'err' property\");\n  }\n\n  throw new Error(`Unknown ABI type: ${JSON.stringify(abiType)}`);\n}\n\n/**\n * Convert a ClarityValue back to a typed JS value using ABI type information.\n */\nexport function clarityValueToJS<T extends AbiType>(\n  abiType: T,\n  cv: ClarityValue,\n): AbiToTS<T> {\n  return clarityValueToJSInner(abiType, cv) as AbiToTS<T>;\n}\n\n/** Non-generic version for internal use — avoids deep type instantiation. */\nexport function clarityValueToJSUntyped(abiType: AbiType, cv: ClarityValue): unknown {\n  return clarityValueToJSInner(abiType, cv);\n}\n\nfunction clarityValueToJSInner(abiType: AbiType, cv: ClarityValue): unknown {\n  if (abiType === \"uint128\" || abiType === \"int128\") {\n    if (cv.type !== \"int\" && cv.type !== \"uint\")\n      throw new Error(`Expected int/uint CV, got ${cv.type}`);\n    return cv.value;\n  }\n\n  if (abiType === \"bool\") {\n    if (cv.type === \"true\") return true;\n    if (cv.type === \"false\") return false;\n    throw new Error(`Expected bool CV, got ${cv.type}`);\n  }\n\n  if (abiType === \"principal\" || abiType === \"trait_reference\") {\n    if (cv.type !== \"address\" && cv.type !== \"contract\")\n      throw new Error(`Expected principal CV, got ${cv.type}`);\n    return cv.value;\n  }\n\n  if (isAbiStringAscii(abiType) || isAbiStringUtf8(abiType)) {\n    if (cv.type !== \"ascii\" && cv.type !== \"utf8\")\n      throw new Error(`Expected string CV, got ${cv.type}`);\n    return cv.value;\n  }\n\n  if (isAbiBuffer(abiType)) {\n    if (cv.type !== \"buffer\") throw new Error(`Expected buffer CV, got ${cv.type}`);\n    // BufferCV stores hex string; convert back to Uint8Array\n    const hex = cv.value;\n    const bytes = new Uint8Array(hex.length / 2);\n    for (let i = 0; i < bytes.length; i++) {\n      bytes[i] = parseInt(hex.substring(i * 2, i * 2 + 2), 16);\n    }\n    return bytes;\n  }\n\n  if (isAbiList(abiType)) {\n    if (cv.type !== \"list\") throw new Error(`Expected list CV, got ${cv.type}`);\n    return cv.value.map((item) => clarityValueToJSInner(abiType.list.type, item));\n  }\n\n  if (isAbiTuple(abiType)) {\n    if (cv.type !== \"tuple\") throw new Error(`Expected tuple CV, got ${cv.type}`);\n    const result: Record<string, unknown> = {};\n    for (const field of abiType.tuple) {\n      const fieldCV = cv.value[field.name];\n      if (!fieldCV) throw new Error(`Missing tuple field in CV: ${field.name}`);\n      const camelKey = toCamelCase(field.name);\n      result[camelKey] = clarityValueToJSInner(field.type, fieldCV);\n    }\n    return result;\n  }\n\n  if (isAbiOptional(abiType)) {\n    if (cv.type === \"none\") return null;\n    if (cv.type === \"some\") return clarityValueToJSInner(abiType.optional, cv.value);\n    throw new Error(`Expected optional CV, got ${cv.type}`);\n  }\n\n  if (isAbiResponse(abiType)) {\n    if (cv.type === \"ok\") return { ok: clarityValueToJSInner(abiType.response.ok, cv.value) };\n    if (cv.type === \"err\") return { err: clarityValueToJSInner(abiType.response.error, cv.value) };\n    throw new Error(`Expected response CV, got ${cv.type}`);\n  }\n\n  throw new Error(`Unknown ABI type: ${JSON.stringify(abiType)}`);\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "F8671962BA8FE8C064756E2164756E21",
+  "names": []
+}