@secondlayer/stacks 6.0.0 → 6.1.0

package/dist/shared/stacks-ee53k9j2.cjs

@@ -1,651 +0,0 @@
-// src/clarity/index.ts
-var exports_clarity = {};
-__export(exports_clarity, {
-  validateArgsArray: () => validateArgsArray,
-  validateArgs: () => validateArgs,
-  uintCV: () => uintCV,
-  tupleCV: () => tupleCV,
-  trueCV: () => trueCV,
-  toCamelCase: () => toCamelCase,
-  structuredDataHash: () => structuredDataHash,
-  stringUtf8CV: () => stringUtf8CV,
-  stringAsciiCV: () => stringAsciiCV,
-  standardPrincipalCV: () => standardPrincipalCV,
-  someCV: () => someCV,
-  sip013Abi: () => sip013Abi,
-  sip010Abi: () => sip010Abi,
-  sip009Abi: () => sip009Abi,
-  signStructuredData: () => signStructuredData,
-  serializeCVBytes: () => serializeCVBytes,
-  serializeCV: () => serializeCV,
-  responseOkCV: () => responseOkCV,
-  responseErrorCV: () => responseErrorCV,
-  prettyPrint: () => prettyPrint,
-  prepareArgs: () => prepareArgs,
-  parseDeclaredStandards: () => parseDeclaredStandards,
-  normalizeType: () => normalizeType,
-  normalizeAccess: () => normalizeAccess,
-  normalizeAbi: () => normalizeAbi,
-  noneCV: () => noneCV,
-  listCV: () => listCV,
-  jsToClarityValue: () => jsToClarityValue,
-  jsToClarity: () => jsToClarity,
-  isUint8Array: () => isUint8Array,
-  isUint128: () => isUint128,
-  isTraitReference: () => isTraitReference,
-  isString: () => isString,
-  isStandardPrincipal: () => isStandardPrincipal,
-  isResponse: () => isResponse,
-  isPrincipal: () => isPrincipal,
-  isOptional: () => isOptional,
-  isOkResponse: () => isOkResponse,
-  isInt128: () => isInt128,
-  isErrResponse: () => isErrResponse,
-  isContractPrincipal: () => isContractPrincipal,
-  isClarityValue: () => isClarityValue,
-  isBool: () => isBool,
-  isArray: () => isArray,
-  isAbiTuple: () => isAbiTuple,
-  isAbiTraitReference: () => isAbiTraitReference,
-  isAbiStringUtf8: () => isAbiStringUtf8,
-  isAbiStringAscii: () => isAbiStringAscii,
-  isAbiResponse: () => isAbiResponse,
-  isAbiOptional: () => isAbiOptional,
-  isAbiList: () => isAbiList,
-  isAbiBuffer: () => isAbiBuffer,
-  intCV: () => intCV,
-  hashStructuredData: () => hashStructuredData,
-  falseCV: () => falseCV,
-  encodeStructuredData: () => encodeStructuredData,
-  deserializeCVBytes: () => deserializeCVBytes,
-  deserializeCV: () => deserializeCV,
-  cvToValue: () => cvToValue,
-  cvToString: () => cvToString,
-  cvToPrincipal: () => cvToPrincipal,
-  cvToJSON: () => cvToJSON,
-  cvToBuffer: () => cvToBuffer,
-  cvToBoolean: () => cvToBoolean,
-  cvToBigInt: () => cvToBigInt,
-  contractPrincipalCV: () => contractPrincipalCV,
-  classifyContract: () => classifyContract,
-  clarityValueToJSUntyped: () => clarityValueToJSUntyped,
-  clarityValueToJS: () => clarityValueToJS,
-  clarityTypeFromByte: () => clarityTypeFromByte,
-  bufferCV: () => bufferCV,
-  boolCV: () => boolCV,
-  TRAIT_STANDARDS: () => TRAIT_STANDARDS,
-  SIP018_PREFIX: () => SIP018_PREFIX,
-  SIP013_ABI: () => SIP013_ABI,
-  SIP010_ABI: () => SIP010_ABI,
-  SIP009_ABI: () => SIP009_ABI,
-  ClarityWireType: () => ClarityWireType,
-  ClarityConversionError: () => ClarityConversionError,
-  Cl: () => Cl,
-  CONTRACT_NAME_REGEX: () => CONTRACT_NAME_REGEX
-});
-module.exports = __toCommonJS(exports_clarity);
-
-// src/clarity/prettyPrint.ts
-function prettyPrint(val, encoding = "hex") {
-  switch (val.type) {
-    case "true":
-      return "true";
-    case "false":
-      return "false";
-    case "int":
-      return val.value.toString();
-    case "uint":
-      return `u${val.value.toString()}`;
-    case "buffer":
-      if (encoding === "tryAscii") {
-        const str = bytesToAscii(hexToBytes(val.value));
-        if (/^[ -~]*$/.test(str))
-          return JSON.stringify(str);
-      }
-      return `0x${val.value}`;
-    case "none":
-      return "none";
-    case "some":
-      return `(some ${prettyPrint(val.value, encoding)})`;
-    case "ok":
-      return `(ok ${prettyPrint(val.value, encoding)})`;
-    case "err":
-      return `(err ${prettyPrint(val.value, encoding)})`;
-    case "address":
-    case "contract":
-      return val.value;
-    case "list":
-      return `(list ${val.value.map((v) => prettyPrint(v, encoding)).join(" ")})`;
-    case "tuple":
-      return `(tuple ${Object.keys(val.value).map((key) => `(${key} ${prettyPrint(val.value[key], encoding)})`).join(" ")})`;
-    case "ascii":
-      return `"${val.value}"`;
-    case "utf8":
-      return `u"${val.value}"`;
-  }
-}
-function cvToJSON(val) {
-  switch (val.type) {
-    case "true":
-      return { type: "bool", value: true };
-    case "false":
-      return { type: "bool", value: false };
-    case "int":
-      return { type: "int", value: val.value.toString() };
-    case "uint":
-      return { type: "uint", value: val.value.toString() };
-    case "buffer": {
-      const hex = without0x(val.value);
-      return {
-        type: `(buff ${Math.ceil(hex.length / 2)})`,
-        value: `0x${hex}`
-      };
-    }
-    case "none":
-      return { type: "(optional none)", value: null };
-    case "some":
-      return { type: "(optional)", value: cvToJSON(val.value) };
-    case "ok":
-      return { type: "(response)", value: cvToJSON(val.value), success: true };
-    case "err":
-      return { type: "(response)", value: cvToJSON(val.value), success: false };
-    case "address":
-    case "contract":
-      return { type: "principal", value: val.value };
-    case "list":
-      return { type: "(list)", value: val.value.map(cvToJSON) };
-    case "tuple": {
-      const result = {};
-      for (const key of Object.keys(val.value)) {
-        result[key] = cvToJSON(val.value[key]);
-      }
-      return { type: "(tuple)", value: result };
-    }
-    case "ascii":
-      return {
-        type: `(string-ascii ${asciiToBytes(val.value).length})`,
-        value: val.value
-      };
-    case "utf8":
-      return {
-        type: `(string-utf8 ${utf8ToBytes(val.value).length})`,
-        value: val.value
-      };
-  }
-}
-function cvToValue(val) {
-  switch (val.type) {
-    case "true":
-      return true;
-    case "false":
-      return false;
-    case "int":
-    case "uint":
-      return val.value;
-    case "buffer":
-      return `0x${val.value}`;
-    case "none":
-      return null;
-    case "some":
-      return cvToValue(val.value);
-    case "ok":
-    case "err":
-      return cvToValue(val.value);
-    case "address":
-    case "contract":
-      return val.value;
-    case "list":
-      return val.value.map(cvToValue);
-    case "tuple": {
-      const result = {};
-      for (const key of Object.keys(val.value)) {
-        result[key] = cvToValue(val.value[key]);
-      }
-      return result;
-    }
-    case "ascii":
-    case "utf8":
-      return val.value;
-  }
-}
-function cvToBigInt(val) {
-  if (val.type !== "int" && val.type !== "uint") {
-    throw new Error(`cvToBigInt: expected int or uint, got ${val.type}`);
-  }
-  return val.value;
-}
-function cvToString(val) {
-  if (val.type !== "ascii" && val.type !== "utf8") {
-    throw new Error(`cvToString: expected ascii or utf8, got ${val.type}`);
-  }
-  return val.value;
-}
-function cvToBuffer(val) {
-  if (val.type !== "buffer") {
-    throw new Error(`cvToBuffer: expected buffer, got ${val.type}`);
-  }
-  return val.value;
-}
-function cvToBoolean(val) {
-  if (val.type !== "true" && val.type !== "false") {
-    throw new Error(`cvToBoolean: expected bool, got ${val.type}`);
-  }
-  return val.type === "true";
-}
-function cvToPrincipal(val) {
-  if (val.type !== "address" && val.type !== "contract") {
-    throw new Error(`cvToPrincipal: expected principal or contract, got ${val.type}`);
-  }
-  return val.value;
-}
-// src/clarity/abi/converters.ts
-class ClarityConversionError extends Error {
-  type;
-  value;
-  constructor(message, type, value) {
-    super(message);
-    this.type = type;
-    this.value = value;
-    this.name = "ClarityConversionError";
-  }
-}
-function jsToClarity(type, value) {
-  if (type === "none")
-    return null;
-  if (type === "uint128") {
-    if (!isUint128(value))
-      throw new ClarityConversionError("Invalid uint128 value", type, value);
-    return value;
-  }
-  if (type === "int128") {
-    if (!isInt128(value))
-      throw new ClarityConversionError("Invalid int128 value", type, value);
-    return value;
-  }
-  if (type === "bool") {
-    if (!isBool(value))
-      throw new ClarityConversionError("Invalid bool value", type, value);
-    return value;
-  }
-  if (type === "principal") {
-    if (!isPrincipal(value))
-      throw new ClarityConversionError("Invalid principal value", type, value);
-    return value;
-  }
-  if (type === "trait_reference") {
-    if (!isPrincipal(value))
-      throw new ClarityConversionError("Invalid trait_reference value", type, value);
-    return value;
-  }
-  if (isAbiStringAscii(type)) {
-    if (!isString(value))
-      throw new ClarityConversionError("Invalid string-ascii value", type, value);
-    const str = value;
-    for (let i = 0;i < str.length; i++) {
-      if (str.charCodeAt(i) > 127) {
-        throw new ClarityConversionError(`Non-ASCII character at position ${i}: '${str[i]}' (code ${str.charCodeAt(i)})`, type, value);
-      }
-    }
-    if (str.length > type["string-ascii"].length) {
-      throw new ClarityConversionError(`String length ${str.length} exceeds max ${type["string-ascii"].length}`, type, value);
-    }
-    return value;
-  }
-  if (isAbiStringUtf8(type)) {
-    if (!isString(value))
-      throw new ClarityConversionError("Invalid string-utf8 value", type, value);
-    const str = value;
-    const byteLength = new TextEncoder().encode(str).length;
-    if (byteLength > type["string-utf8"].length) {
-      throw new ClarityConversionError(`String byte length ${byteLength} exceeds max ${type["string-utf8"].length}`, type, value);
-    }
-    return value;
-  }
-  if (isAbiBuffer(type)) {
-    if (!isUint8Array(value))
-      throw new ClarityConversionError("Invalid buffer value", type, value);
-    const buff = value;
-    if (buff.length > type.buff.length) {
-      throw new ClarityConversionError(`Buffer length ${buff.length} exceeds max ${type.buff.length}`, type, value);
-    }
-    return value;
-  }
-  if (isAbiList(type)) {
-    if (!Array.isArray(value))
-      throw new ClarityConversionError("Expected array for list type", type, value);
-    if (value.length > type.list.length) {
-      throw new ClarityConversionError(`List length ${value.length} exceeds max ${type.list.length}`, type, value);
-    }
-    return value.map((item) => jsToClarity(type.list.type, item));
-  }
-  if (isAbiTuple(type)) {
-    if (typeof value !== "object" || value === null)
-      throw new ClarityConversionError("Expected object for tuple type", type, value);
-    const result = {};
-    for (const field of type.tuple) {
-      const camelKey = toCamelCase(field.name);
-      const hasOriginal = field.name in value;
-      const hasCamel = camelKey in value;
-      if (!hasOriginal && !hasCamel) {
-        throw new ClarityConversionError(`Missing tuple field: ${field.name}`, type, value);
-      }
-      const fieldValue = hasOriginal ? value[field.name] : value[camelKey];
-      result[field.name] = jsToClarity(field.type, fieldValue);
-    }
-    return result;
-  }
-  if (isAbiOptional(type)) {
-    if (value === null || value === undefined)
-      return null;
-    return jsToClarity(type.optional, value);
-  }
-  if (isAbiResponse(type)) {
-    if (typeof value !== "object" || value === null)
-      throw new ClarityConversionError("Expected object for response type", type, value);
-    const hasOk = "ok" in value;
-    const hasErr = "err" in value;
-    if (hasOk && !hasErr) {
-      return {
-        ok: jsToClarity(type.response.ok, value.ok)
-      };
-    }
-    if (hasErr && !hasOk) {
-      return {
-        err: jsToClarity(type.response.error, value.err)
-      };
-    }
-    throw new ClarityConversionError("Response must have exactly 'ok' or 'err' property", type, value);
-  }
-  throw new ClarityConversionError("Unknown Clarity type", type, value);
-}
-function prepareArgs(func, args) {
-  return func.args.map((arg) => {
-    if (!(arg.name in args)) {
-      throw new ClarityConversionError(`Missing argument: ${arg.name}`, arg.type, undefined);
-    }
-    return jsToClarity(arg.type, args[arg.name]);
-  });
-}
-function validateArgs(func, args) {
-  for (const arg of func.args) {
-    if (!(arg.name in args)) {
-      throw new ClarityConversionError(`Missing argument: ${arg.name}`, arg.type, undefined);
-    }
-    jsToClarity(arg.type, args[arg.name]);
-  }
-}
-function validateArgsArray(func, args) {
-  if (args.length !== func.args.length) {
-    throw new ClarityConversionError(`Expected ${func.args.length} arguments, got ${args.length}`, func.args[0]?.type ?? "bool", args);
-  }
-  func.args.forEach((arg, i) => {
-    jsToClarity(arg.type, args[i]);
-  });
-}
-// src/clarity/abi/classify.ts
-var TRAIT_STANDARDS = ["sip-009", "sip-010", "sip-013"];
-var STANDARDS = [
-  { id: "sip-010", abi: SIP010_ABI, optional: new Set(["get-token-uri"]) },
-  { id: "sip-009", abi: SIP009_ABI, optional: new Set(["get-token-uri"]) },
-  {
-    id: "sip-013",
-    abi: SIP013_ABI,
-    optional: new Set([
-      "transfer-memo",
-      "transfer-many",
-      "transfer-many-memo",
-      "get-token-uri",
-      "get-overall-balance",
-      "get-overall-supply"
-    ])
-  }
-];
-function indexByName(abi) {
-  const m = new Map;
-  for (const f of abi.functions)
-    m.set(f.name, f);
-  return m;
-}
-function conformsTo(candidate, spec) {
-  const fns = indexByName(candidate);
-  for (const required of spec.abi.functions) {
-    if (spec.optional.has(required.name))
-      continue;
-    const got = fns.get(required.name);
-    if (!got)
-      return false;
-    if (got.access !== required.access)
-      return false;
-    if (got.args.length !== required.args.length)
-      return false;
-  }
-  return true;
-}
-function classifyContract(abi) {
-  if (!abi || !Array.isArray(abi.functions))
-    return [];
-  return STANDARDS.filter((s) => conformsTo(abi, s)).map((s) => s.id);
-}
-function parseDeclaredStandards(claritySource) {
-  const out = new Set;
-  const matches = claritySource.matchAll(/\(impl-trait\s+[^)]+\)/gi);
-  for (const m of matches) {
-    const ref = m[0].toLowerCase();
-    if (ref.includes("sip-010") || ref.includes(".ft-trait"))
-      out.add("sip-010");
-    if (ref.includes("sip-009") || ref.includes("nft-trait"))
-      out.add("sip-009");
-    if (ref.includes("sip-013") || ref.includes("semi-fungible"))
-      out.add("sip-013");
-  }
-  return [...out];
-}
-// src/clarity/abi/normalize.ts
-function normalizeAccess(access) {
-  if (access === "read_only")
-    return "read-only";
-  return access;
-}
-function normalizeType(type) {
-  if (typeof type === "string") {
-    switch (type) {
-      case "uint128":
-      case "int128":
-      case "bool":
-      case "principal":
-      case "trait_reference":
-        return type;
-      default:
-        return type;
-    }
-  }
-  if (typeof type !== "object" || type === null) {
-    throw new Error(`Invalid ABI type: expected object, got ${typeof type}`);
-  }
-  const typeObj = type;
-  if ("buffer" in typeObj) {
-    const buffer = typeObj.buffer;
-    return {
-      buff: {
-        length: buffer?.length ?? 32
-      }
-    };
-  }
-  if ("buff" in typeObj) {
-    const buff = typeObj.buff;
-    return {
-      buff: {
-        length: buff?.length ?? 32
-      }
-    };
-  }
-  if ("string-ascii" in typeObj) {
-    const strAscii = typeObj["string-ascii"];
-    return {
-      "string-ascii": {
-        length: strAscii?.length ?? 256
-      }
-    };
-  }
-  if ("string-utf8" in typeObj) {
-    const strUtf8 = typeObj["string-utf8"];
-    return {
-      "string-utf8": {
-        length: strUtf8?.length ?? 256
-      }
-    };
-  }
-  if ("response" in typeObj) {
-    const response = typeObj.response;
-    return {
-      response: {
-        ok: normalizeType(response?.ok ?? "bool"),
-        error: normalizeType(response?.error ?? "uint128")
-      }
-    };
-  }
-  if ("optional" in typeObj) {
-    return {
-      optional: normalizeType(typeObj.optional)
-    };
-  }
-  if ("list" in typeObj) {
-    const list = typeObj.list;
-    return {
-      list: {
-        type: normalizeType(list?.type ?? "uint128"),
-        length: list?.length ?? 100
-      }
-    };
-  }
-  if ("tuple" in typeObj) {
-    const tuple = typeObj.tuple;
-    return {
-      tuple: tuple.map((field) => ({
-        name: field.name,
-        type: normalizeType(field.type)
-      }))
-    };
-  }
-  throw new Error(`Unknown ABI type structure: ${JSON.stringify(type)}`);
-}
-function normalizeFunction(func) {
-  const access = normalizeAccess(func.access);
-  const args = func.args ?? [];
-  const outputs = func.outputs;
-  return {
-    name: func.name,
-    access,
-    args: args.map((arg) => ({
-      name: arg.name,
-      type: normalizeType(arg.type)
-    })),
-    outputs: normalizeType(typeof outputs === "object" && outputs !== null && "type" in outputs ? outputs.type : outputs)
-  };
-}
-function normalizeMap(map) {
-  return {
-    name: map.name,
-    key: normalizeType(map.key),
-    value: normalizeType(map.value)
-  };
-}
-function normalizeVariable(variable) {
-  return {
-    name: variable.name,
-    type: normalizeType(variable.type),
-    access: variable.access
-  };
-}
-function normalizeFungibleToken(token) {
-  return { name: token.name };
-}
-function normalizeNonFungibleToken(token) {
-  return { name: token.name, type: normalizeType(token.type) };
-}
-function normalizeTraitDefinition(trait) {
-  const rawFunctions = Array.isArray(trait.functions) ? trait.functions : [];
-  const functions = [];
-  for (const func of rawFunctions) {
-    if (typeof func !== "object" || func === null)
-      continue;
-    const normalized = normalizeFunction(func);
-    if (normalized.access === "private")
-      continue;
-    functions.push(normalized);
-  }
-  return { name: trait.name, functions };
-}
-function normalizeAbi(abi) {
-  if (typeof abi !== "object" || abi === null) {
-    return { functions: [] };
-  }
-  const abiObj = abi;
-  const functions = [];
-  const maps = [];
-  const variables = [];
-  const fungibleTokens = [];
-  const nonFungibleTokens = [];
-  const implementedTraits = [];
-  const definedTraits = [];
-  if (Array.isArray(abiObj.functions)) {
-    for (const func of abiObj.functions) {
-      if (typeof func === "object" && func !== null) {
-        functions.push(normalizeFunction(func));
-      }
-    }
-  }
-  if (Array.isArray(abiObj.maps)) {
-    for (const map of abiObj.maps) {
-      if (typeof map === "object" && map !== null) {
-        maps.push(normalizeMap(map));
-      }
-    }
-  }
-  if (Array.isArray(abiObj.variables)) {
-    for (const variable of abiObj.variables) {
-      if (typeof variable === "object" && variable !== null) {
-        variables.push(normalizeVariable(variable));
-      }
-    }
-  }
-  if (Array.isArray(abiObj.fungible_tokens)) {
-    for (const token of abiObj.fungible_tokens) {
-      if (typeof token === "object" && token !== null) {
-        fungibleTokens.push(normalizeFungibleToken(token));
-      }
-    }
-  }
-  if (Array.isArray(abiObj.non_fungible_tokens)) {
-    for (const token of abiObj.non_fungible_tokens) {
-      if (typeof token === "object" && token !== null) {
-        nonFungibleTokens.push(normalizeNonFungibleToken(token));
-      }
-    }
-  }
-  if (Array.isArray(abiObj.implemented_traits)) {
-    for (const trait of abiObj.implemented_traits) {
-      if (typeof trait === "string")
-        implementedTraits.push(trait);
-    }
-  }
-  if (Array.isArray(abiObj.defined_traits)) {
-    for (const trait of abiObj.defined_traits) {
-      if (typeof trait === "object" && trait !== null) {
-        definedTraits.push(normalizeTraitDefinition(trait));
-      }
-    }
-  }
-  return {
-    functions,
-    maps: maps.length > 0 ? maps : undefined,
-    variables: variables.length > 0 ? variables : undefined,
-    fungible_tokens: fungibleTokens.length > 0 ? fungibleTokens : undefined,
-    non_fungible_tokens: nonFungibleTokens.length > 0 ? nonFungibleTokens : undefined,
-    implemented_traits: implementedTraits.length > 0 ? implementedTraits : undefined,
-    defined_traits: definedTraits.length > 0 ? definedTraits : undefined
-  };
-}
-
-//# debugId=80FCD2146E22850B64756E2164756E21
-//# sourceMappingURL=stacks-ee53k9j2.cjs.map