@secondlayer/stacks 0.0.1

package/README.md

@@ -0,0 +1,92 @@
+# @secondlayer/stacks
+
+A viem-style SDK for the Stacks blockchain. One package, zero polyfills, full tree-shaking.
+
+## Install
+
+```bash
+bun add @secondlayer/stacks
+```
+
+## Quick Start
+
+```ts
+import { createPublicClient, http } from "@secondlayer/stacks";
+import { mainnet } from "@secondlayer/stacks/chains";
+
+const client = createPublicClient({
+  chain: mainnet,
+  transport: http(),
+});
+
+const balance = await client.getBalance({
+  address: "SP2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKNRV9EJ7",
+});
+```
+
+## Exports
+
+| Module | Description |
+|---|---|
+| `@secondlayer/stacks` | Clients, transports, re-exports |
+| `@secondlayer/stacks/accounts` | `privateKeyToAccount`, `mnemonicToAccount`, wallet providers |
+| `@secondlayer/stacks/chains` | `mainnet`, `testnet`, `devnet`, `defineChain` |
+| `@secondlayer/stacks/clarity` | `Cl.*` constructors, serialization, ABI type system |
+| `@secondlayer/stacks/actions` | `readContract`, `callContract`, `transferStx`, `getContract`, `multicall` |
+| `@secondlayer/stacks/transactions` | Build, sign, serialize transactions, multi-sig |
+| `@secondlayer/stacks/postconditions` | `Pc` fluent builder for post-conditions |
+| `@secondlayer/stacks/connect` | Wallet connection — browser extensions + `setProvider` |
+| `@secondlayer/stacks/connect/walletconnect` | WalletConnect v2 — native relay, QR, modal |
+| `@secondlayer/stacks/subscriptions` | `watchBlocks`, `watchMempool`, `watchTransaction` |
+| `@secondlayer/stacks/utils` | Encoding, hashing, addresses, unit formatting |
+| `@secondlayer/stacks/bns` | BNS name registration, resolution, zonefiles |
+| `@secondlayer/stacks/pox` | PoX stacking — solo and delegated |
+| `@secondlayer/stacks/stackingdao` | StackingDAO liquid staking (STX/stSTX) |
+
+## WalletConnect v2
+
+Native WC v2 implementation — X25519 ECDH, AES-256-GCM envelope encryption, Ed25519 JWT relay auth. Zero cost if you don't import it, tree-shakes completely.
+
+```ts
+import { connect, setProvider } from "@secondlayer/stacks/connect";
+import { WalletConnectProvider, showModal } from "@secondlayer/stacks/connect/walletconnect";
+
+const wc = new WalletConnectProvider({
+  projectId: "your-reown-project-id", // from cloud.reown.com
+  metadata: { name: "My App", description: "...", url: "https://myapp.com", icons: [] },
+});
+
+// Restore existing session or pair new one
+if (!wc.restore()) {
+  const { uri, approval } = await wc.pair();
+  showModal({ wcUri: uri, onClose: () => {} });
+  await approval;
+}
+
+setProvider(wc);
+const { addresses } = await connect();
+```
+
+The built-in modal shows browser extension wallets alongside the WC QR code — users pick whichever they prefer.
+
+## Bundle Size
+
+Measured with `bun build --minify --target=browser`, gzipped. Compared against stacks.js v7.3.1 + @stacks/connect v8.2.4.
+
+```
+                        @secondlayer/stacks    stacks.js + connect
+                        ───────────────────    ───────────────────
+SDK (gzipped)                      23.8 KB              189 KB
++ Connect                          +7.9 KB             +347 KB
++ WalletConnect v2                +25.5 KB          (included)
+                        ───────────────────    ───────────────────
+Total                              46.1 KB              536 KB  ← 11.6x
+Dependencies                             6                 294  ← 49x
+node_modules                          7 MB              351 MB  ← 50x
+Polyfills needed                      none       Buffer, crypto
+Packages to install                      1                  5+
+```
+
+6 runtime deps, all `@noble`/`@scure`: `@noble/hashes`, `@noble/secp256k1`, `@noble/curves`, `@noble/ciphers`, `@scure/bip32`, `@scure/bip39`.
+
+Connect and WalletConnect are separate entry points — import only what you use. An app that just reads contracts pays 23.8 KB. Full wallet connection + WC v2 pays 46.1 KB. The equivalent stacks.js setup is 536 KB regardless.

package/dist/shared/stacks-02actsrx.cjs

@@ -0,0 +1,17 @@
+// src/accounts/providerToAccount.ts
+async function providerToAccount(provider) {
+  const result = await provider.request("stx_getAddresses");
+  const entry = result?.addresses?.[0];
+  if (!entry?.address || !entry?.publicKey) {
+    throw new Error("Provider did not return a valid address");
+  }
+  return {
+    type: "provider",
+    address: entry.address,
+    publicKey: entry.publicKey,
+    provider
+  };
+}
+
+//# debugId=92C250F1EE7F3F3064756E2164756E21
+//# sourceMappingURL=stacks-02actsrx.cjs.map

package/dist/shared/stacks-02actsrx.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/accounts/providerToAccount.ts"],
+  "sourcesContent": [
+    "import type { StacksProvider, ProviderAccount } from \"./types.ts\";\n\n/** Create a ProviderAccount by querying the wallet for addresses */\nexport async function providerToAccount(\n  provider: StacksProvider\n): Promise<ProviderAccount> {\n  const result = await provider.request(\"stx_getAddresses\");\n\n  const entry = result?.addresses?.[0];\n  if (!entry?.address || !entry?.publicKey) {\n    throw new Error(\"Provider did not return a valid address\");\n  }\n\n  return {\n    type: \"provider\",\n    address: entry.address,\n    publicKey: entry.publicKey,\n    provider,\n  };\n}\n"
+  ],
+  "mappings": ";AAGA,eAAsB,iBAAiB,CACrC,UAC0B;AAAA,EAC1B,MAAM,SAAS,MAAM,SAAS,QAAQ,kBAAkB;AAAA,EAExD,MAAM,QAAQ,QAAQ,YAAY;AAAA,EAClC,IAAI,CAAC,OAAO,WAAW,CAAC,OAAO,WAAW;AAAA,IACxC,MAAM,IAAI,MAAM,yCAAyC;AAAA,EAC3D;AAAA,EAEA,OAAO;AAAA,IACL,MAAM;AAAA,IACN,SAAS,MAAM;AAAA,IACf,WAAW,MAAM;AAAA,IACjB;AAAA,EACF;AAAA;",
+  "debugId": "92C250F1EE7F3F3064756E2164756E21",
+  "names": []
+}

package/dist/shared/stacks-1aqm7c2h.cjs

@@ -0,0 +1,110 @@
+// 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/clarity/serialize.ts
+var CLARITY_INT_SIZE = 128n;
+var CLARITY_INT_BYTE_SIZE = 16;
+function typeIdByte(type) {
+  return ClarityWireType[type];
+}
+function withTypeId(type, bytes) {
+  return concatBytes(new Uint8Array([typeIdByte(type)]), bytes);
+}
+function serializeAddress(c32Address) {
+  const [version, 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);
+    }
+    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.localeCompare(b));
+      const parts = [writeUInt32BE(keys.length)];
+      for (const key of keys) {
+        parts.push(serializeLPString(key));
+        parts.push(serializeCVBytes(value.value[key]));
+      }
+      return withTypeId(value.type, concatBytes(...parts));
+    }
+    case "ascii": {
+      const strBytes = asciiToBytes(value.value);
+      return withTypeId(value.type, concatBytes(writeUInt32BE(strBytes.length), strBytes));
+    }
+    case "utf8": {
+      const strBytes = utf8ToBytes(value.value);
+      return withTypeId(value.type, concatBytes(writeUInt32BE(strBytes.length), strBytes));
+    }
+    default:
+      throw new Error(`Cannot serialize unknown clarity type`);
+  }
+}
+function serializeCV(value) {
+  return bytesToHex(serializeCVBytes(value));
+}
+
+//# debugId=2B3A693ED24B1BAF64756E2164756E21
+//# sourceMappingURL=stacks-1aqm7c2h.cjs.map

package/dist/shared/stacks-1aqm7c2h.cjs.map

@@ -0,0 +1,11 @@
+{
+  "version": 3,
+  "sources": ["../src/clarity/types.ts", "../src/clarity/serialize.ts"],
+  "sourcesContent": [
+    "export type ClarityType =\n  | \"int\"\n  | \"uint\"\n  | \"buffer\"\n  | \"true\"\n  | \"false\"\n  | \"address\"\n  | \"contract\"\n  | \"ok\"\n  | \"err\"\n  | \"none\"\n  | \"some\"\n  | \"list\"\n  | \"tuple\"\n  | \"ascii\"\n  | \"utf8\";\n\n/** Wire type IDs matching the Stacks binary format (SIP-005) */\nexport const ClarityWireType = {\n  int: 0x00,\n  uint: 0x01,\n  buffer: 0x02,\n  true: 0x03,\n  false: 0x04,\n  address: 0x05,\n  contract: 0x06,\n  ok: 0x07,\n  err: 0x08,\n  none: 0x09,\n  some: 0x0a,\n  list: 0x0b,\n  tuple: 0x0c,\n  ascii: 0x0d,\n  utf8: 0x0e,\n} as const satisfies Record<ClarityType, number>;\n\n/** Reverse lookup: wire byte → ClarityType string */\nconst wireTypeToClarity = Object.fromEntries(\n  Object.entries(ClarityWireType).map(([k, v]) => [v, k])\n) as Record<number, ClarityType>;\n\nexport function clarityTypeFromByte(byte: number): ClarityType {\n  const type = wireTypeToClarity[byte];\n  if (!type) throw new Error(`Unknown clarity wire type: ${byte}`);\n  return type;\n}\n\n// CV types\n\nexport type IntCV = { readonly type: \"int\"; readonly value: bigint };\nexport type UIntCV = { readonly type: \"uint\"; readonly value: bigint };\nexport type BooleanCV = TrueCV | FalseCV;\nexport type TrueCV = { readonly type: \"true\" };\nexport type FalseCV = { readonly type: \"false\" };\nexport type BufferCV = { readonly type: \"buffer\"; readonly value: string }; // hex\nexport type NoneCV = { readonly type: \"none\" };\nexport type SomeCV = {\n  readonly type: \"some\";\n  readonly value: ClarityValue;\n};\nexport type OptionalCV = NoneCV | SomeCV;\nexport type ResponseOkCV = {\n  readonly type: \"ok\";\n  readonly value: ClarityValue;\n};\nexport type ResponseErrorCV = {\n  readonly type: \"err\";\n  readonly value: ClarityValue;\n};\nexport type ResponseCV = ResponseOkCV | ResponseErrorCV;\nexport type StandardPrincipalCV = {\n  readonly type: \"address\";\n  readonly value: string;\n};\nexport type ContractPrincipalCV = {\n  readonly type: \"contract\";\n  readonly value: string; // \"address.name\"\n};\nexport type PrincipalCV = StandardPrincipalCV | ContractPrincipalCV;\nexport type ListCV = {\n  type: \"list\";\n  value: ClarityValue[];\n};\nexport type TupleData = {\n  [key: string]: ClarityValue;\n};\nexport type TupleCV = {\n  type: \"tuple\";\n  value: TupleData;\n};\nexport type StringAsciiCV = {\n  readonly type: \"ascii\";\n  readonly value: string;\n};\nexport type StringUtf8CV = {\n  readonly type: \"utf8\";\n  readonly value: string;\n};\n\nexport type ClarityValue =\n  | IntCV\n  | UIntCV\n  | BooleanCV\n  | BufferCV\n  | NoneCV\n  | SomeCV\n  | ResponseOkCV\n  | ResponseErrorCV\n  | StandardPrincipalCV\n  | ContractPrincipalCV\n  | ListCV\n  | TupleCV\n  | StringAsciiCV\n  | StringUtf8CV;\n",
+    "import {\n  bytesToHex,\n  hexToBytes,\n  concatBytes,\n  bigIntToBytes,\n  toTwos,\n  asciiToBytes,\n  utf8ToBytes,\n  writeUInt32BE,\n  intToHex,\n} from \"../utils/encoding.ts\";\nimport { c32addressDecode } from \"../utils/c32.ts\";\nimport { ClarityWireType, type ClarityValue, type ClarityType } from \"./types.ts\";\n\nconst CLARITY_INT_SIZE = 128n;\nconst CLARITY_INT_BYTE_SIZE = 16;\n\nfunction typeIdByte(type: ClarityType): number {\n  return ClarityWireType[type];\n}\n\nfunction withTypeId(type: ClarityType, bytes: Uint8Array): Uint8Array {\n  return concatBytes(new Uint8Array([typeIdByte(type)]), bytes);\n}\n\nfunction serializeAddress(c32Address: string): Uint8Array {\n  const [version, hash160] = c32addressDecode(c32Address);\n  return concatBytes(new Uint8Array([version]), hexToBytes(hash160));\n}\n\nfunction serializeLPString(str: string, prefixBytes = 1): Uint8Array {\n  const content = utf8ToBytes(str);\n  const lengthPrefix = hexToBytes(intToHex(content.byteLength, prefixBytes));\n  return concatBytes(lengthPrefix, content);\n}\n\nexport function serializeCVBytes(value: ClarityValue): Uint8Array {\n  switch (value.type) {\n    case \"true\":\n    case \"false\":\n      return new Uint8Array([typeIdByte(value.type)]);\n\n    case \"int\": {\n      const bytes = bigIntToBytes(\n        toTwos(BigInt(value.value), CLARITY_INT_SIZE),\n        CLARITY_INT_BYTE_SIZE\n      );\n      return withTypeId(value.type, bytes);\n    }\n\n    case \"uint\": {\n      const bytes = bigIntToBytes(BigInt(value.value), CLARITY_INT_BYTE_SIZE);\n      return withTypeId(value.type, bytes);\n    }\n\n    case \"buffer\": {\n      const bufBytes = hexToBytes(value.value);\n      return withTypeId(\n        value.type,\n        concatBytes(writeUInt32BE(bufBytes.length), bufBytes)\n      );\n    }\n\n    case \"none\":\n      return new Uint8Array([typeIdByte(value.type)]);\n\n    case \"some\":\n      return withTypeId(value.type, serializeCVBytes(value.value));\n\n    case \"ok\":\n    case \"err\":\n      return withTypeId(value.type, serializeCVBytes(value.value));\n\n    case \"address\":\n      return withTypeId(value.type, serializeAddress(value.value));\n\n    case \"contract\": {\n      const [addr, name] = value.value.split(\".\");\n      if (!addr || !name) throw new Error(`Invalid contract principal: ${value.value}`);\n      return withTypeId(\n        value.type,\n        concatBytes(serializeAddress(addr), serializeLPString(name))\n      );\n    }\n\n    case \"list\": {\n      const parts: Uint8Array[] = [writeUInt32BE(value.value.length)];\n      for (const item of value.value) {\n        parts.push(serializeCVBytes(item));\n      }\n      return withTypeId(value.type, concatBytes(...parts));\n    }\n\n    case \"tuple\": {\n      const keys = Object.keys(value.value).sort((a, b) => a.localeCompare(b));\n      const parts: Uint8Array[] = [writeUInt32BE(keys.length)];\n      for (const key of keys) {\n        parts.push(serializeLPString(key));\n        parts.push(serializeCVBytes(value.value[key]!));\n      }\n      return withTypeId(value.type, concatBytes(...parts));\n    }\n\n    case \"ascii\": {\n      const strBytes = asciiToBytes(value.value);\n      return withTypeId(\n        value.type,\n        concatBytes(writeUInt32BE(strBytes.length), strBytes)\n      );\n    }\n\n    case \"utf8\": {\n      const strBytes = utf8ToBytes(value.value);\n      return withTypeId(\n        value.type,\n        concatBytes(writeUInt32BE(strBytes.length), strBytes)\n      );\n    }\n\n    default:\n      throw new Error(`Cannot serialize unknown clarity type`);\n  }\n}\n\nexport function serializeCV(value: ClarityValue): string {\n  return bytesToHex(serializeCVBytes(value));\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "2B3A693ED24B1BAF64756E2164756E21",
+  "names": []
+}

package/dist/shared/stacks-24h5k94q.cjs

@@ -0,0 +1,74 @@
+// src/chains/definitions.ts
+var mainnet = {
+  id: 1,
+  name: "Stacks Mainnet",
+  network: "mainnet",
+  transactionVersion: 0,
+  peerNetworkId: 385875968,
+  addressVersion: { singleSig: 22, multiSig: 20 },
+  magicBytes: "X2",
+  bootAddress: "SP000000000000000000002Q6VF78",
+  nativeCurrency: { name: "Stacks", symbol: "STX", decimals: 6 },
+  rpcUrls: {
+    default: {
+      http: ["https://api.mainnet.hiro.so"],
+      ws: ["wss://api.mainnet.hiro.so/extended/v1/ws"]
+    }
+  },
+  blockExplorers: {
+    default: { name: "Hiro Explorer", url: "https://explorer.hiro.so" }
+  }
+};
+var testnet = {
+  id: 2147483648,
+  name: "Stacks Testnet",
+  network: "testnet",
+  transactionVersion: 128,
+  peerNetworkId: 4278190080,
+  addressVersion: { singleSig: 26, multiSig: 21 },
+  magicBytes: "T2",
+  bootAddress: "ST000000000000000000002AMW42H",
+  nativeCurrency: { name: "Stacks", symbol: "STX", decimals: 6 },
+  rpcUrls: {
+    default: {
+      http: ["https://api.testnet.hiro.so"],
+      ws: ["wss://api.testnet.hiro.so/extended/v1/ws"]
+    }
+  },
+  blockExplorers: {
+    default: {
+      name: "Hiro Explorer",
+      url: "https://explorer.hiro.so/?chain=testnet"
+    }
+  }
+};
+var devnet = {
+  id: 2147483648,
+  name: "Stacks Devnet",
+  network: "testnet",
+  transactionVersion: 128,
+  peerNetworkId: 4278190080,
+  addressVersion: { singleSig: 26, multiSig: 21 },
+  magicBytes: "id",
+  bootAddress: "ST000000000000000000002AMW42H",
+  nativeCurrency: { name: "Stacks", symbol: "STX", decimals: 6 },
+  rpcUrls: {
+    default: {
+      http: ["http://localhost:3999"],
+      ws: ["ws://localhost:3999/extended/v1/ws"]
+    }
+  }
+};
+var mocknet = {
+  ...devnet,
+  name: "Stacks Mocknet",
+  addressVersion: { ...devnet.addressVersion }
+};
+
+// src/chains/defineChain.ts
+function defineChain(chain) {
+  return chain;
+}
+
+//# debugId=2AFA2816A3EAB92964756E2164756E21
+//# sourceMappingURL=stacks-24h5k94q.cjs.map

package/dist/shared/stacks-24h5k94q.cjs.map

@@ -0,0 +1,11 @@
+{
+  "version": 3,
+  "sources": ["../src/chains/definitions.ts", "../src/chains/defineChain.ts"],
+  "sourcesContent": [
+    "import type { StacksChain } from \"./types.ts\";\n\n/** Stacks mainnet chain definition (Hiro API). */\nexport const mainnet: StacksChain = {\n  id: 0x00000001,\n  name: \"Stacks Mainnet\",\n  network: \"mainnet\",\n  transactionVersion: 0x00,\n  peerNetworkId: 0x17000000,\n  addressVersion: { singleSig: 22, multiSig: 20 },\n  magicBytes: \"X2\",\n  bootAddress: \"SP000000000000000000002Q6VF78\",\n  nativeCurrency: { name: \"Stacks\", symbol: \"STX\", decimals: 6 },\n  rpcUrls: {\n    default: {\n      http: [\"https://api.mainnet.hiro.so\"],\n      ws: [\"wss://api.mainnet.hiro.so/extended/v1/ws\"],\n    },\n  },\n  blockExplorers: {\n    default: { name: \"Hiro Explorer\", url: \"https://explorer.hiro.so\" },\n  },\n};\n\n/** Stacks testnet chain definition (Hiro API). */\nexport const testnet: StacksChain = {\n  id: 0x80000000,\n  name: \"Stacks Testnet\",\n  network: \"testnet\",\n  transactionVersion: 0x80,\n  peerNetworkId: 0xff000000,\n  addressVersion: { singleSig: 26, multiSig: 21 },\n  magicBytes: \"T2\",\n  bootAddress: \"ST000000000000000000002AMW42H\",\n  nativeCurrency: { name: \"Stacks\", symbol: \"STX\", decimals: 6 },\n  rpcUrls: {\n    default: {\n      http: [\"https://api.testnet.hiro.so\"],\n      ws: [\"wss://api.testnet.hiro.so/extended/v1/ws\"],\n    },\n  },\n  blockExplorers: {\n    default: {\n      name: \"Hiro Explorer\",\n      url: \"https://explorer.hiro.so/?chain=testnet\",\n    },\n  },\n};\n\n/** Local development chain definition (localhost:3999). */\nexport const devnet: StacksChain = {\n  id: 0x80000000,\n  name: \"Stacks Devnet\",\n  network: \"testnet\",\n  transactionVersion: 0x80,\n  peerNetworkId: 0xff000000,\n  addressVersion: { singleSig: 26, multiSig: 21 },\n  magicBytes: \"id\",\n  bootAddress: \"ST000000000000000000002AMW42H\",\n  nativeCurrency: { name: \"Stacks\", symbol: \"STX\", decimals: 6 },\n  rpcUrls: {\n    default: {\n      http: [\"http://localhost:3999\"],\n      ws: [\"ws://localhost:3999/extended/v1/ws\"],\n    },\n  },\n};\n\n/** Alias for devnet used in mock/test environments. */\nexport const mocknet: StacksChain = {\n  ...devnet,\n  name: \"Stacks Mocknet\",\n  addressVersion: { ...devnet.addressVersion },\n};\n",
+    "import type { StacksChain } from \"./types.ts\";\n\n/** Identity helper for defining a custom {@link StacksChain} with full type inference. */\nexport function defineChain(chain: StacksChain): StacksChain {\n  return chain;\n}\n"
+  ],
+  "mappings": ";AAGO,IAAM,UAAuB;AAAA,EAClC,IAAI;AAAA,EACJ,MAAM;AAAA,EACN,SAAS;AAAA,EACT,oBAAoB;AAAA,EACpB,eAAe;AAAA,EACf,gBAAgB,EAAE,WAAW,IAAI,UAAU,GAAG;AAAA,EAC9C,YAAY;AAAA,EACZ,aAAa;AAAA,EACb,gBAAgB,EAAE,MAAM,UAAU,QAAQ,OAAO,UAAU,EAAE;AAAA,EAC7D,SAAS;AAAA,IACP,SAAS;AAAA,MACP,MAAM,CAAC,6BAA6B;AAAA,MACpC,IAAI,CAAC,0CAA0C;AAAA,IACjD;AAAA,EACF;AAAA,EACA,gBAAgB;AAAA,IACd,SAAS,EAAE,MAAM,iBAAiB,KAAK,2BAA2B;AAAA,EACpE;AACF;AAGO,IAAM,UAAuB;AAAA,EAClC,IAAI;AAAA,EACJ,MAAM;AAAA,EACN,SAAS;AAAA,EACT,oBAAoB;AAAA,EACpB,eAAe;AAAA,EACf,gBAAgB,EAAE,WAAW,IAAI,UAAU,GAAG;AAAA,EAC9C,YAAY;AAAA,EACZ,aAAa;AAAA,EACb,gBAAgB,EAAE,MAAM,UAAU,QAAQ,OAAO,UAAU,EAAE;AAAA,EAC7D,SAAS;AAAA,IACP,SAAS;AAAA,MACP,MAAM,CAAC,6BAA6B;AAAA,MACpC,IAAI,CAAC,0CAA0C;AAAA,IACjD;AAAA,EACF;AAAA,EACA,gBAAgB;AAAA,IACd,SAAS;AAAA,MACP,MAAM;AAAA,MACN,KAAK;AAAA,IACP;AAAA,EACF;AACF;AAGO,IAAM,SAAsB;AAAA,EACjC,IAAI;AAAA,EACJ,MAAM;AAAA,EACN,SAAS;AAAA,EACT,oBAAoB;AAAA,EACpB,eAAe;AAAA,EACf,gBAAgB,EAAE,WAAW,IAAI,UAAU,GAAG;AAAA,EAC9C,YAAY;AAAA,EACZ,aAAa;AAAA,EACb,gBAAgB,EAAE,MAAM,UAAU,QAAQ,OAAO,UAAU,EAAE;AAAA,EAC7D,SAAS;AAAA,IACP,SAAS;AAAA,MACP,MAAM,CAAC,uBAAuB;AAAA,MAC9B,IAAI,CAAC,oCAAoC;AAAA,IAC3C;AAAA,EACF;AACF;AAGO,IAAM,UAAuB;AAAA,KAC/B;AAAA,EACH,MAAM;AAAA,EACN,gBAAgB,KAAK,OAAO,eAAe;AAC7C;;;ACtEO,SAAS,WAAW,CAAC,OAAiC;AAAA,EAC3D,OAAO;AAAA;",
+  "debugId": "2AFA2816A3EAB92964756E2164756E21",
+  "names": []
+}

package/dist/shared/stacks-2ar4prfz.cjs

@@ -0,0 +1,328 @@
+// src/clarity/index.ts
+var exports_clarity = {};
+__export(exports_clarity, {
+  validateArgsArray: () => validateArgsArray,
+  validateArgs: () => validateArgs,
+  uintCV: () => uintCV,
+  tupleCV: () => tupleCV,
+  trueCV: () => trueCV,
+  toCamelCase: () => toCamelCase,
+  stringUtf8CV: () => stringUtf8CV,
+  stringAsciiCV: () => stringAsciiCV,
+  standardPrincipalCV: () => standardPrincipalCV,
+  someCV: () => someCV,
+  sip013Abi: () => sip013Abi,
+  sip010Abi: () => sip010Abi,
+  sip009Abi: () => sip009Abi,
+  serializeCVBytes: () => serializeCVBytes,
+  serializeCV: () => serializeCV,
+  responseOkCV: () => responseOkCV,
+  responseErrorCV: () => responseErrorCV,
+  prettyPrint: () => prettyPrint,
+  prepareArgs: () => prepareArgs,
+  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,
+  isBool: () => isBool,
+  isArray: () => isArray,
+  isAbiTuple: () => isAbiTuple,
+  isAbiTraitReference: () => isAbiTraitReference,
+  isAbiStringUtf8: () => isAbiStringUtf8,
+  isAbiStringAscii: () => isAbiStringAscii,
+  isAbiResponse: () => isAbiResponse,
+  isAbiOptional: () => isAbiOptional,
+  isAbiList: () => isAbiList,
+  isAbiBuffer: () => isAbiBuffer,
+  intCV: () => intCV,
+  falseCV: () => falseCV,
+  deserializeCVBytes: () => deserializeCVBytes,
+  deserializeCV: () => deserializeCV,
+  cvToValue: () => cvToValue,
+  cvToJSON: () => cvToJSON,
+  contractPrincipalCV: () => contractPrincipalCV,
+  clarityValueToJS: () => clarityValueToJS,
+  clarityTypeFromByte: () => clarityTypeFromByte,
+  bufferCV: () => bufferCV,
+  boolCV: () => boolCV,
+  SIP013_ABI: () => SIP013_ABI,
+  SIP010_ABI: () => SIP010_ABI,
+  SIP009_ABI: () => SIP009_ABI,
+  ClarityWireType: () => ClarityWireType,
+  ClarityConversionError: () => ClarityConversionError,
+  Cl: () => Cl,
+  CONTRACT_NAME_REGEX: () => CONTRACT_NAME_REGEX
+});
+module.exports = __toCommonJS(exports_clarity);
+
+// src/clarity/prettyPrint.ts
+function prettyPrint(val, encoding = "hex") {
+  switch (val.type) {
+    case "true":
+      return "true";
+    case "false":
+      return "false";
+    case "int":
+      return val.value.toString();
+    case "uint":
+      return `u${val.value.toString()}`;
+    case "buffer":
+      if (encoding === "tryAscii") {
+        const str = bytesToAscii(hexToBytes(val.value));
+        if (/^[ -~]*$/.test(str))
+          return JSON.stringify(str);
+      }
+      return `0x${val.value}`;
+    case "none":
+      return "none";
+    case "some":
+      return `(some ${prettyPrint(val.value, encoding)})`;
+    case "ok":
+      return `(ok ${prettyPrint(val.value, encoding)})`;
+    case "err":
+      return `(err ${prettyPrint(val.value, encoding)})`;
+    case "address":
+    case "contract":
+      return val.value;
+    case "list":
+      return `(list ${val.value.map((v) => prettyPrint(v, encoding)).join(" ")})`;
+    case "tuple":
+      return `(tuple ${Object.keys(val.value).map((key) => `(${key} ${prettyPrint(val.value[key], encoding)})`).join(" ")})`;
+    case "ascii":
+      return `"${val.value}"`;
+    case "utf8":
+      return `u"${val.value}"`;
+  }
+}
+function cvToJSON(val) {
+  switch (val.type) {
+    case "true":
+      return { type: "bool", value: true };
+    case "false":
+      return { type: "bool", value: false };
+    case "int":
+      return { type: "int", value: val.value.toString() };
+    case "uint":
+      return { type: "uint", value: val.value.toString() };
+    case "buffer":
+      return { type: `(buff ${Math.ceil(val.value.length / 2)})`, value: `0x${val.value}` };
+    case "none":
+      return { type: "(optional none)", value: null };
+    case "some":
+      return { type: `(optional)`, value: cvToJSON(val.value) };
+    case "ok":
+      return { type: "(response)", value: cvToJSON(val.value), success: true };
+    case "err":
+      return { type: "(response)", value: cvToJSON(val.value), success: false };
+    case "address":
+    case "contract":
+      return { type: "principal", value: val.value };
+    case "list":
+      return { type: "(list)", value: val.value.map(cvToJSON) };
+    case "tuple": {
+      const result = {};
+      for (const key of Object.keys(val.value)) {
+        result[key] = cvToJSON(val.value[key]);
+      }
+      return { type: "(tuple)", value: result };
+    }
+    case "ascii":
+      return { type: `(string-ascii ${asciiToBytes(val.value).length})`, value: val.value };
+    case "utf8":
+      return { type: `(string-utf8 ${utf8ToBytes(val.value).length})`, value: val.value };
+  }
+}
+function cvToValue(val) {
+  switch (val.type) {
+    case "true":
+      return true;
+    case "false":
+      return false;
+    case "int":
+    case "uint":
+      return val.value;
+    case "buffer":
+      return `0x${val.value}`;
+    case "none":
+      return null;
+    case "some":
+      return cvToValue(val.value);
+    case "ok":
+    case "err":
+      return cvToValue(val.value);
+    case "address":
+    case "contract":
+      return val.value;
+    case "list":
+      return val.value.map(cvToValue);
+    case "tuple": {
+      const result = {};
+      for (const key of Object.keys(val.value)) {
+        result[key] = cvToValue(val.value[key]);
+      }
+      return result;
+    }
+    case "ascii":
+    case "utf8":
+      return val.value;
+  }
+}
+// src/clarity/abi/converters.ts
+class ClarityConversionError extends Error {
+  type;
+  value;
+  constructor(message, type, value) {
+    super(message);
+    this.type = type;
+    this.value = value;
+    this.name = "ClarityConversionError";
+  }
+}
+function jsToClarity(type, value) {
+  if (type === "none")
+    return null;
+  if (type === "uint128") {
+    if (!isUint128(value))
+      throw new ClarityConversionError("Invalid uint128 value", type, value);
+    return value;
+  }
+  if (type === "int128") {
+    if (!isInt128(value))
+      throw new ClarityConversionError("Invalid int128 value", type, value);
+    return value;
+  }
+  if (type === "bool") {
+    if (!isBool(value))
+      throw new ClarityConversionError("Invalid bool value", type, value);
+    return value;
+  }
+  if (type === "principal") {
+    if (!isPrincipal(value))
+      throw new ClarityConversionError("Invalid principal value", type, value);
+    return value;
+  }
+  if (type === "trait_reference") {
+    if (!isPrincipal(value))
+      throw new ClarityConversionError("Invalid trait_reference value", type, value);
+    return value;
+  }
+  if (isAbiStringAscii(type)) {
+    if (!isString(value))
+      throw new ClarityConversionError("Invalid string-ascii value", type, value);
+    const str = value;
+    for (let i = 0;i < str.length; i++) {
+      if (str.charCodeAt(i) > 127) {
+        throw new ClarityConversionError(`Non-ASCII character at position ${i}: '${str[i]}' (code ${str.charCodeAt(i)})`, type, value);
+      }
+    }
+    if (str.length > type["string-ascii"].length) {
+      throw new ClarityConversionError(`String length ${str.length} exceeds max ${type["string-ascii"].length}`, type, value);
+    }
+    return value;
+  }
+  if (isAbiStringUtf8(type)) {
+    if (!isString(value))
+      throw new ClarityConversionError("Invalid string-utf8 value", type, value);
+    const str = value;
+    const byteLength = new TextEncoder().encode(str).length;
+    if (byteLength > type["string-utf8"].length) {
+      throw new ClarityConversionError(`String byte length ${byteLength} exceeds max ${type["string-utf8"].length}`, type, value);
+    }
+    return value;
+  }
+  if (isAbiBuffer(type)) {
+    if (!isUint8Array(value))
+      throw new ClarityConversionError("Invalid buffer value", type, value);
+    const buff = value;
+    if (buff.length > type.buff.length) {
+      throw new ClarityConversionError(`Buffer length ${buff.length} exceeds max ${type.buff.length}`, type, value);
+    }
+    return value;
+  }
+  if (isAbiList(type)) {
+    if (!Array.isArray(value))
+      throw new ClarityConversionError("Expected array for list type", type, value);
+    if (value.length > type.list.length) {
+      throw new ClarityConversionError(`List length ${value.length} exceeds max ${type.list.length}`, type, value);
+    }
+    return value.map((item) => jsToClarity(type.list.type, item));
+  }
+  if (isAbiTuple(type)) {
+    if (typeof value !== "object" || value === null)
+      throw new ClarityConversionError("Expected object for tuple type", type, value);
+    const result = {};
+    for (const field of type.tuple) {
+      const camelKey = toCamelCase(field.name);
+      const hasOriginal = field.name in value;
+      const hasCamel = camelKey in value;
+      if (!hasOriginal && !hasCamel) {
+        throw new ClarityConversionError(`Missing tuple field: ${field.name}`, type, value);
+      }
+      const fieldValue = hasOriginal ? value[field.name] : value[camelKey];
+      result[field.name] = jsToClarity(field.type, fieldValue);
+    }
+    return result;
+  }
+  if (isAbiOptional(type)) {
+    if (value === null || value === undefined)
+      return null;
+    return jsToClarity(type.optional, value);
+  }
+  if (isAbiResponse(type)) {
+    if (typeof value !== "object" || value === null)
+      throw new ClarityConversionError("Expected object for response type", type, value);
+    const hasOk = "ok" in value;
+    const hasErr = "err" in value;
+    if (hasOk && !hasErr) {
+      return {
+        ok: jsToClarity(type.response.ok, value.ok)
+      };
+    }
+    if (hasErr && !hasOk) {
+      return {
+        err: jsToClarity(type.response.error, value.err)
+      };
+    }
+    throw new ClarityConversionError("Response must have exactly 'ok' or 'err' property", type, value);
+  }
+  throw new ClarityConversionError(`Unknown Clarity type`, type, value);
+}
+function prepareArgs(func, args) {
+  return func.args.map((arg) => {
+    if (!(arg.name in args)) {
+      throw new ClarityConversionError(`Missing argument: ${arg.name}`, arg.type, undefined);
+    }
+    return jsToClarity(arg.type, args[arg.name]);
+  });
+}
+function validateArgs(func, args) {
+  for (const arg of func.args) {
+    if (!(arg.name in args)) {
+      throw new ClarityConversionError(`Missing argument: ${arg.name}`, arg.type, undefined);
+    }
+    jsToClarity(arg.type, args[arg.name]);
+  }
+}
+function validateArgsArray(func, args) {
+  if (args.length !== func.args.length) {
+    throw new ClarityConversionError(`Expected ${func.args.length} arguments, got ${args.length}`, func.args[0]?.type ?? "bool", args);
+  }
+  func.args.forEach((arg, i) => {
+    jsToClarity(arg.type, args[i]);
+  });
+}
+
+//# debugId=72D7A0CDC9AC36C164756E2164756E21
+//# sourceMappingURL=stacks-2ar4prfz.cjs.map