@leather.io/rpc 2.21.0 → 2.21.2

package/dist/index.cjs

@@ -1,782 +1,650 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  Bip322MessageTypesSchema: () => Bip322MessageTypesSchema,
-  RpcErrorCode: () => RpcErrorCode,
-  addressResponseBodySchema: () => addressResponseBodySchema,
-  addressSchema: () => addressSchema,
-  baseStacksTransactionConfigSchema: () => baseStacksTransactionConfigSchema,
-  bitcoinPaymentTypesSchema: () => bitcoinPaymentTypesSchema,
-  btcAddressBaseSchema: () => btcAddressBaseSchema,
-  btcAddressSchema: () => btcAddressSchema,
-  clarityValueSchema: () => clarityValueSchema,
-  createRequestEncoder: () => createRequestEncoder,
-  createRpcErrorBodySchema: () => createRpcErrorBodySchema,
-  createRpcErrorResponse: () => createRpcErrorResponse,
-  createRpcErrorResponseSchema: () => createRpcErrorResponseSchema,
-  createRpcRequestSchema: () => createRpcRequestSchema,
-  createRpcResponseSchema: () => createRpcResponseSchema,
-  createRpcSuccessResponse: () => createRpcSuccessResponse,
-  createRpcSuccessResponseSchema: () => createRpcSuccessResponseSchema,
-  cvAddressSchema: () => cvAddressSchema,
-  cvAsciiSchema: () => cvAsciiSchema,
-  cvBufferSchema: () => cvBufferSchema,
-  cvContractSchema: () => cvContractSchema,
-  cvErrSchema: () => cvErrSchema,
-  cvFalseSchema: () => cvFalseSchema,
-  cvIntSchema: () => cvIntSchema,
-  cvListSchema: () => cvListSchema,
-  cvNoneSchema: () => cvNoneSchema,
-  cvOkSchema: () => cvOkSchema,
-  cvSomeSchema: () => cvSomeSchema,
-  cvTrueSchema: () => cvTrueSchema,
-  cvTupleSchema: () => cvTupleSchema,
-  cvUintSchema: () => cvUintSchema,
-  cvUtf8Schema: () => cvUtf8Schema,
-  decodeBase64Json: () => decodeBase64Json,
-  defaultErrorSchema: () => defaultErrorSchema,
-  defineRpcEndpoint: () => defineRpcEndpoint,
-  encodeBase64Json: () => encodeBase64Json,
-  endpoints: () => endpoints,
-  getAddresses: () => getAddresses,
-  getInfo: () => getInfo,
-  open: () => open,
-  openSwap: () => openSwap,
-  parseEndpointRequest: () => parseEndpointRequest,
-  rpcBasePropsSchema: () => rpcBasePropsSchema,
-  rpcParameterSchema: () => rpcParameterSchema,
-  rpcSendTransferLegacyParamSchema: () => rpcSendTransferLegacyParamSchema,
-  rpcSendTransferNewParamsSchema: () => rpcSendTransferNewParamsSchema,
-  rpcSendTransferParamsSchema: () => rpcSendTransferParamsSchema,
-  sendTransfer: () => sendTransfer,
-  signMessage: () => signMessage,
-  signMessageRequestParamsSchema: () => signMessageRequestParamsSchema,
-  signPsbt: () => signPsbt,
-  signatureHash: () => signatureHash,
-  stacksTransactionDetailsSchema: () => stacksTransactionDetailsSchema,
-  stxAddressItemSchema: () => stxAddressItemSchema,
-  stxAddressSchema: () => stxAddressSchema,
-  stxCallContract: () => stxCallContract,
-  stxDeployContract: () => stxDeployContract,
-  stxDeployContractResponseBodySchema: () => stxDeployContractResponseBodySchema,
-  stxGetAddresses: () => stxGetAddresses,
-  stxGetAddressesResponseBodySchema: () => stxGetAddressesResponseBodySchema,
-  stxSignMessage: () => stxSignMessage,
-  stxSignMessageRequestBaseSchema: () => stxSignMessageRequestBaseSchema,
-  stxSignMessageRequestStructuredSchema: () => stxSignMessageRequestStructuredSchema,
-  stxSignMessageRequestUtf8Schema: () => stxSignMessageRequestUtf8Schema,
-  stxSignMessageTypeSchema: () => stxSignMessageTypeSchema,
-  stxSignStructuredMessage: () => stxSignStructuredMessage,
-  stxSignTransaction: () => stxSignTransaction,
-  stxSignTransactionRequestLeatherRpcParamsSchema: () => stxSignTransactionRequestLeatherRpcParamsSchema,
-  stxSignTransactionRequestSip30ParamsSchema: () => stxSignTransactionRequestSip30ParamsSchema,
-  stxTransferSip10Ft: () => stxTransferSip10Ft,
-  stxTransferSip9Nft: () => stxTransferSip9Nft,
-  stxTransferStx: () => stxTransferStx,
-  stxUpdateProfile: () => stxUpdateProfile,
-  stxUpdateProfileRequestParamsSchema: () => stxUpdateProfileRequestParamsSchema,
-  stxUpdateProfileResponseBodySchema: () => stxUpdateProfileResponseBodySchema,
-  supportedMethodSchema: () => supportedMethodSchema,
-  supportedMethods: () => supportedMethods,
-  testIsNumberOrArrayOfNumbers: () => testIsNumberOrArrayOfNumbers
-});
-module.exports = __toCommonJS(index_exports);
+let zod = require("zod");
+let __leather_io_utils = require("@leather.io/utils");
+let __leather_io_stacks = require("@leather.io/stacks");
 
-// src/methods/bitcoin/send-transfer.ts
-var import_zod2 = require("zod");
-
-// src/rpc/schemas.ts
-var import_zod = require("zod");
-var rpcParameterByPositionSchema = import_zod.z.string().array();
-var rpcParameterByNameSchema = import_zod.z.record(import_zod.z.string(), import_zod.z.unknown());
-var rpcParameterSchema = import_zod.z.union([
-  rpcParameterByPositionSchema,
-  rpcParameterByNameSchema,
-  import_zod.z.undefined()
+//#region src/rpc/schemas.ts
+const rpcParameterByPositionSchema = zod.z.string().array();
+const rpcParameterByNameSchema = zod.z.record(zod.z.string(), zod.z.unknown());
+const rpcParameterSchema = zod.z.union([
+	rpcParameterByPositionSchema,
+	rpcParameterByNameSchema,
+	zod.z.undefined()
 ]);
-var rpcBasePropsSchema = import_zod.z.object({
-  jsonrpc: import_zod.z.literal("2.0"),
-  id: import_zod.z.string()
+const rpcBasePropsSchema = zod.z.object({
+	jsonrpc: zod.z.literal("2.0"),
+	id: zod.z.string()
 });
 function createRpcRequestSchema(method, paramsSchema) {
-  if (!paramsSchema) return rpcBasePropsSchema.extend({ method: import_zod.z.literal(method) });
-  return rpcBasePropsSchema.extend({
-    method: import_zod.z.literal(method),
-    params: paramsSchema
-  });
+	if (!paramsSchema) return rpcBasePropsSchema.extend({ method: zod.z.literal(method) });
+	return rpcBasePropsSchema.extend({
+		method: zod.z.literal(method),
+		params: paramsSchema
+	});
 }
-var RpcErrorCode = /* @__PURE__ */ ((RpcErrorCode2) => {
-  RpcErrorCode2[RpcErrorCode2["PARSE_ERROR"] = -32700] = "PARSE_ERROR";
-  RpcErrorCode2[RpcErrorCode2["INVALID_REQUEST"] = -32600] = "INVALID_REQUEST";
-  RpcErrorCode2[RpcErrorCode2["METHOD_NOT_FOUND"] = -32601] = "METHOD_NOT_FOUND";
-  RpcErrorCode2[RpcErrorCode2["INVALID_PARAMS"] = -32602] = "INVALID_PARAMS";
-  RpcErrorCode2[RpcErrorCode2["INTERNAL_ERROR"] = -32603] = "INTERNAL_ERROR";
-  RpcErrorCode2[RpcErrorCode2["SERVER_ERROR"] = -32e3] = "SERVER_ERROR";
-  RpcErrorCode2[RpcErrorCode2["USER_REJECTION"] = 4001] = "USER_REJECTION";
-  RpcErrorCode2[RpcErrorCode2["METHOD_NOT_SUPPORTED"] = 4002] = "METHOD_NOT_SUPPORTED";
-  RpcErrorCode2[RpcErrorCode2["PERMISSION_DENIED"] = 7] = "PERMISSION_DENIED";
-  RpcErrorCode2[RpcErrorCode2["UNAUTHENTICATED"] = 16] = "UNAUTHENTICATED";
-  return RpcErrorCode2;
-})(RpcErrorCode || {});
-var rpcErrorCodeSchema = import_zod.z.enum(RpcErrorCode);
+let RpcErrorCode = /* @__PURE__ */ function(RpcErrorCode$1) {
+	RpcErrorCode$1[RpcErrorCode$1["PARSE_ERROR"] = -32700] = "PARSE_ERROR";
+	RpcErrorCode$1[RpcErrorCode$1["INVALID_REQUEST"] = -32600] = "INVALID_REQUEST";
+	RpcErrorCode$1[RpcErrorCode$1["METHOD_NOT_FOUND"] = -32601] = "METHOD_NOT_FOUND";
+	RpcErrorCode$1[RpcErrorCode$1["INVALID_PARAMS"] = -32602] = "INVALID_PARAMS";
+	RpcErrorCode$1[RpcErrorCode$1["INTERNAL_ERROR"] = -32603] = "INTERNAL_ERROR";
+	RpcErrorCode$1[RpcErrorCode$1["SERVER_ERROR"] = -32e3] = "SERVER_ERROR";
+	RpcErrorCode$1[RpcErrorCode$1["USER_REJECTION"] = 4001] = "USER_REJECTION";
+	RpcErrorCode$1[RpcErrorCode$1["METHOD_NOT_SUPPORTED"] = 4002] = "METHOD_NOT_SUPPORTED";
+	RpcErrorCode$1[RpcErrorCode$1["PERMISSION_DENIED"] = 7] = "PERMISSION_DENIED";
+	RpcErrorCode$1[RpcErrorCode$1["UNAUTHENTICATED"] = 16] = "UNAUTHENTICATED";
+	return RpcErrorCode$1;
+}({});
+const rpcErrorCodeSchema = zod.z.enum(RpcErrorCode);
 function createRpcErrorBodySchema(errorDataSchema) {
-  return import_zod.z.object({
-    code: import_zod.z.union([import_zod.z.number(), rpcErrorCodeSchema]),
-    message: import_zod.z.string(),
-    data: errorDataSchema.optional()
-  });
+	return zod.z.object({
+		code: zod.z.union([zod.z.number(), rpcErrorCodeSchema]),
+		message: zod.z.string(),
+		data: errorDataSchema.optional()
+	});
 }
 function createRpcErrorResponseSchema(errorSchema) {
-  return rpcBasePropsSchema.extend({ error: errorSchema });
+	return rpcBasePropsSchema.extend({ error: errorSchema });
 }
-var defaultErrorSchema = createRpcErrorBodySchema(import_zod.z.any());
+const defaultErrorSchema = createRpcErrorBodySchema(zod.z.any());
 function createRpcSuccessResponseSchema(resultSchema) {
-  return rpcBasePropsSchema.extend({ result: resultSchema });
+	return rpcBasePropsSchema.extend({ result: resultSchema });
 }
 function createRpcResponseSchema(resultSchema, errorSchema) {
-  return import_zod.z.union([
-    createRpcSuccessResponseSchema(resultSchema),
-    createRpcErrorResponseSchema(errorSchema)
-  ]);
+	return zod.z.union([createRpcSuccessResponseSchema(resultSchema), createRpcErrorResponseSchema(errorSchema)]);
 }
 function defineRpcEndpoint(props) {
-  const error = props.error ?? defaultErrorSchema;
-  if ("params" in props) {
-    return {
-      method: props.method,
-      params: props.params,
-      result: props.result,
-      error,
-      request: createRpcRequestSchema(props.method, props.params),
-      response: createRpcResponseSchema(props.result, error)
-    };
-  }
-  return {
-    method: props.method,
-    result: props.result,
-    error,
-    request: createRpcRequestSchema(props.method),
-    response: createRpcResponseSchema(props.result, error)
-  };
+	const error = props.error ?? defaultErrorSchema;
+	if ("params" in props) return {
+		method: props.method,
+		params: props.params,
+		result: props.result,
+		error,
+		request: createRpcRequestSchema(props.method, props.params),
+		response: createRpcResponseSchema(props.result, error)
+	};
+	return {
+		method: props.method,
+		result: props.result,
+		error,
+		request: createRpcRequestSchema(props.method),
+		response: createRpcResponseSchema(props.result, error)
+	};
 }
 
-// src/methods/bitcoin/send-transfer.ts
-var rpcSendTransferLegacyParamSchema = import_zod2.z.object({
-  account: import_zod2.z.number().optional(),
-  address: import_zod2.z.string(),
-  amount: import_zod2.z.coerce.string(),
-  network: import_zod2.z.string()
-});
-var transferRecipientParamSchema = import_zod2.z.object({
-  address: import_zod2.z.string(),
-  amount: import_zod2.z.coerce.string()
-});
-var rpcSendTransferNewParamsSchema = import_zod2.z.object({
-  account: import_zod2.z.number().optional(),
-  recipients: import_zod2.z.array(transferRecipientParamSchema),
-  network: import_zod2.z.string()
-});
-var rpcSendTransferParamsSchema = import_zod2.z.union([
-  rpcSendTransferLegacyParamSchema,
-  rpcSendTransferNewParamsSchema
-]);
-var sendTransfer = defineRpcEndpoint({
-  method: "sendTransfer",
-  params: rpcSendTransferParamsSchema,
-  result: import_zod2.z.object({
-    txid: import_zod2.z.string()
-  })
+//#endregion
+//#region src/methods/bitcoin/send-transfer.ts
+const rpcSendTransferLegacyParamSchema = zod.z.object({
+	account: zod.z.number().optional(),
+	address: zod.z.string(),
+	amount: zod.z.coerce.string(),
+	network: zod.z.string()
+});
+const transferRecipientParamSchema = zod.z.object({
+	address: zod.z.string(),
+	amount: zod.z.coerce.string()
+});
+const rpcSendTransferNewParamsSchema = zod.z.object({
+	account: zod.z.number().optional(),
+	recipients: zod.z.array(transferRecipientParamSchema),
+	network: zod.z.string()
+});
+const rpcSendTransferParamsSchema = zod.z.union([rpcSendTransferLegacyParamSchema, rpcSendTransferNewParamsSchema]);
+const sendTransfer = defineRpcEndpoint({
+	method: "sendTransfer",
+	params: rpcSendTransferParamsSchema,
+	result: zod.z.object({ txid: zod.z.string() })
 });
 
-// src/methods/bitcoin/sign-message.ts
-var import_zod3 = require("zod");
-var Bip322MessageTypesSchema = import_zod3.z.enum(["legacy", "bip322"]);
-var supportedPaymentTypesSchema = import_zod3.z.enum(["p2tr", "p2wpkh"]);
-var signMessageRequestParamsSchema = import_zod3.z.looseObject({
-  type: Bip322MessageTypesSchema.optional(),
-  account: import_zod3.z.number().optional(),
-  message: import_zod3.z.string(),
-  paymentType: supportedPaymentTypesSchema,
-  network: import_zod3.z.string().optional()
-});
-var signMessage = defineRpcEndpoint({
-  method: "signMessage",
-  params: signMessageRequestParamsSchema,
-  result: import_zod3.z.object({
-    signature: import_zod3.z.string(),
-    address: import_zod3.z.string(),
-    message: import_zod3.z.string()
-  })
+//#endregion
+//#region src/methods/bitcoin/sign-message.ts
+const Bip322MessageTypesSchema = zod.z.enum(["legacy", "bip322"]);
+const supportedPaymentTypesSchema = zod.z.enum(["p2tr", "p2wpkh"]);
+const signMessageRequestParamsSchema = zod.z.looseObject({
+	type: Bip322MessageTypesSchema.optional(),
+	account: zod.z.number().optional(),
+	message: zod.z.string(),
+	paymentType: supportedPaymentTypesSchema,
+	network: zod.z.string().optional()
+});
+const signMessage = defineRpcEndpoint({
+	method: "signMessage",
+	params: signMessageRequestParamsSchema,
+	result: zod.z.object({
+		signature: zod.z.string(),
+		address: zod.z.string(),
+		message: zod.z.string()
+	})
 });
 
-// src/methods/bitcoin/sign-psbt.ts
-var import_zod4 = require("zod");
-
-// src/rpc/helpers.ts
-var import_utils = require("@leather.io/utils");
+//#endregion
+//#region src/rpc/helpers.ts
 function testIsNumberOrArrayOfNumbers(value) {
-  if ((0, import_utils.isUndefined)(value)) return true;
-  return (0, import_utils.isNumberOrNumberList)(value);
+	if ((0, __leather_io_utils.isUndefined)(value)) return true;
+	return (0, __leather_io_utils.isNumberOrNumberList)(value);
 }
 function encodeBase64Json(payload) {
-  const jsonString = JSON.stringify(payload);
-  return btoa(jsonString);
+	const jsonString = JSON.stringify(payload);
+	return btoa(jsonString);
 }
 function decodeBase64Json(encodedPayload) {
-  const jsonString = atob(encodedPayload);
-  return JSON.parse(jsonString);
+	const jsonString = atob(encodedPayload);
+	return JSON.parse(jsonString);
 }
 function createRequestEncoder(schema) {
-  function encode(request) {
-    return encodeBase64Json(schema.parse(request));
-  }
-  function decode(encodedRequest) {
-    const parsedJson = decodeBase64Json(encodedRequest);
-    return schema.parse(parsedJson);
-  }
-  return { encode, decode };
+	function encode(request) {
+		return encodeBase64Json(schema.parse(request));
+	}
+	function decode(encodedRequest) {
+		const parsedJson = decodeBase64Json(encodedRequest);
+		return schema.parse(parsedJson);
+	}
+	return {
+		encode,
+		decode
+	};
 }
 
-// src/methods/bitcoin/sign-psbt.ts
-var signatureHash = {
-  DEFAULT: 0,
-  ALL: 1,
-  NONE: 2,
-  SINGLE: 3,
-  ALL_ANYONECANPAY: 129,
-  NONE_ANYONECANPAY: 130,
-  SINGLE_ANYONECANPAY: 131
+//#endregion
+//#region src/methods/bitcoin/sign-psbt.ts
+/**
+* DEFAULT       -- all inputs, all outputs
+* ALL           -- all inputs, all outputs
+* NONE          -- all inputs, no outputs
+* SINGLE        -- all inputs, one output of the same index
+* ALL + ANYONE  -- one input, all outputs
+* NONE + ANYONE -- one input, no outputs
+* SINGLE        -- one inputs, one output of the same index
+*/
+const signatureHash = {
+	DEFAULT: 0,
+	ALL: 1,
+	NONE: 2,
+	SINGLE: 3,
+	ALL_ANYONECANPAY: 129,
+	NONE_ANYONECANPAY: 130,
+	SINGLE_ANYONECANPAY: 131
 };
-var signPsbtRequestParamsSchema = import_zod4.z.object({
-  account: import_zod4.z.number().optional(),
-  allowedSighash: import_zod4.z.array(import_zod4.z.any()).optional(),
-  broadcast: import_zod4.z.boolean().optional(),
-  hex: import_zod4.z.string(),
-  network: import_zod4.z.string().optional(),
-  signAtIndex: import_zod4.z.union([import_zod4.z.number(), import_zod4.z.array(import_zod4.z.number())]).optional().refine(testIsNumberOrArrayOfNumbers)
-});
-var signPsbtResponseBodySchema = import_zod4.z.object({
-  hex: import_zod4.z.string(),
-  txid: import_zod4.z.string().optional()
-});
-var signPsbt = defineRpcEndpoint({
-  method: "signPsbt",
-  params: signPsbtRequestParamsSchema,
-  result: signPsbtResponseBodySchema
+const signPsbtRequestParamsSchema = zod.z.object({
+	account: zod.z.number().optional(),
+	allowedSighash: zod.z.array(zod.z.any()).optional(),
+	broadcast: zod.z.boolean().optional(),
+	hex: zod.z.string(),
+	network: zod.z.string().optional(),
+	signAtIndex: zod.z.union([zod.z.number(), zod.z.array(zod.z.number())]).optional().refine(testIsNumberOrArrayOfNumbers)
+});
+const signPsbtResponseBodySchema = zod.z.object({
+	hex: zod.z.string(),
+	txid: zod.z.string().optional()
+});
+const signPsbt = defineRpcEndpoint({
+	method: "signPsbt",
+	params: signPsbtRequestParamsSchema,
+	result: signPsbtResponseBodySchema
 });
 
-// src/methods/get-addresses.ts
-var import_zod5 = require("zod");
-var bitcoinPaymentTypesSchema = import_zod5.z.enum(["p2pkh", "p2sh", "p2wpkh-p2sh", "p2wpkh", "p2tr"]);
-var btcAddressBaseSchema = import_zod5.z.object({
-  symbol: import_zod5.z.literal("BTC"),
-  type: bitcoinPaymentTypesSchema,
-  address: import_zod5.z.string(),
-  publicKey: import_zod5.z.string(),
-  derivationPath: import_zod5.z.string(),
-  descriptor: import_zod5.z.string()
-});
-var nativeSegwitAddressSchema = btcAddressBaseSchema.extend({
-  type: import_zod5.z.literal("p2wpkh")
-});
-var taprootAddressSchema = btcAddressBaseSchema.extend({
-  type: import_zod5.z.literal("p2tr"),
-  tweakedPublicKey: import_zod5.z.string()
-});
-var btcAddressSchema = import_zod5.z.discriminatedUnion("type", [
-  nativeSegwitAddressSchema,
-  taprootAddressSchema
+//#endregion
+//#region src/methods/get-addresses.ts
+const bitcoinPaymentTypesSchema = zod.z.enum([
+	"p2pkh",
+	"p2sh",
+	"p2wpkh-p2sh",
+	"p2wpkh",
+	"p2tr"
 ]);
-var stxAddressSchema = import_zod5.z.object({
-  symbol: import_zod5.z.literal("STX"),
-  address: import_zod5.z.string(),
-  publicKey: import_zod5.z.string()
-});
-var addressSchema = import_zod5.z.union([btcAddressSchema, stxAddressSchema]);
-var addressResponseBodySchema = import_zod5.z.object({ addresses: import_zod5.z.array(addressSchema) });
-var getAddresses = defineRpcEndpoint({
-  method: "getAddresses",
-  params: import_zod5.z.object({ network: import_zod5.z.string().optional() }).optional(),
-  result: addressResponseBodySchema
+const btcAddressBaseSchema = zod.z.object({
+	symbol: zod.z.literal("BTC"),
+	type: bitcoinPaymentTypesSchema,
+	address: zod.z.string(),
+	publicKey: zod.z.string(),
+	derivationPath: zod.z.string(),
+	descriptor: zod.z.string()
+});
+const nativeSegwitAddressSchema = btcAddressBaseSchema.extend({ type: zod.z.literal("p2wpkh") });
+const taprootAddressSchema = btcAddressBaseSchema.extend({
+	type: zod.z.literal("p2tr"),
+	tweakedPublicKey: zod.z.string()
+});
+const btcAddressSchema = zod.z.discriminatedUnion("type", [nativeSegwitAddressSchema, taprootAddressSchema]);
+const stxAddressSchema = zod.z.object({
+	symbol: zod.z.literal("STX"),
+	address: zod.z.string(),
+	publicKey: zod.z.string()
+});
+const addressSchema = zod.z.union([btcAddressSchema, stxAddressSchema]);
+const addressResponseBodySchema = zod.z.object({ addresses: zod.z.array(addressSchema) });
+const getAddresses = defineRpcEndpoint({
+	method: "getAddresses",
+	params: zod.z.object({ network: zod.z.string().optional() }).optional(),
+	result: addressResponseBodySchema
 });
 
-// src/methods/get-info.ts
-var import_zod6 = require("zod");
-var getInfoResponseBodySchema = import_zod6.z.object({
-  version: import_zod6.z.string(),
-  supportedMethods: import_zod6.z.array(import_zod6.z.string()).optional(),
-  platform: import_zod6.z.union([import_zod6.z.literal("mobile"), import_zod6.z.literal("extension")])
+//#endregion
+//#region src/methods/get-info.ts
+const getInfoResponseBodySchema = zod.z.object({
+	version: zod.z.string(),
+	supportedMethods: zod.z.array(zod.z.string()).optional(),
+	platform: zod.z.union([zod.z.literal("mobile"), zod.z.literal("extension")])
 });
-var getInfo = defineRpcEndpoint({
-  method: "getInfo",
-  result: getInfoResponseBodySchema
+const getInfo = defineRpcEndpoint({
+	method: "getInfo",
+	result: getInfoResponseBodySchema
 });
 
-// src/methods/open.ts
-var import_zod7 = require("zod");
-var open = defineRpcEndpoint({
-  method: "open",
-  params: import_zod7.z.object({ mode: import_zod7.z.enum(["fullpage", "popup"]) }).default({ mode: "popup" }),
-  result: import_zod7.z.object({ success: import_zod7.z.literal(true) })
+//#endregion
+//#region src/methods/open.ts
+const open = defineRpcEndpoint({
+	method: "open",
+	params: zod.z.object({ mode: zod.z.enum(["fullpage", "popup"]) }).default({ mode: "popup" }),
+	result: zod.z.object({ success: zod.z.literal(true) })
 });
 
-// src/methods/open-swap.ts
-var import_zod8 = require("zod");
-var openSwapRequestParamsSchema = import_zod8.z.object({
-  base: import_zod8.z.string(),
-  quote: import_zod8.z.string()
-});
-var openSwapResponseBodySchema = import_zod8.z.object({
-  message: import_zod8.z.string()
-});
-var openSwap = defineRpcEndpoint({
-  method: "openSwap",
-  params: openSwapRequestParamsSchema,
-  result: openSwapResponseBodySchema
+//#endregion
+//#region src/methods/open-swap.ts
+const openSwapRequestParamsSchema = zod.z.object({
+	base: zod.z.string(),
+	quote: zod.z.string()
+});
+const openSwapResponseBodySchema = zod.z.object({ message: zod.z.string() });
+const openSwap = defineRpcEndpoint({
+	method: "openSwap",
+	params: openSwapRequestParamsSchema,
+	result: openSwapResponseBodySchema
 });
 
-// src/methods/stacks/stx-call-contract.ts
-var import_zod10 = require("zod");
-
-// src/methods/stacks/_stacks-helpers.ts
-var import_zod9 = require("zod");
-var stacksTransactionDetailsSchema = import_zod9.z.object({
-  txid: import_zod9.z.string(),
-  transaction: import_zod9.z.string()
-});
-var baseStacksTransactionConfigSchema = import_zod9.z.object({
-  address: import_zod9.z.string().optional(),
-  network: import_zod9.z.union([
-    import_zod9.z.literal("mainnet"),
-    import_zod9.z.literal("testnet"),
-    import_zod9.z.literal("regtest"),
-    import_zod9.z.literal("devnet"),
-    import_zod9.z.literal("mocknet"),
-    import_zod9.z.string()
-  ]).optional(),
-  fee: import_zod9.z.coerce.number().optional(),
-  nonce: import_zod9.z.coerce.number().optional(),
-  // add pc later when imported from stacks.js
-  postConditions: import_zod9.z.array(import_zod9.z.string()).optional(),
-  postConditionMode: import_zod9.z.union([import_zod9.z.literal("allow"), import_zod9.z.literal("deny")]).optional(),
-  sponsored: import_zod9.z.boolean().optional()
+//#endregion
+//#region src/methods/stacks/_stacks-helpers.ts
+const stacksTransactionDetailsSchema = zod.z.object({
+	txid: zod.z.string(),
+	transaction: zod.z.string()
+});
+const baseStacksTransactionConfigSchema = zod.z.object({
+	address: zod.z.string().optional(),
+	network: zod.z.union([
+		zod.z.literal("mainnet"),
+		zod.z.literal("testnet"),
+		zod.z.literal("regtest"),
+		zod.z.literal("devnet"),
+		zod.z.literal("mocknet"),
+		zod.z.string()
+	]).optional(),
+	fee: zod.z.coerce.number().optional(),
+	nonce: zod.z.coerce.number().optional(),
+	postConditions: zod.z.array(zod.z.string()).optional(),
+	postConditionMode: zod.z.union([zod.z.literal("allow"), zod.z.literal("deny")]).optional(),
+	sponsored: zod.z.boolean().optional()
 });
 
-// src/methods/stacks/stx-call-contract.ts
-var stxCallContract = defineRpcEndpoint({
-  method: "stx_callContract",
-  params: import_zod10.z.intersection(
-    import_zod10.z.object({
-      contract: import_zod10.z.string(),
-      functionName: import_zod10.z.string(),
-      functionArgs: import_zod10.z.array(import_zod10.z.string()).optional()
-    }),
-    baseStacksTransactionConfigSchema
-  ),
-  result: stacksTransactionDetailsSchema
+//#endregion
+//#region src/methods/stacks/stx-call-contract.ts
+const stxCallContract = defineRpcEndpoint({
+	method: "stx_callContract",
+	params: zod.z.intersection(zod.z.object({
+		contract: zod.z.string(),
+		functionName: zod.z.string(),
+		functionArgs: zod.z.array(zod.z.string()).optional()
+	}), baseStacksTransactionConfigSchema),
+	result: stacksTransactionDetailsSchema
 });
 
-// src/methods/stacks/stx-deploy-contract.ts
-var import_zod11 = require("zod");
-var import_stacks = require("@leather.io/stacks");
-var stxDeployContractResponseBodySchema = stacksTransactionDetailsSchema;
-var stxDeployContract = defineRpcEndpoint({
-  method: "stx_deployContract",
-  params: import_zod11.z.intersection(
-    import_zod11.z.object({
-      name: import_zod11.z.string(),
-      clarityCode: import_stacks.clarityContractSchema,
-      clarityVersion: import_zod11.z.coerce.number().optional()
-    }),
-    baseStacksTransactionConfigSchema
-  ),
-  result: stxDeployContractResponseBodySchema
+//#endregion
+//#region src/methods/stacks/stx-deploy-contract.ts
+const stxDeployContractResponseBodySchema = stacksTransactionDetailsSchema;
+const stxDeployContract = defineRpcEndpoint({
+	method: "stx_deployContract",
+	params: zod.z.intersection(zod.z.object({
+		name: zod.z.string(),
+		clarityCode: __leather_io_stacks.clarityContractSchema,
+		clarityVersion: zod.z.coerce.number().optional()
+	}), baseStacksTransactionConfigSchema),
+	result: stxDeployContractResponseBodySchema
 });
 
-// src/methods/stacks/stx-get-addresses.ts
-var import_zod12 = require("zod");
-var stxAddressItemSchema = import_zod12.z.object({
-  address: import_zod12.z.string(),
-  publicKey: import_zod12.z.string(),
-  derivationPath: import_zod12.z.string()
-});
-var stxGetAddressesResponseBodySchema = import_zod12.z.array(stxAddressItemSchema);
-var stxGetAddresses = defineRpcEndpoint({
-  method: "stx_getAddresses",
-  params: import_zod12.z.object({ network: import_zod12.z.string().optional() }).optional(),
-  result: stxGetAddressesResponseBodySchema
+//#endregion
+//#region src/methods/stacks/stx-get-addresses.ts
+const stxAddressItemSchema = zod.z.object({
+	address: zod.z.string(),
+	publicKey: zod.z.string(),
+	derivationPath: zod.z.string()
+});
+const stxGetAddressesResponseBodySchema = zod.z.array(stxAddressItemSchema);
+const stxGetAddresses = defineRpcEndpoint({
+	method: "stx_getAddresses",
+	params: zod.z.object({ network: zod.z.string().optional() }).optional(),
+	result: stxGetAddressesResponseBodySchema
 });
 
-// src/methods/stacks/stx-get-networks.ts
-var import_zod13 = require("zod");
-var stxGetNetworks = defineRpcEndpoint({
-  method: "stx_getNetworks",
-  result: import_zod13.z.object({
-    active: import_zod13.z.string(),
-    networks: import_zod13.z.array(
-      import_zod13.z.object({
-        id: import_zod13.z.string(),
-        chainId: import_zod13.z.string(),
-        transactionVersion: import_zod13.z.string()
-      })
-    )
-  })
+//#endregion
+//#region src/methods/stacks/stx-get-networks.ts
+const stxGetNetworks = defineRpcEndpoint({
+	method: "stx_getNetworks",
+	result: zod.z.object({
+		active: zod.z.string(),
+		networks: zod.z.array(zod.z.object({
+			id: zod.z.string(),
+			chainId: zod.z.string(),
+			transactionVersion: zod.z.string()
+		}))
+	})
 });
 
-// src/methods/stacks/stx-sign-message.ts
-var import_zod14 = require("zod");
-var stxSignMessageTypeSchema = import_zod14.z.enum(["utf8", "structured"]);
-var stxSignMessageRequestBaseSchema = import_zod14.z.object({
-  messageType: stxSignMessageTypeSchema.optional().default("utf8"),
-  network: import_zod14.z.optional(import_zod14.z.enum(["mainnet", "testnet", "devnet", "mocknet"]))
-});
-var stxSignMessageRequestUtf8Schema = stxSignMessageRequestBaseSchema.and(
-  import_zod14.z.object({
-    messageType: import_zod14.z.literal("utf8").default("utf8"),
-    message: import_zod14.z.string()
-  })
-);
-var stxSignMessageRequestStructuredSchema = stxSignMessageRequestBaseSchema.and(
-  import_zod14.z.object({
-    messageType: import_zod14.z.literal("structured"),
-    domain: import_zod14.z.string(),
-    message: import_zod14.z.string()
-  })
-);
-var stxSignMessage = defineRpcEndpoint({
-  method: "stx_signMessage",
-  params: import_zod14.z.union([stxSignMessageRequestUtf8Schema, stxSignMessageRequestStructuredSchema]),
-  result: import_zod14.z.object({
-    signature: import_zod14.z.string(),
-    publicKey: import_zod14.z.string()
-  })
+//#endregion
+//#region src/methods/stacks/stx-sign-message.ts
+const stxSignMessageTypeSchema = zod.z.enum(["utf8", "structured"]);
+const stxSignMessageRequestBaseSchema = zod.z.object({
+	messageType: stxSignMessageTypeSchema.optional().default("utf8"),
+	network: zod.z.optional(zod.z.enum([
+		"mainnet",
+		"testnet",
+		"devnet",
+		"mocknet"
+	]))
+});
+const stxSignMessageRequestUtf8Schema = stxSignMessageRequestBaseSchema.and(zod.z.object({
+	messageType: zod.z.literal("utf8").default("utf8"),
+	message: zod.z.string()
+}));
+const stxSignMessageRequestStructuredSchema = stxSignMessageRequestBaseSchema.and(zod.z.object({
+	messageType: zod.z.literal("structured"),
+	domain: zod.z.string(),
+	message: zod.z.string()
+}));
+const stxSignMessage = defineRpcEndpoint({
+	method: "stx_signMessage",
+	params: zod.z.union([stxSignMessageRequestUtf8Schema, stxSignMessageRequestStructuredSchema]),
+	result: zod.z.object({
+		signature: zod.z.string(),
+		publicKey: zod.z.string()
+	})
 });
 
-// src/methods/stacks/stx-sign-structured-message.ts
-var import_zod15 = require("zod");
-var stxSignStructuredMessage = defineRpcEndpoint({
-  method: "stx_signStructuredMessage",
-  params: import_zod15.z.object({
-    domain: import_zod15.z.string(),
-    message: import_zod15.z.string()
-  }),
-  result: import_zod15.z.object({
-    signature: import_zod15.z.string(),
-    publicKey: import_zod15.z.string()
-  })
+//#endregion
+//#region src/methods/stacks/stx-sign-structured-message.ts
+const stxSignStructuredMessage = defineRpcEndpoint({
+	method: "stx_signStructuredMessage",
+	params: zod.z.object({
+		domain: zod.z.string(),
+		message: zod.z.string()
+	}),
+	result: zod.z.object({
+		signature: zod.z.string(),
+		publicKey: zod.z.string()
+	})
 });
 
-// src/methods/stacks/stx-sign-transaction.ts
-var import_zod16 = require("zod");
-var stxSignTransactionRequestLeatherRpcParamsSchema = import_zod16.z.object({
-  txHex: import_zod16.z.string(),
-  stxAddress: import_zod16.z.string().optional(),
-  attachment: import_zod16.z.string().optional(),
-  accountIndex: import_zod16.z.string().optional(),
-  network: import_zod16.z.string().optional()
-});
-var stxSignTransactionRequestSip30ParamsSchema = import_zod16.z.object({
-  transaction: import_zod16.z.string(),
-  network: import_zod16.z.string().optional()
-});
-var stxSignTransaction = defineRpcEndpoint({
-  method: "stx_signTransaction",
-  params: import_zod16.z.union([
-    stxSignTransactionRequestLeatherRpcParamsSchema,
-    stxSignTransactionRequestSip30ParamsSchema
-  ]),
-  result: import_zod16.z.object({
-    transaction: import_zod16.z.string(),
-    txHex: import_zod16.z.string()
-  })
+//#endregion
+//#region src/methods/stacks/stx-sign-transaction.ts
+const stxSignTransactionRequestLeatherRpcParamsSchema = zod.z.object({
+	txHex: zod.z.string(),
+	stxAddress: zod.z.string().optional(),
+	attachment: zod.z.string().optional(),
+	accountIndex: zod.z.string().optional(),
+	network: zod.z.string().optional()
+});
+const stxSignTransactionRequestSip30ParamsSchema = zod.z.object({
+	transaction: zod.z.string(),
+	network: zod.z.string().optional()
+});
+const stxSignTransaction = defineRpcEndpoint({
+	method: "stx_signTransaction",
+	params: zod.z.union([stxSignTransactionRequestLeatherRpcParamsSchema, stxSignTransactionRequestSip30ParamsSchema]),
+	result: zod.z.object({
+		transaction: zod.z.string(),
+		txHex: zod.z.string()
+	})
 });
 
-// src/methods/stacks/stx-transfer-sip9-nft.ts
-var import_zod17 = require("zod");
-var stxTransferSip9Nft = defineRpcEndpoint({
-  method: "stx_transferSip9Nft",
-  params: import_zod17.z.intersection(
-    import_zod17.z.looseObject({
-      recipient: import_zod17.z.string(),
-      asset: import_zod17.z.string(),
-      assetId: import_zod17.z.string()
-    }),
-    baseStacksTransactionConfigSchema
-  ),
-  result: stacksTransactionDetailsSchema
+//#endregion
+//#region src/methods/stacks/stx-transfer-sip9-nft.ts
+const stxTransferSip9Nft = defineRpcEndpoint({
+	method: "stx_transferSip9Nft",
+	params: zod.z.intersection(zod.z.looseObject({
+		recipient: zod.z.string(),
+		asset: zod.z.string(),
+		assetId: zod.z.string()
+	}), baseStacksTransactionConfigSchema),
+	result: stacksTransactionDetailsSchema
 });
 
-// src/methods/stacks/stx-transfer-sip10-ft.ts
-var import_zod18 = require("zod");
-var stxTransferSip10Ft = defineRpcEndpoint({
-  method: "stx_transferSip10Ft",
-  params: import_zod18.z.intersection(
-    import_zod18.z.looseObject({
-      recipient: import_zod18.z.string(),
-      asset: import_zod18.z.string(),
-      amount: import_zod18.z.coerce.number()
-    }),
-    baseStacksTransactionConfigSchema
-  ),
-  result: stacksTransactionDetailsSchema
+//#endregion
+//#region src/methods/stacks/stx-transfer-sip10-ft.ts
+const stxTransferSip10Ft = defineRpcEndpoint({
+	method: "stx_transferSip10Ft",
+	params: zod.z.intersection(zod.z.looseObject({
+		recipient: zod.z.string(),
+		asset: zod.z.string(),
+		amount: zod.z.coerce.number()
+	}), baseStacksTransactionConfigSchema),
+	result: stacksTransactionDetailsSchema
 });
 
-// src/methods/stacks/stx-transfer-stx.ts
-var import_zod19 = require("zod");
-var import_stacks2 = require("@leather.io/stacks");
-var stxTransferStx = defineRpcEndpoint({
-  method: "stx_transferStx",
-  params: import_zod19.z.intersection(
-    import_zod19.z.object({
-      recipient: import_stacks2.principalSchema,
-      amount: import_zod19.z.coerce.number().int("Amount must be an integer describing \xB5STX"),
-      memo: import_stacks2.stacksMemoSchema.optional()
-    }),
-    baseStacksTransactionConfigSchema
-  ),
-  result: stacksTransactionDetailsSchema
+//#endregion
+//#region src/methods/stacks/stx-transfer-stx.ts
+const stxTransferStx = defineRpcEndpoint({
+	method: "stx_transferStx",
+	params: zod.z.intersection(zod.z.object({
+		recipient: __leather_io_stacks.principalSchema,
+		amount: zod.z.coerce.number().int("Amount must be an integer describing µSTX"),
+		memo: __leather_io_stacks.stacksMemoSchema.optional()
+	}), baseStacksTransactionConfigSchema),
+	result: stacksTransactionDetailsSchema
 });
 
-// src/methods/stacks/stx-update-profile.ts
-var import_zod20 = require("zod");
-var stxUpdateProfileRequestParamsSchema = import_zod20.z.object({
-  // schema.org/Person
-  person: import_zod20.z.looseObject({})
-});
-var stxUpdateProfileResponseBodySchema = stacksTransactionDetailsSchema;
-var stxUpdateProfile = defineRpcEndpoint({
-  method: "stx_updateProfile",
-  params: stxUpdateProfileRequestParamsSchema,
-  result: stxUpdateProfileResponseBodySchema
+//#endregion
+//#region src/methods/stacks/stx-update-profile.ts
+const stxUpdateProfileRequestParamsSchema = zod.z.object({ person: zod.z.looseObject({}) });
+const stxUpdateProfileResponseBodySchema = stacksTransactionDetailsSchema;
+const stxUpdateProfile = defineRpcEndpoint({
+	method: "stx_updateProfile",
+	params: stxUpdateProfileRequestParamsSchema,
+	result: stxUpdateProfileResponseBodySchema
 });
 
-// src/methods/supported-methods.ts
-var import_zod21 = require("zod");
-var supportedMethodSchema = import_zod21.z.object({
-  name: import_zod21.z.string(),
-  docsUrl: import_zod21.z.union([import_zod21.z.string(), import_zod21.z.array(import_zod21.z.string())])
-});
-var supportedMethods = defineRpcEndpoint({
-  method: "supportedMethods",
-  result: import_zod21.z.object({
-    documentation: import_zod21.z.string(),
-    methods: import_zod21.z.array(supportedMethodSchema)
-  })
+//#endregion
+//#region src/methods/supported-methods.ts
+const supportedMethodSchema = zod.z.object({
+	name: zod.z.string(),
+	docsUrl: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())])
+});
+const supportedMethods = defineRpcEndpoint({
+	method: "supportedMethods",
+	result: zod.z.object({
+		documentation: zod.z.string(),
+		methods: zod.z.array(supportedMethodSchema)
+	})
 });
 
-// src/methods/stacks/_clarity-values.ts
-var import_zod22 = require("zod");
-var cvIntSchema = import_zod22.z.object({
-  type: import_zod22.z.literal("int"),
-  value: import_zod22.z.coerce.string()
-});
-var cvUintSchema = import_zod22.z.object({
-  type: import_zod22.z.literal("uint"),
-  value: import_zod22.z.coerce.string()
-});
-var cvBufferSchema = import_zod22.z.object({
-  type: import_zod22.z.literal("buffer"),
-  value: import_zod22.z.string()
-});
-var cvTrueSchema = import_zod22.z.object({
-  type: import_zod22.z.literal("true")
-});
-var cvFalseSchema = import_zod22.z.object({
-  type: import_zod22.z.literal("false")
-});
-var cvAddressSchema = import_zod22.z.object({
-  type: import_zod22.z.literal("address"),
-  value: import_zod22.z.string()
-});
-var cvContractSchema = import_zod22.z.object({
-  type: import_zod22.z.literal("contract"),
-  value: import_zod22.z.string().refine((value) => value.includes("."), {
-    message: "Stacks contract principals are denoted with a dot"
-  })
-});
-var cvAsciiSchema = import_zod22.z.object({
-  type: import_zod22.z.literal("ascii"),
-  value: import_zod22.z.string()
-});
-var cvUtf8Schema = import_zod22.z.object({
-  type: import_zod22.z.literal("utf8"),
-  value: import_zod22.z.string()
-});
-var cvOkSchema = import_zod22.z.object({
-  type: import_zod22.z.literal("ok"),
-  value: import_zod22.z.lazy(() => clarityValueSchema)
+//#endregion
+//#region src/methods/stacks/_clarity-values.ts
+const cvIntSchema = zod.z.object({
+	type: zod.z.literal("int"),
+	value: zod.z.coerce.string()
+});
+const cvUintSchema = zod.z.object({
+	type: zod.z.literal("uint"),
+	value: zod.z.coerce.string()
+});
+const cvBufferSchema = zod.z.object({
+	type: zod.z.literal("buffer"),
+	value: zod.z.string()
+});
+const cvTrueSchema = zod.z.object({ type: zod.z.literal("true") });
+const cvFalseSchema = zod.z.object({ type: zod.z.literal("false") });
+const cvAddressSchema = zod.z.object({
+	type: zod.z.literal("address"),
+	value: zod.z.string()
+});
+const cvContractSchema = zod.z.object({
+	type: zod.z.literal("contract"),
+	value: zod.z.string().refine((value) => value.includes("."), { message: "Stacks contract principals are denoted with a dot" })
+});
+const cvAsciiSchema = zod.z.object({
+	type: zod.z.literal("ascii"),
+	value: zod.z.string()
+});
+const cvUtf8Schema = zod.z.object({
+	type: zod.z.literal("utf8"),
+	value: zod.z.string()
+});
+const cvOkSchema = zod.z.object({
+	type: zod.z.literal("ok"),
+	value: zod.z.lazy(() => clarityValueSchema)
 }).transform((value) => value);
-var cvErrSchema = import_zod22.z.object({
-  type: import_zod22.z.literal("err"),
-  value: import_zod22.z.lazy(() => clarityValueSchema)
-});
-var cvNoneSchema = import_zod22.z.object({
-  type: import_zod22.z.literal("none")
-});
-var cvSomeSchema = import_zod22.z.object({
-  type: import_zod22.z.literal("some"),
-  value: import_zod22.z.lazy(() => clarityValueSchema)
-});
-var cvListSchema = import_zod22.z.object({
-  type: import_zod22.z.literal("list"),
-  value: import_zod22.z.array(import_zod22.z.lazy(() => clarityValueSchema))
-});
-var cvTupleSchema = import_zod22.z.object({
-  type: import_zod22.z.literal("tuple"),
-  value: import_zod22.z.record(
-    import_zod22.z.string(),
-    import_zod22.z.lazy(() => clarityValueSchema)
-  )
-});
-var clarityValueSchema = import_zod22.z.union([
-  cvIntSchema,
-  cvUintSchema,
-  cvBufferSchema,
-  cvTrueSchema,
-  cvFalseSchema,
-  cvAddressSchema,
-  cvContractSchema,
-  cvOkSchema,
-  cvErrSchema,
-  cvNoneSchema,
-  cvSomeSchema,
-  cvListSchema,
-  cvTupleSchema,
-  cvAsciiSchema,
-  cvUtf8Schema
+const cvErrSchema = zod.z.object({
+	type: zod.z.literal("err"),
+	value: zod.z.lazy(() => clarityValueSchema)
+});
+const cvNoneSchema = zod.z.object({ type: zod.z.literal("none") });
+const cvSomeSchema = zod.z.object({
+	type: zod.z.literal("some"),
+	value: zod.z.lazy(() => clarityValueSchema)
+});
+const cvListSchema = zod.z.object({
+	type: zod.z.literal("list"),
+	value: zod.z.array(zod.z.lazy(() => clarityValueSchema))
+});
+const cvTupleSchema = zod.z.object({
+	type: zod.z.literal("tuple"),
+	value: zod.z.record(zod.z.string(), zod.z.lazy(() => clarityValueSchema))
+});
+const clarityValueSchema = zod.z.union([
+	cvIntSchema,
+	cvUintSchema,
+	cvBufferSchema,
+	cvTrueSchema,
+	cvFalseSchema,
+	cvAddressSchema,
+	cvContractSchema,
+	cvOkSchema,
+	cvErrSchema,
+	cvNoneSchema,
+	cvSomeSchema,
+	cvListSchema,
+	cvTupleSchema,
+	cvAsciiSchema,
+	cvUtf8Schema
 ]);
 
-// src/index.ts
-var endpoints = {
-  getAddresses,
-  getInfo,
-  open,
-  openSwap,
-  sendTransfer,
-  signMessage,
-  signPsbt,
-  stxCallContract,
-  stxDeployContract,
-  stxGetAddresses,
-  stxGetNetworks,
-  stxSignMessage,
-  stxSignStructuredMessage,
-  stxSignTransaction,
-  stxTransferSip10Ft,
-  stxTransferSip9Nft,
-  stxTransferStx,
-  stxUpdateProfile,
-  supportedMethods
+//#endregion
+//#region src/index.ts
+const endpoints = {
+	getAddresses,
+	getInfo,
+	open,
+	openSwap,
+	sendTransfer,
+	signMessage,
+	signPsbt,
+	stxCallContract,
+	stxDeployContract,
+	stxGetAddresses,
+	stxGetNetworks,
+	stxSignMessage,
+	stxSignStructuredMessage,
+	stxSignTransaction,
+	stxTransferSip10Ft,
+	stxTransferSip9Nft,
+	stxTransferStx,
+	stxUpdateProfile,
+	supportedMethods
 };
+/**
+* Helper to create a successful RPC response object
+*/
 function createRpcSuccessResponse(_method, response) {
-  return { jsonrpc: "2.0", ...response };
+	return {
+		jsonrpc: "2.0",
+		...response
+	};
 }
+/**
+* Helper to create an error RPC response object
+*/
 function createRpcErrorResponse(_method, error) {
-  return { jsonrpc: "2.0", ...error };
+	return {
+		jsonrpc: "2.0",
+		...error
+	};
 }
 function parseEndpointRequest(data) {
-  const endpointRequests = Object.values(endpoints).map((endpoint2) => endpoint2.request);
-  const endpoint = endpointRequests.find((req) => req.safeParse(data).success);
-  return endpoint?.safeParse(data).data;
+	return Object.values(endpoints).map((endpoint) => endpoint.request).find((req) => req.safeParse(data).success)?.safeParse(data).data;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Bip322MessageTypesSchema,
-  RpcErrorCode,
-  addressResponseBodySchema,
-  addressSchema,
-  baseStacksTransactionConfigSchema,
-  bitcoinPaymentTypesSchema,
-  btcAddressBaseSchema,
-  btcAddressSchema,
-  clarityValueSchema,
-  createRequestEncoder,
-  createRpcErrorBodySchema,
-  createRpcErrorResponse,
-  createRpcErrorResponseSchema,
-  createRpcRequestSchema,
-  createRpcResponseSchema,
-  createRpcSuccessResponse,
-  createRpcSuccessResponseSchema,
-  cvAddressSchema,
-  cvAsciiSchema,
-  cvBufferSchema,
-  cvContractSchema,
-  cvErrSchema,
-  cvFalseSchema,
-  cvIntSchema,
-  cvListSchema,
-  cvNoneSchema,
-  cvOkSchema,
-  cvSomeSchema,
-  cvTrueSchema,
-  cvTupleSchema,
-  cvUintSchema,
-  cvUtf8Schema,
-  decodeBase64Json,
-  defaultErrorSchema,
-  defineRpcEndpoint,
-  encodeBase64Json,
-  endpoints,
-  getAddresses,
-  getInfo,
-  open,
-  openSwap,
-  parseEndpointRequest,
-  rpcBasePropsSchema,
-  rpcParameterSchema,
-  rpcSendTransferLegacyParamSchema,
-  rpcSendTransferNewParamsSchema,
-  rpcSendTransferParamsSchema,
-  sendTransfer,
-  signMessage,
-  signMessageRequestParamsSchema,
-  signPsbt,
-  signatureHash,
-  stacksTransactionDetailsSchema,
-  stxAddressItemSchema,
-  stxAddressSchema,
-  stxCallContract,
-  stxDeployContract,
-  stxDeployContractResponseBodySchema,
-  stxGetAddresses,
-  stxGetAddressesResponseBodySchema,
-  stxSignMessage,
-  stxSignMessageRequestBaseSchema,
-  stxSignMessageRequestStructuredSchema,
-  stxSignMessageRequestUtf8Schema,
-  stxSignMessageTypeSchema,
-  stxSignStructuredMessage,
-  stxSignTransaction,
-  stxSignTransactionRequestLeatherRpcParamsSchema,
-  stxSignTransactionRequestSip30ParamsSchema,
-  stxTransferSip10Ft,
-  stxTransferSip9Nft,
-  stxTransferStx,
-  stxUpdateProfile,
-  stxUpdateProfileRequestParamsSchema,
-  stxUpdateProfileResponseBodySchema,
-  supportedMethodSchema,
-  supportedMethods,
-  testIsNumberOrArrayOfNumbers
-});
-//# sourceMappingURL=index.cjs.map
+
+//#endregion
+exports.Bip322MessageTypesSchema = Bip322MessageTypesSchema;
+exports.RpcErrorCode = RpcErrorCode;
+exports.addressResponseBodySchema = addressResponseBodySchema;
+exports.addressSchema = addressSchema;
+exports.baseStacksTransactionConfigSchema = baseStacksTransactionConfigSchema;
+exports.bitcoinPaymentTypesSchema = bitcoinPaymentTypesSchema;
+exports.btcAddressBaseSchema = btcAddressBaseSchema;
+exports.btcAddressSchema = btcAddressSchema;
+exports.clarityValueSchema = clarityValueSchema;
+exports.createRequestEncoder = createRequestEncoder;
+exports.createRpcErrorBodySchema = createRpcErrorBodySchema;
+exports.createRpcErrorResponse = createRpcErrorResponse;
+exports.createRpcErrorResponseSchema = createRpcErrorResponseSchema;
+exports.createRpcRequestSchema = createRpcRequestSchema;
+exports.createRpcResponseSchema = createRpcResponseSchema;
+exports.createRpcSuccessResponse = createRpcSuccessResponse;
+exports.createRpcSuccessResponseSchema = createRpcSuccessResponseSchema;
+exports.cvAddressSchema = cvAddressSchema;
+exports.cvAsciiSchema = cvAsciiSchema;
+exports.cvBufferSchema = cvBufferSchema;
+exports.cvContractSchema = cvContractSchema;
+exports.cvErrSchema = cvErrSchema;
+exports.cvFalseSchema = cvFalseSchema;
+exports.cvIntSchema = cvIntSchema;
+exports.cvListSchema = cvListSchema;
+exports.cvNoneSchema = cvNoneSchema;
+exports.cvOkSchema = cvOkSchema;
+exports.cvSomeSchema = cvSomeSchema;
+exports.cvTrueSchema = cvTrueSchema;
+exports.cvTupleSchema = cvTupleSchema;
+exports.cvUintSchema = cvUintSchema;
+exports.cvUtf8Schema = cvUtf8Schema;
+exports.decodeBase64Json = decodeBase64Json;
+exports.defaultErrorSchema = defaultErrorSchema;
+exports.defineRpcEndpoint = defineRpcEndpoint;
+exports.encodeBase64Json = encodeBase64Json;
+exports.endpoints = endpoints;
+exports.getAddresses = getAddresses;
+exports.getInfo = getInfo;
+exports.open = open;
+exports.openSwap = openSwap;
+exports.parseEndpointRequest = parseEndpointRequest;
+exports.rpcBasePropsSchema = rpcBasePropsSchema;
+exports.rpcParameterSchema = rpcParameterSchema;
+exports.rpcSendTransferLegacyParamSchema = rpcSendTransferLegacyParamSchema;
+exports.rpcSendTransferNewParamsSchema = rpcSendTransferNewParamsSchema;
+exports.rpcSendTransferParamsSchema = rpcSendTransferParamsSchema;
+exports.sendTransfer = sendTransfer;
+exports.signMessage = signMessage;
+exports.signMessageRequestParamsSchema = signMessageRequestParamsSchema;
+exports.signPsbt = signPsbt;
+exports.signatureHash = signatureHash;
+exports.stacksTransactionDetailsSchema = stacksTransactionDetailsSchema;
+exports.stxAddressItemSchema = stxAddressItemSchema;
+exports.stxAddressSchema = stxAddressSchema;
+exports.stxCallContract = stxCallContract;
+exports.stxDeployContract = stxDeployContract;
+exports.stxDeployContractResponseBodySchema = stxDeployContractResponseBodySchema;
+exports.stxGetAddresses = stxGetAddresses;
+exports.stxGetAddressesResponseBodySchema = stxGetAddressesResponseBodySchema;
+exports.stxSignMessage = stxSignMessage;
+exports.stxSignMessageRequestBaseSchema = stxSignMessageRequestBaseSchema;
+exports.stxSignMessageRequestStructuredSchema = stxSignMessageRequestStructuredSchema;
+exports.stxSignMessageRequestUtf8Schema = stxSignMessageRequestUtf8Schema;
+exports.stxSignMessageTypeSchema = stxSignMessageTypeSchema;
+exports.stxSignStructuredMessage = stxSignStructuredMessage;
+exports.stxSignTransaction = stxSignTransaction;
+exports.stxSignTransactionRequestLeatherRpcParamsSchema = stxSignTransactionRequestLeatherRpcParamsSchema;
+exports.stxSignTransactionRequestSip30ParamsSchema = stxSignTransactionRequestSip30ParamsSchema;
+exports.stxTransferSip10Ft = stxTransferSip10Ft;
+exports.stxTransferSip9Nft = stxTransferSip9Nft;
+exports.stxTransferStx = stxTransferStx;
+exports.stxUpdateProfile = stxUpdateProfile;
+exports.stxUpdateProfileRequestParamsSchema = stxUpdateProfileRequestParamsSchema;
+exports.stxUpdateProfileResponseBodySchema = stxUpdateProfileResponseBodySchema;
+exports.supportedMethodSchema = supportedMethodSchema;
+exports.supportedMethods = supportedMethods;
+exports.testIsNumberOrArrayOfNumbers = testIsNumberOrArrayOfNumbers;