@secondlayer/stacks 0.0.1

package/dist/src/clarity/index.js

@@ -0,0 +1,145 @@
+import {
+  ClarityConversionError,
+  cvToJSON,
+  cvToValue,
+  jsToClarity,
+  prepareArgs,
+  prettyPrint,
+  validateArgs,
+  validateArgsArray
+} from "../../shared/stacks-tjxmrssa.js";
+import {
+  SIP009_ABI,
+  SIP010_ABI,
+  SIP013_ABI,
+  sip009Abi,
+  sip010Abi,
+  sip013Abi
+} from "../../shared/stacks-k58k970n.js";
+import {
+  CONTRACT_NAME_REGEX,
+  clarityValueToJS,
+  isAbiBuffer,
+  isAbiList,
+  isAbiOptional,
+  isAbiResponse,
+  isAbiStringAscii,
+  isAbiStringUtf8,
+  isAbiTraitReference,
+  isAbiTuple,
+  isArray,
+  isBool,
+  isContractPrincipal,
+  isErrResponse,
+  isInt128,
+  isOkResponse,
+  isOptional,
+  isPrincipal,
+  isResponse,
+  isStandardPrincipal,
+  isString,
+  isTraitReference,
+  isUint128,
+  isUint8Array,
+  jsToClarityValue,
+  toCamelCase
+} from "../../shared/stacks-d1fmkv3p.js";
+import {
+  Cl,
+  boolCV,
+  bufferCV,
+  contractPrincipalCV,
+  deserializeCV,
+  deserializeCVBytes,
+  falseCV,
+  intCV,
+  listCV,
+  noneCV,
+  responseErrorCV,
+  responseOkCV,
+  someCV,
+  standardPrincipalCV,
+  stringAsciiCV,
+  stringUtf8CV,
+  trueCV,
+  tupleCV,
+  uintCV
+} from "../../shared/stacks-j2cy7qtt.js";
+import {
+  ClarityWireType,
+  clarityTypeFromByte,
+  serializeCV,
+  serializeCVBytes
+} from "../../shared/stacks-8yykgdww.js";
+import"../../shared/stacks-v9jqcpd4.js";
+import"../../shared/stacks-gjvbq6w7.js";
+import"../../shared/stacks-nqytwfcc.js";
+import"../../shared/stacks-8m9byk2j.js";
+export {
+  validateArgsArray,
+  validateArgs,
+  uintCV,
+  tupleCV,
+  trueCV,
+  toCamelCase,
+  stringUtf8CV,
+  stringAsciiCV,
+  standardPrincipalCV,
+  someCV,
+  sip013Abi,
+  sip010Abi,
+  sip009Abi,
+  serializeCVBytes,
+  serializeCV,
+  responseOkCV,
+  responseErrorCV,
+  prettyPrint,
+  prepareArgs,
+  noneCV,
+  listCV,
+  jsToClarityValue,
+  jsToClarity,
+  isUint8Array,
+  isUint128,
+  isTraitReference,
+  isString,
+  isStandardPrincipal,
+  isResponse,
+  isPrincipal,
+  isOptional,
+  isOkResponse,
+  isInt128,
+  isErrResponse,
+  isContractPrincipal,
+  isBool,
+  isArray,
+  isAbiTuple,
+  isAbiTraitReference,
+  isAbiStringUtf8,
+  isAbiStringAscii,
+  isAbiResponse,
+  isAbiOptional,
+  isAbiList,
+  isAbiBuffer,
+  intCV,
+  falseCV,
+  deserializeCVBytes,
+  deserializeCV,
+  cvToValue,
+  cvToJSON,
+  contractPrincipalCV,
+  clarityValueToJS,
+  clarityTypeFromByte,
+  bufferCV,
+  boolCV,
+  SIP013_ABI,
+  SIP010_ABI,
+  SIP009_ABI,
+  ClarityWireType,
+  ClarityConversionError,
+  Cl,
+  CONTRACT_NAME_REGEX
+};
+
+//# debugId=565CB95AB940D0B164756E2164756E21
+//# sourceMappingURL=index.js.map

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

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

package/dist/src/connect/index.cjs

@@ -0,0 +1,480 @@
+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
+    });
+};
+
+// src/connect/index.ts
+var exports_connect = {};
+__export(exports_connect, {
+  setProvider: () => setProvider,
+  request: () => request,
+  isWalletInstalled: () => isWalletInstalled,
+  isConnected: () => isConnected,
+  getProvider: () => getProvider,
+  disconnect: () => disconnect,
+  connect: () => connect,
+  JsonRpcErrorCode: () => JsonRpcErrorCode,
+  JsonRpcError: () => JsonRpcError,
+  ConnectError: () => ConnectError
+});
+module.exports = __toCommonJS(exports_connect);
+
+// src/errors/base.ts
+class BaseError extends Error {
+  name = "StacksError";
+  shortMessage;
+  details;
+  constructor(shortMessage, options) {
+    const message = [
+      shortMessage,
+      options?.details ? `
+${options.details}` : ""
+    ].join("");
+    super(message, { cause: options?.cause });
+    this.shortMessage = shortMessage;
+    this.details = options?.details;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      shortMessage: this.shortMessage,
+      details: this.details,
+      cause: this.cause instanceof Error ? this.cause.message : undefined
+    };
+  }
+}
+
+// src/connect/errors.ts
+class ConnectError extends BaseError {
+  name = "ConnectError";
+}
+var JsonRpcErrorCode;
+((JsonRpcErrorCode2) => {
+  JsonRpcErrorCode2[JsonRpcErrorCode2["ParseError"] = -32700] = "ParseError";
+  JsonRpcErrorCode2[JsonRpcErrorCode2["InvalidRequest"] = -32600] = "InvalidRequest";
+  JsonRpcErrorCode2[JsonRpcErrorCode2["MethodNotFound"] = -32601] = "MethodNotFound";
+  JsonRpcErrorCode2[JsonRpcErrorCode2["InvalidParams"] = -32602] = "InvalidParams";
+  JsonRpcErrorCode2[JsonRpcErrorCode2["InternalError"] = -32603] = "InternalError";
+  JsonRpcErrorCode2[JsonRpcErrorCode2["UserRejection"] = -31001] = "UserRejection";
+})(JsonRpcErrorCode ||= {});
+
+class JsonRpcError extends ConnectError {
+  name = "JsonRpcError";
+  code;
+  data;
+  constructor(message, code, options) {
+    const details = options?.data !== undefined ? typeof options.data === "string" ? options.data : JSON.stringify(options.data) : undefined;
+    super(message, { cause: options?.cause, details });
+    this.code = code;
+    this.data = options?.data;
+  }
+}
+
+// src/connect/provider.ts
+var customProvider = null;
+function setProvider(provider) {
+  customProvider = provider;
+}
+function getProvider() {
+  if (customProvider)
+    return customProvider;
+  if (typeof window === "undefined") {
+    throw new ConnectError("No Stacks wallet found");
+  }
+  const provider = window.StacksProvider ?? window.LeatherProvider ?? window.XverseProvider ?? window.HiroWalletProvider;
+  if (!provider)
+    throw new ConnectError("No Stacks wallet found");
+  return provider;
+}
+function isWalletInstalled() {
+  return typeof window !== "undefined" && !!(window.StacksProvider || window.LeatherProvider || window.XverseProvider || window.HiroWalletProvider);
+}
+
+// src/connect/storage.ts
+var STORAGE_KEY = "@secondlayer/connect";
+function toHex(str) {
+  return Array.from(new TextEncoder().encode(str)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function fromHex(hex) {
+  const bytes = new Uint8Array(hex.match(/.{1,2}/g).map((byte) => parseInt(byte, 16)));
+  return new TextDecoder().decode(bytes);
+}
+function getLocalStorage() {
+  return typeof localStorage !== "undefined" ? localStorage : undefined;
+}
+function getStorageData() {
+  try {
+    const raw = getLocalStorage()?.getItem(STORAGE_KEY);
+    if (!raw)
+      return null;
+    return JSON.parse(fromHex(raw));
+  } catch {
+    return null;
+  }
+}
+function setStorageData(data) {
+  const encoded = toHex(JSON.stringify(data));
+  getLocalStorage()?.setItem(STORAGE_KEY, encoded);
+}
+function clearStorage() {
+  getLocalStorage()?.removeItem(STORAGE_KEY);
+}
+function cacheAddresses(addresses) {
+  const stx = addresses.filter((a) => a.address.startsWith("SP") || a.address.startsWith("ST"));
+  const btc = addresses.filter((a) => !a.address.startsWith("SP") && !a.address.startsWith("ST"));
+  setStorageData({
+    addresses: { stx, btc },
+    version: "0.0.1",
+    updatedAt: Date.now()
+  });
+}
+
+// src/utils/encoding.ts
+var hexes = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+function bytesToHex(bytes) {
+  let hex = "";
+  for (const b of bytes) {
+    hex += hexes[b];
+  }
+  return hex;
+}
+function hexToBytes(hex) {
+  hex = without0x(hex);
+  if (hex.length % 2)
+    hex = `0${hex}`;
+  const array = new Uint8Array(hex.length / 2);
+  for (let i = 0;i < array.length; i++) {
+    const j = i * 2;
+    const byte = Number.parseInt(hex.slice(j, j + 2), 16);
+    if (Number.isNaN(byte) || byte < 0)
+      throw new Error("Invalid byte sequence");
+    array[i] = byte;
+  }
+  return array;
+}
+function without0x(value) {
+  return /^0x/i.test(value) ? value.slice(2) : value;
+}
+function utf8ToBytes(str) {
+  return new TextEncoder().encode(str);
+}
+function asciiToBytes(str) {
+  const bytes = new Uint8Array(str.length);
+  for (let i = 0;i < str.length; i++) {
+    bytes[i] = str.charCodeAt(i) & 255;
+  }
+  return bytes;
+}
+function concatBytes(...arrays) {
+  if (arrays.length === 1)
+    return arrays[0];
+  const length = arrays.reduce((a, arr) => a + arr.length, 0);
+  const result = new Uint8Array(length);
+  let pad = 0;
+  for (const arr of arrays) {
+    result.set(arr, pad);
+    pad += arr.length;
+  }
+  return result;
+}
+function intToBigInt(value) {
+  if (typeof value === "bigint")
+    return value;
+  if (typeof value === "string")
+    return BigInt(value);
+  if (typeof value === "number") {
+    if (!Number.isInteger(value))
+      throw new RangeError("Values of type 'number' must be an integer.");
+    if (value > Number.MAX_SAFE_INTEGER)
+      throw new RangeError(`Values of type 'number' must be <= ${Number.MAX_SAFE_INTEGER}. Use BigInt instead.`);
+    return BigInt(value);
+  }
+  if (value instanceof Uint8Array)
+    return BigInt(`0x${bytesToHex(value)}`);
+  throw new TypeError("Must be a number, bigint, string, or Uint8Array.");
+}
+function bigIntToBytes(value, length = 16) {
+  const hex = value.toString(16).padStart(length * 2, "0");
+  return hexToBytes(hex);
+}
+function intToHex(integer, byteLength = 8) {
+  const value = typeof integer === "bigint" ? integer : intToBigInt(integer);
+  return value.toString(16).padStart(byteLength * 2, "0");
+}
+function toTwos(value, width) {
+  const limit = BigInt(1) << width - BigInt(1);
+  if (value < -limit || value > limit - BigInt(1)) {
+    throw new Error(`Unable to represent integer in width: ${width}`);
+  }
+  if (value >= BigInt(0))
+    return value;
+  return value + (BigInt(1) << width);
+}
+function writeUInt32BE(value) {
+  const buf = new Uint8Array(4);
+  buf[0] = value >>> 24 & 255;
+  buf[1] = value >>> 16 & 255;
+  buf[2] = value >>> 8 & 255;
+  buf[3] = value & 255;
+  return buf;
+}
+
+// src/utils/c32.ts
+var import_sha2 = 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 c32decode(c32input) {
+  c32input = c32normalize(c32input);
+  if (!c32input.match(`^[${C32}]*$`))
+    throw new Error("Not a c32-encoded string");
+  const zeroPrefix = c32input.match(`^${C32[0]}*`);
+  const numLeadingZeroBytes = zeroPrefix ? zeroPrefix[0].length : 0;
+  const res = [];
+  let carry = 0;
+  let carryBits = 0;
+  for (let i = c32input.length - 1;i >= 0; i--) {
+    if (carryBits === 4) {
+      res.unshift(HEX[carry]);
+      carryBits = 0;
+      carry = 0;
+    }
+    const currentValue = (C32.indexOf(c32input[i]) << carryBits) + carry;
+    res.unshift(HEX[currentValue % 16]);
+    carryBits += 1;
+    carry = currentValue >> 4;
+    if (carry > 1 << carryBits)
+      throw new Error("Panic error in c32 decoding");
+  }
+  res.unshift(HEX[carry]);
+  if (res.length % 2 === 1)
+    res.unshift("0");
+  let hexLeadingZeros = 0;
+  while (hexLeadingZeros < res.length && res[hexLeadingZeros] === "0")
+    hexLeadingZeros++;
+  let hexStr = res.slice(hexLeadingZeros - hexLeadingZeros % 2).join("");
+  for (let i = 0;i < numLeadingZeroBytes; i++)
+    hexStr = `00${hexStr}`;
+  return hexStr;
+}
+function c32checksum(dataHex) {
+  return bytesToHex(import_sha2.sha256(import_sha2.sha256(hexToBytes(dataHex))).slice(0, 4));
+}
+function c32checkDecode(c32data) {
+  c32data = c32normalize(c32data);
+  const dataHex = c32decode(c32data.slice(1));
+  const version = C32.indexOf(c32data[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 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/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]));
+
+// 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`);
+  }
+}
+
+// src/connect/request.ts
+var POST_CONDITION_TYPES = new Set([
+  "stx-postcondition",
+  "ft-postcondition",
+  "nft-postcondition"
+]);
+function isClarityValue(obj) {
+  return typeof obj === "object" && obj !== null && "type" in obj && typeof obj.type === "string" && !POST_CONDITION_TYPES.has(obj.type);
+}
+function serializeParams(value) {
+  if (value === null || value === undefined)
+    return value;
+  if (typeof value === "bigint")
+    return value.toString();
+  if (Array.isArray(value))
+    return value.map(serializeParams);
+  if (typeof value === "object") {
+    if (value instanceof Uint8Array)
+      return value;
+    if (POST_CONDITION_TYPES.has(value.type))
+      return value;
+    if (isClarityValue(value)) {
+      return bytesToHex(serializeCVBytes(value));
+    }
+    const result = {};
+    for (const [k, v] of Object.entries(value)) {
+      result[k] = serializeParams(v);
+    }
+    return result;
+  }
+  return value;
+}
+var ADDRESS_METHODS = new Set(["getAddresses", "stx_getAddresses"]);
+async function request(method, ...args) {
+  const provider = getProvider();
+  const params = args[0];
+  const serialized = params ? serializeParams(params) : undefined;
+  let result;
+  try {
+    result = await provider.request(method, serialized);
+  } catch (err) {
+    if (err?.code !== undefined) {
+      throw new JsonRpcError(err.message ?? String(err), err.code, {
+        data: err.data
+      });
+    }
+    throw new ConnectError(err?.message ?? "Wallet request failed", {
+      cause: err instanceof Error ? err : undefined
+    });
+  }
+  if (ADDRESS_METHODS.has(method) && result?.addresses) {
+    cacheAddresses(result.addresses);
+  }
+  return result;
+}
+// src/connect/actions.ts
+async function connect() {
+  return request("getAddresses");
+}
+function disconnect() {
+  clearStorage();
+  try {
+    getProvider().disconnect?.();
+  } catch {}
+}
+function isConnected() {
+  const data = getStorageData();
+  return (data?.addresses?.stx?.length ?? 0) > 0;
+}
+
+//# debugId=94114852344D7D1664756E2164756E21
+//# sourceMappingURL=index.cjs.map