@sats-connect/core 0.9.0-6f299e4 → 0.10.0-2560ac8

package/dist/index.cjs

@@ -0,0 +1,2376 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let valibot = require("valibot");
+valibot = __toESM(valibot);
+let jsontokens = require("jsontokens");
+jsontokens = __toESM(jsontokens);
+let axios = require("axios");
+axios = __toESM(axios);
+let bitcoin_address_validation = require("bitcoin-address-validation");
+bitcoin_address_validation = __toESM(bitcoin_address_validation);
+let buffer = require("buffer");
+buffer = __toESM(buffer);
+
+//#region src/request/types/common.ts
+const walletTypes = [
+	"software",
+	"ledger",
+	"keystone"
+];
+const walletTypeSchema = valibot.picklist(walletTypes);
+
+//#endregion
+//#region src/addresses/types.ts
+let AddressPurpose = /* @__PURE__ */ function(AddressPurpose$1) {
+	AddressPurpose$1["Ordinals"] = "ordinals";
+	AddressPurpose$1["Payment"] = "payment";
+	AddressPurpose$1["Stacks"] = "stacks";
+	AddressPurpose$1["Starknet"] = "starknet";
+	AddressPurpose$1["Spark"] = "spark";
+	return AddressPurpose$1;
+}({});
+let AddressType = /* @__PURE__ */ function(AddressType$2) {
+	AddressType$2["p2pkh"] = "p2pkh";
+	AddressType$2["p2sh"] = "p2sh";
+	AddressType$2["p2wpkh"] = "p2wpkh";
+	AddressType$2["p2wsh"] = "p2wsh";
+	AddressType$2["p2tr"] = "p2tr";
+	AddressType$2["stacks"] = "stacks";
+	AddressType$2["starknet"] = "starknet";
+	AddressType$2["spark"] = "spark";
+	return AddressType$2;
+}({});
+const addressSchema = valibot.object({
+	address: valibot.string(),
+	publicKey: valibot.string(),
+	purpose: valibot.enum(AddressPurpose),
+	addressType: valibot.enum(AddressType),
+	walletType: walletTypeSchema
+});
+
+//#endregion
+//#region src/addresses/index.ts
+/**
+* @deprecated Use `request()` instead
+*/
+const getAddress = async (options) => {
+	const provider = await getProviderOrThrow(options.getProvider);
+	const { purposes } = options.payload;
+	if (!purposes) throw new Error("Address purposes are required");
+	try {
+		const request$1 = (0, jsontokens.createUnsecuredToken)(options.payload);
+		const response = await provider.connect(request$1);
+		options.onFinish?.(response);
+	} catch (error) {
+		console.error("[Connect] Error during address request", error);
+		options.onCancel?.();
+	}
+};
+
+//#endregion
+//#region src/request/types/walletMethods/utils.ts
+const commonNetworkSchema = valibot.object({
+	id: valibot.string(),
+	name: valibot.string(),
+	mode: valibot.picklist([]),
+	blockExplorerUrl: valibot.optional(valibot.pipe(valibot.string(), valibot.url()))
+});
+const bitcoinChainModeSchema = valibot.picklist([
+	"mainnet",
+	"testnet",
+	"testnet4",
+	"signet",
+	"regtest"
+]);
+const bitcoinNetworkSchema = valibot.object({
+	chain: valibot.literal("bitcoin"),
+	...commonNetworkSchema.entries,
+	mode: bitcoinChainModeSchema,
+	xverseApiUrl: valibot.string(),
+	electrsApiUrl: valibot.string()
+});
+const sparkChainModeSchema = valibot.picklist(["mainnet", "regtest"]);
+const sparkNetworkSchema = valibot.object({
+	chain: valibot.literal("spark"),
+	...commonNetworkSchema.entries,
+	mode: sparkChainModeSchema,
+	electrsApiUrl: valibot.string()
+});
+const stacksChainModeSchema = valibot.picklist([
+	"mainnet",
+	"testnet",
+	"devnet",
+	"mocknet"
+]);
+const stacksNetworkSchema = valibot.object({
+	chain: valibot.literal("stacks"),
+	...commonNetworkSchema.entries,
+	mode: stacksChainModeSchema,
+	stacksApiUrl: valibot.string(),
+	xverseApiUrl: valibot.string()
+});
+const starknetChainModeSchema = valibot.picklist(["mainnet", "sepolia"]);
+const starknetNetworkSchema = valibot.object({
+	chain: valibot.literal("starknet"),
+	...commonNetworkSchema.entries,
+	mode: starknetChainModeSchema,
+	rpcApiUrl: valibot.string(),
+	xverseApiUrl: valibot.string()
+});
+const networkSchema = valibot.variant("chain", [
+	bitcoinNetworkSchema,
+	sparkNetworkSchema,
+	stacksNetworkSchema,
+	starknetNetworkSchema
+]);
+
+//#endregion
+//#region src/provider/types.ts
+const accountChangeEventName = "accountChange";
+const accountChangeSchema = valibot.object({
+	type: valibot.literal(accountChangeEventName),
+	addresses: valibot.optional(valibot.array(addressSchema))
+});
+const networkChangeEventName = "networkChange";
+const networkChangeSchema = valibot.object({
+	type: valibot.literal(networkChangeEventName),
+	networks: valibot.object({
+		bitcoin: bitcoinNetworkSchema,
+		spark: sparkNetworkSchema,
+		stacks: stacksNetworkSchema,
+		starknet: starknetNetworkSchema
+	}),
+	addresses: valibot.optional(valibot.array(addressSchema))
+});
+const disconnectEventName = "disconnect";
+const disconnectSchema = valibot.object({ type: valibot.literal(disconnectEventName) });
+const walletEventSchema = valibot.variant("type", [
+	accountChangeSchema,
+	networkChangeSchema,
+	disconnectSchema
+]);
+
+//#endregion
+//#region src/provider/index.ts
+async function getProviderOrThrow(getProvider) {
+	const provider = await getProvider?.() || window.XverseProviders?.BitcoinProvider || window.BitcoinProvider;
+	if (!provider) throw new Error("No Bitcoin wallet installed");
+	return provider;
+}
+function getProviders() {
+	if (!window.btc_providers) window.btc_providers = [];
+	return window.btc_providers;
+}
+function getProviderById(providerId) {
+	return providerId?.split(".").reduce((acc, part) => acc?.[part], window);
+}
+function isProviderInstalled(providerId) {
+	return !!getProviderById(providerId);
+}
+function setDefaultProvider(providerId) {
+	localStorage.setItem("sats-connect_defaultProvider", providerId);
+}
+function getDefaultProvider() {
+	return localStorage.getItem("sats-connect_defaultProvider");
+}
+function removeDefaultProvider() {
+	localStorage.removeItem("sats-connect_defaultProvider");
+}
+function getSupportedWallets() {
+	return Object.values(DefaultAdaptersInfo).map((provider) => {
+		return {
+			...provider,
+			isInstalled: isProviderInstalled(provider.id)
+		};
+	});
+}
+
+//#endregion
+//#region src/types.ts
+let BitcoinNetworkType = /* @__PURE__ */ function(BitcoinNetworkType$1) {
+	BitcoinNetworkType$1["Mainnet"] = "Mainnet";
+	BitcoinNetworkType$1["Testnet"] = "Testnet";
+	BitcoinNetworkType$1["Testnet4"] = "Testnet4";
+	BitcoinNetworkType$1["Signet"] = "Signet";
+	BitcoinNetworkType$1["Regtest"] = "Regtest";
+	return BitcoinNetworkType$1;
+}({});
+let StacksNetworkType = /* @__PURE__ */ function(StacksNetworkType$1) {
+	StacksNetworkType$1["Mainnet"] = "mainnet";
+	StacksNetworkType$1["Testnet"] = "testnet";
+	return StacksNetworkType$1;
+}({});
+let StarknetNetworkType = /* @__PURE__ */ function(StarknetNetworkType$1) {
+	StarknetNetworkType$1["Mainnet"] = "mainnet";
+	StarknetNetworkType$1["Sepolia"] = "sepolia";
+	return StarknetNetworkType$1;
+}({});
+let SparkNetworkType = /* @__PURE__ */ function(SparkNetworkType$1) {
+	SparkNetworkType$1["Mainnet"] = "mainnet";
+	SparkNetworkType$1["Regtest"] = "regtest";
+	return SparkNetworkType$1;
+}({});
+const RpcIdSchema = valibot.optional(valibot.union([
+	valibot.string(),
+	valibot.number(),
+	valibot.null()
+]));
+const rpcRequestMessageSchema = valibot.object({
+	jsonrpc: valibot.literal("2.0"),
+	method: valibot.string(),
+	params: valibot.optional(valibot.union([
+		valibot.array(valibot.unknown()),
+		valibot.looseObject({}),
+		valibot.null()
+	])),
+	id: valibot.unwrap(RpcIdSchema)
+});
+/**
+* @enum {number} RpcErrorCode
+* @description JSON-RPC error codes
+* @see https://www.jsonrpc.org/specification#error_object
+*/
+let RpcErrorCode = /* @__PURE__ */ function(RpcErrorCode$1) {
+	/**
+	* Parse error Invalid JSON
+	**/
+	RpcErrorCode$1[RpcErrorCode$1["PARSE_ERROR"] = -32700] = "PARSE_ERROR";
+	/**
+	* The JSON sent is not a valid Request object.
+	**/
+	RpcErrorCode$1[RpcErrorCode$1["INVALID_REQUEST"] = -32600] = "INVALID_REQUEST";
+	/**
+	* The method does not exist/is not available.
+	**/
+	RpcErrorCode$1[RpcErrorCode$1["METHOD_NOT_FOUND"] = -32601] = "METHOD_NOT_FOUND";
+	/**
+	* Invalid method parameter(s).
+	*/
+	RpcErrorCode$1[RpcErrorCode$1["INVALID_PARAMS"] = -32602] = "INVALID_PARAMS";
+	/**
+	* Internal JSON-RPC error.
+	* This is a generic error, used when the server encounters an error in performing the request.
+	**/
+	RpcErrorCode$1[RpcErrorCode$1["INTERNAL_ERROR"] = -32603] = "INTERNAL_ERROR";
+	/**
+	* user rejected/canceled the request
+	*/
+	RpcErrorCode$1[RpcErrorCode$1["USER_REJECTION"] = -32e3] = "USER_REJECTION";
+	/**
+	* method is not supported for the address provided
+	*/
+	RpcErrorCode$1[RpcErrorCode$1["METHOD_NOT_SUPPORTED"] = -32001] = "METHOD_NOT_SUPPORTED";
+	/**
+	* The client does not have permission to access the requested resource.
+	*/
+	RpcErrorCode$1[RpcErrorCode$1["ACCESS_DENIED"] = -32002] = "ACCESS_DENIED";
+	return RpcErrorCode$1;
+}({});
+const rpcSuccessResponseMessageSchema = valibot.object({
+	jsonrpc: valibot.literal("2.0"),
+	result: valibot.nonOptional(valibot.unknown()),
+	id: RpcIdSchema
+});
+const rpcErrorResponseMessageSchema = valibot.object({
+	jsonrpc: valibot.literal("2.0"),
+	error: valibot.nonOptional(valibot.unknown()),
+	id: RpcIdSchema
+});
+const rpcResponseMessageSchema = valibot.union([rpcSuccessResponseMessageSchema, rpcErrorResponseMessageSchema]);
+
+//#endregion
+//#region src/request/sanitizeRequest.ts
+const sanitizeRequest = (method, params, providerInfo) => {
+	try {
+		const [major, minor, patch] = providerInfo.version.split(".").map((part) => parseInt(part, 10));
+		const platform = providerInfo.platform;
+		if (!platform || platform === ProviderPlatform.Web && major <= 1 && minor <= 4 || platform === ProviderPlatform.Mobile && major <= 1 && minor <= 54) {
+			const v1Sanitized = sanitizeAddressPurposeRequest(method, params);
+			method = v1Sanitized.method;
+			params = v1Sanitized.params;
+		}
+	} catch {}
+	return {
+		method,
+		params
+	};
+};
+const sanitizeAddressPurposeRequest = (method, params) => {
+	const filterPurposes = (purposes) => purposes?.filter((purpose) => purpose !== AddressPurpose.Spark && purpose !== AddressPurpose.Starknet);
+	if (method === "wallet_connect") {
+		const typedParams = params;
+		if (!typedParams) return {
+			method,
+			params
+		};
+		const { addresses,...rest } = typedParams;
+		return {
+			method,
+			params: {
+				...rest,
+				addresses: filterPurposes(addresses)
+			}
+		};
+	}
+	if (method === "getAccounts") {
+		const { purposes,...rest } = params;
+		return {
+			method,
+			params: {
+				...rest,
+				purposes: filterPurposes(purposes)
+			}
+		};
+	}
+	if (method === "getAddresses") {
+		const { purposes,...rest } = params;
+		return {
+			method,
+			params: {
+				...rest,
+				purposes: filterPurposes(purposes)
+			}
+		};
+	}
+	return {
+		method,
+		params
+	};
+};
+
+//#endregion
+//#region src/request/types/btcMethods.ts
+let ProviderPlatform = /* @__PURE__ */ function(ProviderPlatform$1) {
+	ProviderPlatform$1["Web"] = "web";
+	ProviderPlatform$1["Mobile"] = "mobile";
+	return ProviderPlatform$1;
+}({});
+const getInfoMethodName = "getInfo";
+const getInfoParamsSchema = valibot.nullish(valibot.null());
+const getInfoResultSchema = valibot.object({
+	version: valibot.string(),
+	platform: valibot.optional(valibot.enum(ProviderPlatform)),
+	methods: valibot.optional(valibot.array(valibot.string())),
+	supports: valibot.array(valibot.string())
+});
+const getInfoRequestMessageSchema = valibot.object({
+	...rpcRequestMessageSchema.entries,
+	...valibot.object({
+		method: valibot.literal(getInfoMethodName),
+		params: getInfoParamsSchema,
+		id: valibot.string()
+	}).entries
+});
+const getAddressesMethodName = "getAddresses";
+const getAddressesParamsSchema = valibot.object({
+	purposes: valibot.array(valibot.enum(AddressPurpose)),
+	message: valibot.optional(valibot.string())
+});
+const getAddressesResultSchema = valibot.object({
+	addresses: valibot.array(addressSchema),
+	network: bitcoinNetworkSchema
+});
+const getAddressesRequestMessageSchema = valibot.object({
+	...rpcRequestMessageSchema.entries,
+	...valibot.object({
+		method: valibot.literal(getAddressesMethodName),
+		params: getAddressesParamsSchema,
+		id: valibot.string()
+	}).entries
+});
+const signMessageMethodName = "signMessage";
+let MessageSigningProtocols = /* @__PURE__ */ function(MessageSigningProtocols$1) {
+	MessageSigningProtocols$1["ECDSA"] = "ECDSA";
+	MessageSigningProtocols$1["BIP322"] = "BIP322";
+	return MessageSigningProtocols$1;
+}({});
+const signMessageParamsSchema = valibot.object({
+	address: valibot.string(),
+	message: valibot.string(),
+	protocol: valibot.optional(valibot.enum(MessageSigningProtocols))
+});
+const signMessageResultSchema = valibot.object({
+	signature: valibot.string(),
+	messageHash: valibot.string(),
+	address: valibot.string(),
+	protocol: valibot.enum(MessageSigningProtocols)
+});
+const signMessageRequestMessageSchema = valibot.object({
+	...rpcRequestMessageSchema.entries,
+	...valibot.object({
+		method: valibot.literal(signMessageMethodName),
+		params: signMessageParamsSchema,
+		id: valibot.string()
+	}).entries
+});
+const sendTransferMethodName = "sendTransfer";
+const sendTransferParamsSchema = valibot.object({ recipients: valibot.array(valibot.object({
+	address: valibot.string(),
+	amount: valibot.number()
+})) });
+const sendTransferResultSchema = valibot.object({ txid: valibot.string() });
+const sendTransferRequestMessageSchema = valibot.object({
+	...rpcRequestMessageSchema.entries,
+	...valibot.object({
+		method: valibot.literal(sendTransferMethodName),
+		params: sendTransferParamsSchema,
+		id: valibot.string()
+	}).entries
+});
+const signPsbtMethodName = "signPsbt";
+const signPsbtParamsSchema = valibot.object({
+	psbt: valibot.string(),
+	signInputs: valibot.optional(valibot.record(valibot.string(), valibot.array(valibot.number()))),
+	broadcast: valibot.optional(valibot.boolean())
+});
+const signPsbtResultSchema = valibot.object({
+	psbt: valibot.string(),
+	txid: valibot.optional(valibot.string())
+});
+const signPsbtRequestMessageSchema = valibot.object({
+	...rpcRequestMessageSchema.entries,
+	...valibot.object({
+		method: valibot.literal(signPsbtMethodName),
+		params: signPsbtParamsSchema,
+		id: valibot.string()
+	}).entries
+});
+const getAccountsMethodName = "getAccounts";
+const getAccountsParamsSchema = valibot.object({
+	purposes: valibot.array(valibot.enum(AddressPurpose)),
+	message: valibot.optional(valibot.string())
+});
+const getAccountsResultSchema = valibot.array(valibot.object({
+	...addressSchema.entries,
+	...valibot.object({ walletType: walletTypeSchema }).entries
+}));
+const getAccountsRequestMessageSchema = valibot.object({
+	...rpcRequestMessageSchema.entries,
+	...valibot.object({
+		method: valibot.literal(getAccountsMethodName),
+		params: getAccountsParamsSchema,
+		id: valibot.string()
+	}).entries
+});
+const getBalanceMethodName = "getBalance";
+const getBalanceParamsSchema = valibot.nullish(valibot.null());
+const getBalanceResultSchema = valibot.object({
+	confirmed: valibot.string(),
+	unconfirmed: valibot.string(),
+	total: valibot.string()
+});
+const getBalanceRequestMessageSchema = valibot.object({
+	...rpcRequestMessageSchema.entries,
+	...valibot.object({
+		method: valibot.literal(getBalanceMethodName),
+		id: valibot.string()
+	}).entries
+});
+
+//#endregion
+//#region src/request/types/ordinalsMethods.ts
+const getInscriptionsMethodName = "ord_getInscriptions";
+const getInscriptionsParamsSchema = valibot.object({
+	offset: valibot.number(),
+	limit: valibot.number()
+});
+const getInscriptionsResultSchema = valibot.object({
+	total: valibot.number(),
+	limit: valibot.number(),
+	offset: valibot.number(),
+	inscriptions: valibot.array(valibot.object({
+		inscriptionId: valibot.string(),
+		inscriptionNumber: valibot.string(),
+		address: valibot.string(),
+		collectionName: valibot.optional(valibot.string()),
+		postage: valibot.string(),
+		contentLength: valibot.string(),
+		contentType: valibot.string(),
+		timestamp: valibot.number(),
+		offset: valibot.number(),
+		genesisTransaction: valibot.string(),
+		output: valibot.string()
+	}))
+});
+const getInscriptionsRequestMessageSchema = valibot.object({
+	...rpcRequestMessageSchema.entries,
+	...valibot.object({
+		method: valibot.literal(getInscriptionsMethodName),
+		params: getInscriptionsParamsSchema,
+		id: valibot.string()
+	}).entries
+});
+const sendInscriptionsMethodName = "ord_sendInscriptions";
+const sendInscriptionsParamsSchema = valibot.object({ transfers: valibot.array(valibot.object({
+	address: valibot.string(),
+	inscriptionId: valibot.string()
+})) });
+const sendInscriptionsResultSchema = valibot.object({ txid: valibot.string() });
+const sendInscriptionsRequestMessageSchema = valibot.object({
+	...rpcRequestMessageSchema.entries,
+	...valibot.object({
+		method: valibot.literal(sendInscriptionsMethodName),
+		params: sendInscriptionsParamsSchema,
+		id: valibot.string()
+	}).entries
+});
+
+//#endregion
+//#region src/request/types/runesMethods/etch.ts
+const runesEtchMethodName = "runes_etch";
+const etchTermsSchema = valibot.object({
+	amount: valibot.string(),
+	cap: valibot.string(),
+	heightStart: valibot.optional(valibot.string()),
+	heightEnd: valibot.optional(valibot.string()),
+	offsetStart: valibot.optional(valibot.string()),
+	offsetEnd: valibot.optional(valibot.string())
+});
+const inscriptionDetailsSchema = valibot.object({
+	contentType: valibot.string(),
+	contentBase64: valibot.string()
+});
+const runesEtchParamsSchema = valibot.object({
+	runeName: valibot.string(),
+	divisibility: valibot.optional(valibot.number()),
+	symbol: valibot.optional(valibot.string()),
+	premine: valibot.optional(valibot.string()),
+	isMintable: valibot.boolean(),
+	delegateInscriptionId: valibot.optional(valibot.string()),
+	destinationAddress: valibot.string(),
+	refundAddress: valibot.string(),
+	feeRate: valibot.number(),
+	appServiceFee: valibot.optional(valibot.number()),
+	appServiceFeeAddress: valibot.optional(valibot.string()),
+	terms: valibot.optional(etchTermsSchema),
+	inscriptionDetails: valibot.optional(inscriptionDetailsSchema),
+	network: valibot.optional(valibot.enum(BitcoinNetworkType))
+});
+const runesEtchResultSchema = valibot.object({
+	orderId: valibot.string(),
+	fundTransactionId: valibot.string(),
+	fundingAddress: valibot.string()
+});
+const runesEtchRequestMessageSchema = valibot.object({
+	...rpcRequestMessageSchema.entries,
+	...valibot.object({
+		method: valibot.literal(runesEtchMethodName),
+		params: runesEtchParamsSchema,
+		id: valibot.string()
+	}).entries
+});
+
+//#endregion
+//#region src/request/types/runesMethods/getBalance.ts
+const runesGetBalanceMethodName = "runes_getBalance";
+const runesGetBalanceParamsSchema = valibot.nullish(valibot.null());
+const runesGetBalanceResultSchema = valibot.object({ balances: valibot.array(valibot.object({
+	runeName: valibot.string(),
+	amount: valibot.string(),
+	divisibility: valibot.number(),
+	symbol: valibot.string(),
+	inscriptionId: valibot.nullish(valibot.string()),
+	spendableBalance: valibot.string()
+})) });
+const runesGetBalanceRequestMessageSchema = valibot.object({
+	...rpcRequestMessageSchema.entries,
+	...valibot.object({
+		method: valibot.literal(runesGetBalanceMethodName),
+		params: runesGetBalanceParamsSchema,
+		id: valibot.string()
+	}).entries
+});
+
+//#endregion
+//#region src/request/types/runesMethods/mint.ts
+const runesMintMethodName = "runes_mint";
+const runesMintParamsSchema = valibot.object({
+	appServiceFee: valibot.optional(valibot.number()),
+	appServiceFeeAddress: valibot.optional(valibot.string()),
+	destinationAddress: valibot.string(),
+	feeRate: valibot.number(),
+	refundAddress: valibot.string(),
+	repeats: valibot.number(),
+	runeName: valibot.string(),
+	network: valibot.optional(valibot.enum(BitcoinNetworkType))
+});
+const runesMintResultSchema = valibot.object({
+	orderId: valibot.string(),
+	fundTransactionId: valibot.string(),
+	fundingAddress: valibot.string()
+});
+const runesMintRequestMessageSchema = valibot.object({
+	...rpcRequestMessageSchema.entries,
+	...valibot.object({
+		method: valibot.literal(runesMintMethodName),
+		params: runesMintParamsSchema,
+		id: valibot.string()
+	}).entries
+});
+
+//#endregion
+//#region src/request/types/runesMethods/transfer.ts
+const runesTransferMethodName = "runes_transfer";
+const runesTransferParamsSchema = valibot.object({ recipients: valibot.array(valibot.object({
+	runeName: valibot.string(),
+	amount: valibot.string(),
+	address: valibot.string()
+})) });
+const runesTransferResultSchema = valibot.object({ txid: valibot.string() });
+const runesTransferRequestMessageSchema = valibot.object({
+	...rpcRequestMessageSchema.entries,
+	...valibot.object({
+		method: valibot.literal(runesTransferMethodName),
+		params: runesTransferParamsSchema,
+		id: valibot.string()
+	}).entries
+});
+
+//#endregion
+//#region src/request/types/sparkMethods/flashnetMethods/getJwt.ts
+const sparkFlashnetGetJwtMethodName = "spark_flashnet_getJwt";
+const sparkFlashnetGetJwtParamsSchema = valibot.null();
+const sparkFlashnetGetJwtResultSchema = valibot.object({ jwt: valibot.string() });
+const sparkFlashnetGetJwtRequestMessageSchema = valibot.object({
+	...rpcRequestMessageSchema.entries,
+	...valibot.object({
+		method: valibot.literal(sparkFlashnetGetJwtMethodName),
+		params: sparkFlashnetGetJwtParamsSchema,
+		id: valibot.string()
+	}).entries
+});
+
+//#endregion
+//#region src/request/types/sparkMethods/flashnetMethods/intents/addLiquidity.ts
+const sparkFlashnetAddLiquidityIntentSchema = valibot.object({
+	type: valibot.literal("addLiquidity"),
+	data: valibot.object({
+		userPublicKey: valibot.string(),
+		poolId: valibot.string(),
+		assetAAmount: valibot.string(),
+		assetBAmount: valibot.string(),
+		assetAMinAmountIn: valibot.string(),
+		assetBMinAmountIn: valibot.string(),
+		assetATransferId: valibot.string(),
+		assetBTransferId: valibot.string(),
+		nonce: valibot.string()
+	})
+});
+
+//#endregion
+//#region src/request/types/sparkMethods/flashnetMethods/intents/clawback.ts
+const sparkFlashnetClawbackIntentSchema = valibot.object({
+	type: valibot.literal("clawback"),
+	data: valibot.object({
+		senderPublicKey: valibot.string(),
+		sparkTransferId: valibot.string(),
+		lpIdentityPublicKey: valibot.string(),
+		nonce: valibot.string()
+	})
+});
+
+//#endregion
+//#region src/request/types/sparkMethods/flashnetMethods/intents/confirmInitialDeposit.ts
+const sparkFlashnetConfirmInitialDepositIntentSchema = valibot.object({
+	type: valibot.literal("confirmInitialDeposit"),
+	data: valibot.object({
+		poolId: valibot.string(),
+		assetASparkTransferId: valibot.string(),
+		poolOwnerPublicKey: valibot.string(),
+		nonce: valibot.string()
+	})
+});
+
+//#endregion
+//#region src/request/types/sparkMethods/flashnetMethods/intents/createConstantProductPool.ts
+const sparkFlashnetCreateConstantProductPoolIntentSchema = valibot.object({
+	type: valibot.literal("createConstantProductPool"),
+	data: valibot.object({
+		poolOwnerPublicKey: valibot.string(),
+		assetAAddress: valibot.string(),
+		assetBAddress: valibot.string(),
+		lpFeeRateBps: valibot.union([valibot.number(), valibot.string()]),
+		totalHostFeeRateBps: valibot.union([valibot.number(), valibot.string()]),
+		nonce: valibot.string()
+	})
+});
+
+//#endregion
+//#region src/request/types/sparkMethods/flashnetMethods/intents/createSingleSidedPool.ts
+const sparkFlashnetCreateSingleSidedPoolIntentSchema = valibot.object({
+	type: valibot.literal("createSingleSidedPool"),
+	data: valibot.object({
+		assetAAddress: valibot.string(),
+		assetBAddress: valibot.string(),
+		assetAInitialReserve: valibot.string(),
+		virtualReserveA: valibot.union([valibot.number(), valibot.string()]),
+		virtualReserveB: valibot.union([valibot.number(), valibot.string()]),
+		threshold: valibot.union([valibot.number(), valibot.string()]),
+		lpFeeRateBps: valibot.union([valibot.number(), valibot.string()]),
+		totalHostFeeRateBps: valibot.union([valibot.number(), valibot.string()]),
+		poolOwnerPublicKey: valibot.string(),
+		nonce: valibot.string()
+	})
+});
+
+//#endregion
+//#region src/request/types/sparkMethods/flashnetMethods/intents/removeLiquidity.ts
+const sparkFlashnetRemoveLiquidityIntentSchema = valibot.object({
+	type: valibot.literal("removeLiquidity"),
+	data: valibot.object({
+		userPublicKey: valibot.string(),
+		poolId: valibot.string(),
+		lpTokensToRemove: valibot.string(),
+		nonce: valibot.string()
+	})
+});
+
+//#endregion
+//#region src/request/types/sparkMethods/flashnetMethods/intents/routeSwap.ts
+const sparkFlashnetRouteSwapIntentSchema = valibot.object({
+	type: valibot.literal("executeRouteSwap"),
+	data: valibot.object({
+		userPublicKey: valibot.string(),
+		initialSparkTransferId: valibot.string(),
+		hops: valibot.array(valibot.object({
+			poolId: valibot.string(),
+			inputAssetAddress: valibot.string(),
+			outputAssetAddress: valibot.string(),
+			hopIntegratorFeeRateBps: valibot.optional(valibot.union([valibot.number(), valibot.string()]))
+		})),
+		inputAmount: valibot.string(),
+		maxRouteSlippageBps: valibot.union([valibot.number(), valibot.string()]),
+		minAmountOut: valibot.string(),
+		defaultIntegratorFeeRateBps: valibot.optional(valibot.union([valibot.number(), valibot.string()])),
+		nonce: valibot.string()
+	})
+});
+
+//#endregion
+//#region src/request/types/sparkMethods/flashnetMethods/intents/swap.ts
+const sparkFlashnetSwapIntentSchema = valibot.object({
+	type: valibot.literal("executeSwap"),
+	data: valibot.object({
+		userPublicKey: valibot.string(),
+		poolId: valibot.string(),
+		transferId: valibot.string(),
+		assetInAddress: valibot.string(),
+		assetOutAddress: valibot.string(),
+		amountIn: valibot.string(),
+		maxSlippageBps: valibot.union([valibot.number(), valibot.string()]),
+		minAmountOut: valibot.string(),
+		totalIntegratorFeeRateBps: valibot.optional(valibot.union([valibot.number(), valibot.string()])),
+		nonce: valibot.string()
+	})
+});
+
+//#endregion
+//#region src/request/types/sparkMethods/flashnetMethods/signIntent.ts
+const sparkFlashnetSignIntentMethodName = "spark_flashnet_signIntent";
+const sparkFlashnetSignIntentParamsSchema = valibot.union([
+	sparkFlashnetSwapIntentSchema,
+	sparkFlashnetRouteSwapIntentSchema,
+	sparkFlashnetAddLiquidityIntentSchema,
+	sparkFlashnetClawbackIntentSchema,
+	sparkFlashnetConfirmInitialDepositIntentSchema,
+	sparkFlashnetCreateConstantProductPoolIntentSchema,
+	sparkFlashnetCreateSingleSidedPoolIntentSchema,
+	sparkFlashnetRemoveLiquidityIntentSchema
+]);
+const sparkFlashnetSignIntentResultSchema = valibot.object({ signature: valibot.string() });
+const sparkFlashnetSignIntentRequestMessageSchema = valibot.object({
+	...rpcRequestMessageSchema.entries,
+	...valibot.object({
+		method: valibot.literal(sparkFlashnetSignIntentMethodName),
+		params: sparkFlashnetSignIntentParamsSchema,
+		id: valibot.string()
+	}).entries
+});
+
+//#endregion
+//#region src/request/types/sparkMethods/flashnetMethods/signStructuredMessage.ts
+const sparkFlashnetSignStructuredMessageMethodName = "spark_flashnet_signStructuredMessage";
+const sparkFlashnetSignStructuredMessageParamsSchema = valibot.object({ message: valibot.string() });
+const sparkFlashnetSignStructuredMessageResultSchema = valibot.object({
+	message: valibot.string(),
+	signature: valibot.string()
+});
+const sparkFlashnetSignStructuredMessageRequestMessageSchema = valibot.object({
+	...rpcRequestMessageSchema.entries,
+	...valibot.object({
+		method: valibot.literal(sparkFlashnetSignStructuredMessageMethodName),
+		params: sparkFlashnetSignStructuredMessageParamsSchema,
+		id: valibot.string()
+	}).entries
+});
+
+//#endregion
+//#region src/request/types/sparkMethods/getAddresses.ts
+const sparkGetAddressesMethodName = "spark_getAddresses";
+const sparkGetAddressesParamsSchema = valibot.nullish(valibot.object({ message: valibot.optional(valibot.string()) }));
+const sparkGetAddressesResultSchema = valibot.object({
+	addresses: valibot.array(addressSchema),
+	network: sparkNetworkSchema
+});
+const sparkGetAddressesRequestMessageSchema = valibot.object({
+	...rpcRequestMessageSchema.entries,
+	...valibot.object({
+		method: valibot.literal(sparkGetAddressesMethodName),
+		params: sparkGetAddressesParamsSchema,
+		id: valibot.string()
+	}).entries
+});
+
+//#endregion
+//#region src/request/types/sparkMethods/getBalance.ts
+const sparkGetBalanceMethodName = "spark_getBalance";
+const sparkGetBalanceParamsSchema = valibot.nullish(valibot.null());
+const sparkGetBalanceResultSchema = valibot.object({
+	balance: valibot.string(),
+	tokenBalances: valibot.array(valibot.object({
+		balance: valibot.string(),
+		tokenMetadata: valibot.object({
+			tokenIdentifier: valibot.string(),
+			tokenName: valibot.string(),
+			tokenTicker: valibot.string(),
+			decimals: valibot.number(),
+			maxSupply: valibot.string()
+		})
+	}))
+});
+const sparkGetBalanceRequestMessageSchema = valibot.object({
+	...rpcRequestMessageSchema.entries,
+	...valibot.object({
+		method: valibot.literal(sparkGetBalanceMethodName),
+		params: sparkGetBalanceParamsSchema,
+		id: valibot.string()
+	}).entries
+});
+
+//#endregion
+//#region src/request/types/sparkMethods/signMessage.ts
+const sparkSignMessageMethodName = "spark_signMessage";
+const sparkSignMessageParamsSchema = valibot.object({ message: valibot.string() });
+const sparkSignMessageResultSchema = valibot.object({ signature: valibot.string() });
+const sparkSignMessageRequestMessageSchema = valibot.object({
+	...rpcRequestMessageSchema.entries,
+	...valibot.object({
+		method: valibot.literal(sparkSignMessageMethodName),
+		params: sparkSignMessageParamsSchema,
+		id: valibot.string()
+	}).entries
+});
+
+//#endregion
+//#region src/request/types/sparkMethods/transfer.ts
+const sparkTransferMethodName = "spark_transfer";
+const sparkTransferParamsSchema = valibot.object({
+	amountSats: valibot.union([valibot.number(), valibot.string()]),
+	receiverSparkAddress: valibot.string()
+});
+const sparkTransferResultSchema = valibot.object({ id: valibot.string() });
+const sparkTransferRequestMessageSchema = valibot.object({
+	...rpcRequestMessageSchema.entries,
+	...valibot.object({
+		method: valibot.literal(sparkTransferMethodName),
+		params: sparkTransferParamsSchema,
+		id: valibot.string()
+	}).entries
+});
+
+//#endregion
+//#region src/request/types/sparkMethods/transferToken.ts
+const sparkTransferTokenMethodName = "spark_transferToken";
+const sparkTransferTokenParamsSchema = valibot.object({
+	tokenAmount: valibot.union([valibot.number(), valibot.string()]),
+	tokenIdentifier: valibot.string(),
+	receiverSparkAddress: valibot.string()
+});
+const sparkTransferTokenResultSchema = valibot.object({ id: valibot.string() });
+const sparkTransferTokenRequestMessageSchema = valibot.object({
+	...rpcRequestMessageSchema.entries,
+	...valibot.object({
+		method: valibot.literal(sparkTransferTokenMethodName),
+		params: sparkTransferTokenParamsSchema,
+		id: valibot.string()
+	}).entries
+});
+
+//#endregion
+//#region src/request/types/stxMethods/callContract.ts
+const stxCallContractMethodName = "stx_callContract";
+const stxCallContractParamsSchema = valibot.object({
+	contract: valibot.string(),
+	functionName: valibot.string(),
+	arguments: valibot.optional(valibot.array(valibot.string())),
+	functionArgs: valibot.optional(valibot.array(valibot.string())),
+	postConditions: valibot.optional(valibot.array(valibot.string())),
+	postConditionMode: valibot.optional(valibot.union([valibot.literal("allow"), valibot.literal("deny")]))
+});
+const stxCallContractResultSchema = valibot.object({
+	txid: valibot.string(),
+	transaction: valibot.string()
+});
+const stxCallContractRequestMessageSchema = valibot.object({
+	...rpcRequestMessageSchema.entries,
+	...valibot.object({
+		method: valibot.literal(stxCallContractMethodName),
+		params: stxCallContractParamsSchema,
+		id: valibot.string()
+	}).entries
+});
+
+//#endregion
+//#region src/request/types/stxMethods/deployContract.ts
+const stxDeployContractMethodName = "stx_deployContract";
+const stxDeployContractParamsSchema = valibot.object({
+	name: valibot.string(),
+	clarityCode: valibot.string(),
+	clarityVersion: valibot.optional(valibot.number()),
+	postConditions: valibot.optional(valibot.array(valibot.string())),
+	postConditionMode: valibot.optional(valibot.union([valibot.literal("allow"), valibot.literal("deny")]))
+});
+const stxDeployContractResultSchema = valibot.object({
+	txid: valibot.string(),
+	transaction: valibot.string()
+});
+const stxDeployContractRequestMessageSchema = valibot.object({
+	...rpcRequestMessageSchema.entries,
+	...valibot.object({
+		method: valibot.literal(stxDeployContractMethodName),
+		params: stxDeployContractParamsSchema,
+		id: valibot.string()
+	}).entries
+});
+
+//#endregion
+//#region src/request/types/walletMethods.ts
+const accountActionsSchema = valibot.object({ read: valibot.optional(valibot.boolean()) });
+const walletActionsSchema = valibot.object({ readNetwork: valibot.optional(valibot.boolean()) });
+const accountPermissionSchema = valibot.object({
+	type: valibot.literal("account"),
+	resourceId: valibot.string(),
+	clientId: valibot.string(),
+	actions: accountActionsSchema
+});
+const walletPermissionSchema = valibot.object({
+	type: valibot.literal("wallet"),
+	resourceId: valibot.string(),
+	clientId: valibot.string(),
+	actions: walletActionsSchema
+});
+/**
+* Permissions with the clientId field omitted and optional actions. Used for
+* permission requests, since the wallet performs authentication based on the
+* client's tab origin and should not rely on the client authenticating
+* themselves.
+*/
+const PermissionRequestParams = valibot.variant("type", [valibot.object({ ...valibot.omit(accountPermissionSchema, ["clientId"]).entries }), valibot.object({ ...valibot.omit(walletPermissionSchema, ["clientId"]).entries })]);
+const permission = valibot.variant("type", [accountPermissionSchema, walletPermissionSchema]);
+const requestPermissionsMethodName = "wallet_requestPermissions";
+const requestPermissionsParamsSchema = valibot.nullish(valibot.array(PermissionRequestParams));
+const requestPermissionsResultSchema = valibot.literal(true);
+const requestPermissionsRequestMessageSchema = valibot.object({
+	...rpcRequestMessageSchema.entries,
+	...valibot.object({
+		method: valibot.literal(requestPermissionsMethodName),
+		params: requestPermissionsParamsSchema,
+		id: valibot.string()
+	}).entries
+});
+const renouncePermissionsMethodName = "wallet_renouncePermissions";
+const renouncePermissionsParamsSchema = valibot.nullish(valibot.null());
+const renouncePermissionsResultSchema = valibot.nullish(valibot.null());
+const renouncePermissionsRequestMessageSchema = valibot.object({
+	...rpcRequestMessageSchema.entries,
+	...valibot.object({
+		method: valibot.literal(renouncePermissionsMethodName),
+		params: renouncePermissionsParamsSchema,
+		id: valibot.string()
+	}).entries
+});
+const disconnectMethodName = "wallet_disconnect";
+const disconnectParamsSchema = valibot.nullish(valibot.null());
+const disconnectResultSchema = valibot.nullish(valibot.null());
+const disconnectRequestMessageSchema = valibot.object({
+	...rpcRequestMessageSchema.entries,
+	...valibot.object({
+		method: valibot.literal(disconnectMethodName),
+		params: disconnectParamsSchema,
+		id: valibot.string()
+	}).entries
+});
+const getWalletTypeMethodName = "wallet_getWalletType";
+const getWalletTypeParamsSchema = valibot.nullish(valibot.null());
+const getWalletTypeResultSchema = walletTypeSchema;
+const getWalletTypeRequestMessageSchema = valibot.object({
+	...rpcRequestMessageSchema.entries,
+	...valibot.object({
+		method: valibot.literal(getWalletTypeMethodName),
+		params: getWalletTypeParamsSchema,
+		id: valibot.string()
+	}).entries
+});
+const getCurrentPermissionsMethodName = "wallet_getCurrentPermissions";
+const getCurrentPermissionsParamsSchema = valibot.nullish(valibot.null());
+const getCurrentPermissionsResultSchema = valibot.array(permission);
+const getCurrentPermissionsRequestMessageSchema = valibot.object({
+	...rpcRequestMessageSchema.entries,
+	...valibot.object({
+		method: valibot.literal(getCurrentPermissionsMethodName),
+		params: getCurrentPermissionsParamsSchema,
+		id: valibot.string()
+	}).entries
+});
+const getNetworkMethodName = "wallet_getNetwork";
+const getNetworkParamsSchema = valibot.nullish(valibot.null());
+const getNetworkResultSchema = valibot.object({
+	bitcoin: valibot.object({ name: valibot.enum(BitcoinNetworkType) }),
+	stacks: valibot.object({ name: valibot.enum(StacksNetworkType) }),
+	spark: valibot.object({ name: valibot.enum(SparkNetworkType) })
+});
+const getNetworkRequestMessageSchema = valibot.object({
+	...rpcRequestMessageSchema.entries,
+	...valibot.object({
+		method: valibot.literal(getNetworkMethodName),
+		params: getNetworkParamsSchema,
+		id: valibot.string()
+	}).entries
+});
+const getNetworksMethodName = "wallet_getNetworks";
+const getNetworksParamsSchema = valibot.nullish(valibot.null());
+const getNetworksResultSchema = valibot.object({
+	active: valibot.object({
+		bitcoin: bitcoinNetworkSchema,
+		stacks: stacksNetworkSchema,
+		spark: sparkNetworkSchema,
+		starknet: starknetNetworkSchema
+	}),
+	builtin: valibot.object({
+		bitcoin: valibot.array(bitcoinNetworkSchema),
+		stacks: valibot.array(stacksNetworkSchema),
+		spark: valibot.array(sparkNetworkSchema),
+		starknet: valibot.array(starknetNetworkSchema)
+	}),
+	custom: valibot.object({
+		bitcoin: valibot.array(bitcoinNetworkSchema),
+		stacks: valibot.array(stacksNetworkSchema),
+		spark: valibot.array(sparkNetworkSchema),
+		starknet: valibot.array(starknetNetworkSchema)
+	})
+});
+const getNetworksRequestMessageSchema = valibot.object({
+	...rpcRequestMessageSchema.entries,
+	...valibot.object({
+		method: valibot.literal(getNetworksMethodName),
+		params: getNetworksParamsSchema,
+		id: valibot.string()
+	}).entries
+});
+const changeNetworkMethodName = "wallet_changeNetwork";
+const changeNetworkParamsSchema = valibot.object({ name: valibot.enum(BitcoinNetworkType) });
+const changeNetworkResultSchema = valibot.nullish(valibot.null());
+const changeNetworkRequestMessageSchema = valibot.object({
+	...rpcRequestMessageSchema.entries,
+	...valibot.object({
+		method: valibot.literal(changeNetworkMethodName),
+		params: changeNetworkParamsSchema,
+		id: valibot.string()
+	}).entries
+});
+const changeNetworkByIdMethodName = "wallet_changeNetworkById";
+const changeNetworkByIdParamsSchema = valibot.object({ id: valibot.string() });
+const changeNetworkByIdResultSchema = valibot.nullish(valibot.null());
+const changeNetworkByIdRequestMessageSchema = valibot.object({
+	...rpcRequestMessageSchema.entries,
+	...valibot.object({
+		method: valibot.literal(changeNetworkByIdMethodName),
+		params: changeNetworkByIdParamsSchema,
+		id: valibot.string()
+	}).entries
+});
+const getAccountMethodName = "wallet_getAccount";
+const getAccountParamsSchema = valibot.nullish(valibot.null());
+const getAccountResultSchema = valibot.object({
+	id: valibot.string(),
+	addresses: valibot.array(addressSchema),
+	walletType: walletTypeSchema,
+	networks: getNetworksResultSchema
+});
+const getAccountRequestMessageSchema = valibot.object({
+	...rpcRequestMessageSchema.entries,
+	...valibot.object({
+		method: valibot.literal(getAccountMethodName),
+		params: getAccountParamsSchema,
+		id: valibot.string()
+	}).entries
+});
+const connectMethodName = "wallet_connect";
+const connectParamsSchema = valibot.nullish(valibot.object({
+	permissions: valibot.optional(valibot.array(PermissionRequestParams)),
+	addresses: valibot.optional(valibot.array(valibot.enum(AddressPurpose))),
+	message: valibot.optional(valibot.pipe(valibot.string(), valibot.maxLength(80, "The message must not exceed 80 characters."))),
+	networkId: valibot.optional(valibot.string())
+}));
+const connectResultSchema = valibot.object({
+	id: valibot.string(),
+	addresses: valibot.array(addressSchema),
+	walletType: walletTypeSchema,
+	networks: getNetworksResultSchema
+});
+const connectRequestMessageSchema = valibot.object({
+	...rpcRequestMessageSchema.entries,
+	...valibot.object({
+		method: valibot.literal(connectMethodName),
+		params: connectParamsSchema,
+		id: valibot.string()
+	}).entries
+});
+const addNetworkMethodName = "wallet_addNetwork";
+const bitcoinNetworkDefinitionSchema = valibot.omit(bitcoinNetworkSchema, ["id"]);
+const sparkNetworkDefinitionSchema = valibot.omit(sparkNetworkSchema, ["id"]);
+const stacksNetworkDefinitionSchema = valibot.omit(stacksNetworkSchema, ["id"]);
+const starknetNetworkDefinitionSchema = valibot.omit(starknetNetworkSchema, ["id"]);
+const newNetworkDefinitionSchema = valibot.variant("chain", [
+	bitcoinNetworkDefinitionSchema,
+	sparkNetworkDefinitionSchema,
+	stacksNetworkDefinitionSchema,
+	starknetNetworkDefinitionSchema
+]);
+const addNetworkParamsSchema = valibot.object({
+	network: newNetworkDefinitionSchema,
+	isActive: valibot.optional(valibot.boolean())
+});
+const addNetworkRequestMessageSchema = valibot.object({
+	...rpcRequestMessageSchema.entries,
+	...valibot.object({
+		method: valibot.literal(addNetworkMethodName),
+		params: addNetworkParamsSchema,
+		id: valibot.string()
+	}).entries
+});
+const addNetworkResultSchema = valibot.object({ id: valibot.string() });
+
+//#endregion
+//#region src/request/types/stxMethods/getAccounts.ts
+const stxGetAccountsMethodName = "stx_getAccounts";
+const stxGetAccountsParamsSchema = valibot.nullish(valibot.null());
+const stxGetAccountsResultSchema = valibot.object({
+	addresses: valibot.array(valibot.object({
+		address: valibot.string(),
+		publicKey: valibot.string(),
+		gaiaHubUrl: valibot.string(),
+		gaiaAppKey: valibot.string()
+	})),
+	network: getNetworkResultSchema
+});
+const stxGetAccountsRequestMessageSchema = valibot.object({
+	...rpcRequestMessageSchema.entries,
+	...valibot.object({
+		method: valibot.literal(stxGetAccountsMethodName),
+		params: stxGetAccountsParamsSchema,
+		id: valibot.string()
+	}).entries
+});
+
+//#endregion
+//#region src/request/types/stxMethods/getAddresses.ts
+const stxGetAddressesMethodName = "stx_getAddresses";
+const stxGetAddressesParamsSchema = valibot.nullish(valibot.object({ message: valibot.optional(valibot.string()) }));
+const stxGetAddressesResultSchema = valibot.object({
+	addresses: valibot.array(addressSchema),
+	network: stacksNetworkSchema
+});
+const stxGetAddressesRequestMessageSchema = valibot.object({
+	...rpcRequestMessageSchema.entries,
+	...valibot.object({
+		method: valibot.literal(stxGetAddressesMethodName),
+		params: stxGetAddressesParamsSchema,
+		id: valibot.string()
+	}).entries
+});
+
+//#endregion
+//#region src/request/types/stxMethods/signMessage.ts
+const stxSignMessageMethodName = "stx_signMessage";
+const stxSignMessageParamsSchema = valibot.object({ message: valibot.string() });
+const stxSignMessageResultSchema = valibot.object({
+	signature: valibot.string(),
+	publicKey: valibot.string()
+});
+const stxSignMessageRequestMessageSchema = valibot.object({
+	...rpcRequestMessageSchema.entries,
+	...valibot.object({
+		method: valibot.literal(stxSignMessageMethodName),
+		params: stxSignMessageParamsSchema,
+		id: valibot.string()
+	}).entries
+});
+
+//#endregion
+//#region src/request/types/stxMethods/signStructuredMessage.ts
+const stxSignStructuredMessageMethodName = "stx_signStructuredMessage";
+const stxSignStructuredMessageParamsSchema = valibot.object({
+	domain: valibot.string(),
+	message: valibot.string(),
+	publicKey: valibot.optional(valibot.string())
+});
+const stxSignStructuredMessageResultSchema = valibot.object({
+	signature: valibot.string(),
+	publicKey: valibot.string()
+});
+const stxSignStructuredMessageRequestMessageSchema = valibot.object({
+	...rpcRequestMessageSchema.entries,
+	...valibot.object({
+		method: valibot.literal(stxSignStructuredMessageMethodName),
+		params: stxSignStructuredMessageParamsSchema,
+		id: valibot.string()
+	}).entries
+});
+
+//#endregion
+//#region src/request/types/stxMethods/signTransaction.ts
+const stxSignTransactionMethodName = "stx_signTransaction";
+const stxSignTransactionParamsSchema = valibot.object({
+	transaction: valibot.string(),
+	pubkey: valibot.optional(valibot.string()),
+	broadcast: valibot.optional(valibot.boolean())
+});
+const stxSignTransactionResultSchema = valibot.object({ transaction: valibot.string() });
+const stxSignTransactionRequestMessageSchema = valibot.object({
+	...rpcRequestMessageSchema.entries,
+	...valibot.object({
+		method: valibot.literal(stxSignTransactionMethodName),
+		params: stxSignTransactionParamsSchema,
+		id: valibot.string()
+	}).entries
+});
+
+//#endregion
+//#region src/request/types/stxMethods/signTransactions.ts
+const stxSignTransactionsMethodName = "stx_signTransactions";
+const stxSignTransactionsParamsSchema = valibot.object({
+	transactions: valibot.pipe(valibot.array(valibot.pipe(valibot.string(), valibot.check((hex) => {
+		return true;
+	}, "Invalid hex-encoded Stacks transaction."))), valibot.minLength(1)),
+	broadcast: valibot.optional(valibot.boolean())
+});
+const stxSignTransactionsResultSchema = valibot.object({ transactions: valibot.array(valibot.string()) });
+const stxSignTransactionsRequestMessageSchema = valibot.object({
+	...rpcRequestMessageSchema.entries,
+	...valibot.object({
+		method: valibot.literal(stxSignTransactionsMethodName),
+		params: stxSignTransactionsParamsSchema,
+		id: valibot.string()
+	}).entries
+});
+
+//#endregion
+//#region src/request/types/stxMethods/transferStx.ts
+const stxTransferStxMethodName = "stx_transferStx";
+const stxTransferStxParamsSchema = valibot.object({
+	amount: valibot.union([valibot.number(), valibot.string()]),
+	recipient: valibot.string(),
+	memo: valibot.optional(valibot.string()),
+	version: valibot.optional(valibot.string()),
+	postConditionMode: valibot.optional(valibot.number()),
+	postConditions: valibot.optional(valibot.array(valibot.string())),
+	pubkey: valibot.optional(valibot.string())
+});
+const stxTransferStxResultSchema = valibot.object({
+	txid: valibot.string(),
+	transaction: valibot.string()
+});
+const stxTransferStxRequestMessageSchema = valibot.object({
+	...rpcRequestMessageSchema.entries,
+	...valibot.object({
+		method: valibot.literal(stxTransferStxMethodName),
+		params: stxTransferStxParamsSchema,
+		id: valibot.string()
+	}).entries
+});
+
+//#endregion
+//#region src/request/index.ts
+const cache = {};
+const requestInternal = async (provider, method, params) => {
+	const response = await provider.request(method, params);
+	if (valibot.is(rpcErrorResponseMessageSchema, response)) return {
+		status: "error",
+		error: response.error
+	};
+	if (valibot.is(rpcSuccessResponseMessageSchema, response)) return {
+		status: "success",
+		result: response.result
+	};
+	return {
+		status: "error",
+		error: {
+			code: RpcErrorCode.INTERNAL_ERROR,
+			message: "Received unknown response from provider.",
+			data: response
+		}
+	};
+};
+const request = async (method, params, providerId) => {
+	let provider = window.XverseProviders?.BitcoinProvider || window.BitcoinProvider;
+	if (providerId) provider = await getProviderById(providerId);
+	if (!provider) throw new Error("no wallet provider was found");
+	if (!method) throw new Error("A wallet method is required");
+	if (!cache.providerInfo) {
+		const infoResult = await requestInternal(provider, "getInfo", null);
+		if (infoResult.status === "success") cache.providerInfo = infoResult.result;
+	}
+	if (cache.providerInfo) {
+		if (method === "getInfo") return {
+			status: "success",
+			result: cache.providerInfo
+		};
+		const sanitized = sanitizeRequest(method, params, cache.providerInfo);
+		if (sanitized.overrideResponse) return sanitized.overrideResponse;
+		method = sanitized.method;
+		params = sanitized.params;
+	}
+	return requestInternal(provider, method, params);
+};
+/**
+* Adds an event listener.
+*
+* Currently expects 2 arguments, although is also capable of handling legacy
+* calls with 3 arguments consisting of:
+*
+* - event name (string)
+* - callback (function)
+* - provider ID (optional string)
+*/
+const addListener = (...rawArgs) => {
+	const [listenerInfo, providerId] = (() => {
+		if (rawArgs.length === 1) return [rawArgs[0], void 0];
+		if (rawArgs.length === 2) if (typeof rawArgs[1] === "function") return [{
+			eventName: rawArgs[0],
+			cb: rawArgs[1]
+		}, void 0];
+		else return rawArgs;
+		if (rawArgs.length === 3) return [{
+			eventName: rawArgs[0],
+			cb: rawArgs[1]
+		}, rawArgs[2]];
+		throw new Error("Unexpected number of arguments. Expecting 2 (or 3 for legacy requests).", { cause: rawArgs });
+	})();
+	let provider = window.XverseProviders?.BitcoinProvider || window.BitcoinProvider;
+	if (providerId) provider = getProviderById(providerId);
+	if (!provider) throw new Error("no wallet provider was found");
+	if (!provider.addListener) {
+		console.error(`The wallet provider you are using does not support the addListener method. Please update your wallet provider.`);
+		return () => {};
+	}
+	return provider.addListener(listenerInfo);
+};
+
+//#endregion
+//#region src/runes/api.ts
+const urlNetworkSuffix = {
+	[BitcoinNetworkType.Mainnet]: "",
+	[BitcoinNetworkType.Testnet]: "-testnet",
+	[BitcoinNetworkType.Testnet4]: "-testnet4",
+	[BitcoinNetworkType.Signet]: "-signet"
+};
+const ORDINALS_API_BASE_URL = (network = BitcoinNetworkType.Mainnet) => {
+	if (network === BitcoinNetworkType.Regtest) throw new Error(`Ordinals API does not support ${network} network`);
+	return `https://ordinals${urlNetworkSuffix[network]}.xverse.app/v1`;
+};
+var RunesApi = class {
+	client;
+	constructor(network) {
+		this.client = axios.default.create({ baseURL: ORDINALS_API_BASE_URL(network) });
+	}
+	parseError = (error) => {
+		return {
+			code: error.response?.status,
+			message: JSON.stringify(error.response?.data)
+		};
+	};
+	estimateMintCost = async (mintParams) => {
+		try {
+			return { data: (await this.client.post("/runes/mint/estimate", { ...mintParams })).data };
+		} catch (error) {
+			const err = error;
+			return { error: this.parseError(err) };
+		}
+	};
+	estimateEtchCost = async (etchParams) => {
+		try {
+			return { data: (await this.client.post("/runes/etch/estimate", { ...etchParams })).data };
+		} catch (error) {
+			const err = error;
+			return { error: this.parseError(err) };
+		}
+	};
+	createMintOrder = async (mintOrderParams) => {
+		try {
+			return { data: (await this.client.post("/runes/mint/orders", { ...mintOrderParams })).data };
+		} catch (error) {
+			const err = error;
+			return { error: this.parseError(err) };
+		}
+	};
+	createEtchOrder = async (etchOrderParams) => {
+		try {
+			return { data: (await this.client.post("/runes/etch/orders", { ...etchOrderParams })).data };
+		} catch (error) {
+			const err = error;
+			return { error: this.parseError(err) };
+		}
+	};
+	executeMint = async (orderId, fundTransactionId) => {
+		try {
+			return { data: (await this.client.post(`/runes/mint/orders/${orderId}/execute`, { fundTransactionId })).data };
+		} catch (error) {
+			const err = error;
+			return { error: this.parseError(err) };
+		}
+	};
+	executeEtch = async (orderId, fundTransactionId) => {
+		try {
+			return { data: (await this.client.post(`/runes/etch/orders/${orderId}/execute`, { fundTransactionId })).data };
+		} catch (error) {
+			const err = error;
+			return { error: this.parseError(err) };
+		}
+	};
+	getOrder = async (orderId) => {
+		try {
+			return { data: (await this.client.get(`/orders/${orderId}`)).data };
+		} catch (error) {
+			const err = error;
+			return { error: this.parseError(err) };
+		}
+	};
+	rbfOrder = async (rbfRequest) => {
+		const { orderId, newFeeRate } = rbfRequest;
+		try {
+			return { data: (await this.client.post(`/orders/${orderId}/rbf-estimate`, { newFeeRate })).data };
+		} catch (error) {
+			const err = error;
+			return { error: this.parseError(err) };
+		}
+	};
+};
+const clients = {};
+const getRunesApiClient = (network = BitcoinNetworkType.Mainnet) => {
+	if (!clients[network]) clients[network] = new RunesApi(network);
+	return clients[network];
+};
+
+//#endregion
+//#region src/adapters/satsConnectAdapter.ts
+var SatsConnectAdapter = class {
+	async mintRunes(params) {
+		try {
+			const walletInfo = await this.requestInternal("getInfo", null).catch(() => null);
+			if (walletInfo && walletInfo.status === "success") {
+				if (walletInfo.result.methods?.includes("runes_mint")) {
+					const response = await this.requestInternal("runes_mint", params);
+					if (response) {
+						if (response.status === "success") return response;
+						if (response.status === "error" && response.error.code !== RpcErrorCode.METHOD_NOT_FOUND) return response;
+					}
+				}
+			}
+			const mintRequest = {
+				destinationAddress: params.destinationAddress,
+				feeRate: params.feeRate,
+				refundAddress: params.refundAddress,
+				repeats: params.repeats,
+				runeName: params.runeName,
+				appServiceFee: params.appServiceFee,
+				appServiceFeeAddress: params.appServiceFeeAddress
+			};
+			const orderResponse = await new RunesApi(params.network).createMintOrder(mintRequest);
+			if (!orderResponse.data) return {
+				status: "error",
+				error: {
+					code: orderResponse.error.code === 400 ? RpcErrorCode.INVALID_REQUEST : RpcErrorCode.INTERNAL_ERROR,
+					message: orderResponse.error.message
+				}
+			};
+			const paymentResponse = await this.requestInternal("sendTransfer", { recipients: [{
+				address: orderResponse.data.fundAddress,
+				amount: orderResponse.data.fundAmount
+			}] });
+			if (paymentResponse.status !== "success") return paymentResponse;
+			await new RunesApi(params.network).executeMint(orderResponse.data.orderId, paymentResponse.result.txid);
+			return {
+				status: "success",
+				result: {
+					orderId: orderResponse.data.orderId,
+					fundTransactionId: paymentResponse.result.txid,
+					fundingAddress: orderResponse.data.fundAddress
+				}
+			};
+		} catch (error) {
+			return {
+				status: "error",
+				error: {
+					code: RpcErrorCode.INTERNAL_ERROR,
+					message: error.message
+				}
+			};
+		}
+	}
+	async etchRunes(params) {
+		const etchRequest = {
+			destinationAddress: params.destinationAddress,
+			refundAddress: params.refundAddress,
+			feeRate: params.feeRate,
+			runeName: params.runeName,
+			divisibility: params.divisibility,
+			symbol: params.symbol,
+			premine: params.premine,
+			isMintable: params.isMintable,
+			terms: params.terms,
+			inscriptionDetails: params.inscriptionDetails,
+			delegateInscriptionId: params.delegateInscriptionId,
+			appServiceFee: params.appServiceFee,
+			appServiceFeeAddress: params.appServiceFeeAddress
+		};
+		try {
+			const walletInfo = await this.requestInternal("getInfo", null).catch(() => null);
+			if (walletInfo && walletInfo.status === "success") {
+				if (walletInfo.result.methods?.includes("runes_etch")) {
+					const response = await this.requestInternal("runes_etch", params);
+					if (response) {
+						if (response.status === "success") return response;
+						if (response.status === "error" && response.error.code !== RpcErrorCode.METHOD_NOT_FOUND) return response;
+					}
+				}
+			}
+			const orderResponse = await new RunesApi(params.network).createEtchOrder(etchRequest);
+			if (!orderResponse.data) return {
+				status: "error",
+				error: {
+					code: orderResponse.error.code === 400 ? RpcErrorCode.INVALID_REQUEST : RpcErrorCode.INTERNAL_ERROR,
+					message: orderResponse.error.message
+				}
+			};
+			const paymentResponse = await this.requestInternal("sendTransfer", { recipients: [{
+				address: orderResponse.data.fundAddress,
+				amount: orderResponse.data.fundAmount
+			}] });
+			if (paymentResponse.status !== "success") return paymentResponse;
+			await new RunesApi(params.network).executeEtch(orderResponse.data.orderId, paymentResponse.result.txid);
+			return {
+				status: "success",
+				result: {
+					orderId: orderResponse.data.orderId,
+					fundTransactionId: paymentResponse.result.txid,
+					fundingAddress: orderResponse.data.fundAddress
+				}
+			};
+		} catch (error) {
+			return {
+				status: "error",
+				error: {
+					code: RpcErrorCode.INTERNAL_ERROR,
+					message: error.message
+				}
+			};
+		}
+	}
+	async estimateMint(params) {
+		const estimateMintRequest = {
+			destinationAddress: params.destinationAddress,
+			feeRate: params.feeRate,
+			repeats: params.repeats,
+			runeName: params.runeName,
+			appServiceFee: params.appServiceFee,
+			appServiceFeeAddress: params.appServiceFeeAddress
+		};
+		const response = await getRunesApiClient(params.network).estimateMintCost(estimateMintRequest);
+		if (response.data) return {
+			status: "success",
+			result: response.data
+		};
+		return {
+			status: "error",
+			error: {
+				code: response.error.code === 400 ? RpcErrorCode.INVALID_REQUEST : RpcErrorCode.INTERNAL_ERROR,
+				message: response.error.message
+			}
+		};
+	}
+	async estimateEtch(params) {
+		const estimateEtchRequest = {
+			destinationAddress: params.destinationAddress,
+			feeRate: params.feeRate,
+			runeName: params.runeName,
+			divisibility: params.divisibility,
+			symbol: params.symbol,
+			premine: params.premine,
+			isMintable: params.isMintable,
+			terms: params.terms,
+			inscriptionDetails: params.inscriptionDetails,
+			delegateInscriptionId: params.delegateInscriptionId,
+			appServiceFee: params.appServiceFee,
+			appServiceFeeAddress: params.appServiceFeeAddress
+		};
+		const response = await getRunesApiClient(params.network).estimateEtchCost(estimateEtchRequest);
+		if (response.data) return {
+			status: "success",
+			result: response.data
+		};
+		return {
+			status: "error",
+			error: {
+				code: response.error.code === 400 ? RpcErrorCode.INVALID_REQUEST : RpcErrorCode.INTERNAL_ERROR,
+				message: response.error.message
+			}
+		};
+	}
+	async getOrder(params) {
+		const response = await getRunesApiClient(params.network).getOrder(params.id);
+		if (response.data) return {
+			status: "success",
+			result: response.data
+		};
+		return {
+			status: "error",
+			error: {
+				code: response.error.code === 400 || response.error.code === 404 ? RpcErrorCode.INVALID_REQUEST : RpcErrorCode.INTERNAL_ERROR,
+				message: response.error.message
+			}
+		};
+	}
+	async estimateRbfOrder(params) {
+		const rbfOrderRequest = {
+			newFeeRate: params.newFeeRate,
+			orderId: params.orderId
+		};
+		const response = await getRunesApiClient(params.network).rbfOrder(rbfOrderRequest);
+		if (response.data) return {
+			status: "success",
+			result: {
+				fundingAddress: response.data.fundingAddress,
+				rbfCost: response.data.rbfCost
+			}
+		};
+		return {
+			status: "error",
+			error: {
+				code: response.error.code === 400 || response.error.code === 404 ? RpcErrorCode.INVALID_REQUEST : RpcErrorCode.INTERNAL_ERROR,
+				message: response.error.message
+			}
+		};
+	}
+	async rbfOrder(params) {
+		try {
+			const rbfOrderRequest = {
+				newFeeRate: params.newFeeRate,
+				orderId: params.orderId
+			};
+			const orderResponse = await getRunesApiClient(params.network).rbfOrder(rbfOrderRequest);
+			if (!orderResponse.data) return {
+				status: "error",
+				error: {
+					code: orderResponse.error.code === 400 || orderResponse.error.code === 404 ? RpcErrorCode.INVALID_REQUEST : RpcErrorCode.INTERNAL_ERROR,
+					message: orderResponse.error.message
+				}
+			};
+			const paymentResponse = await this.requestInternal("sendTransfer", { recipients: [{
+				address: orderResponse.data.fundingAddress,
+				amount: orderResponse.data.rbfCost
+			}] });
+			if (paymentResponse.status !== "success") return paymentResponse;
+			return {
+				status: "success",
+				result: {
+					fundingAddress: orderResponse.data.fundingAddress,
+					orderId: rbfOrderRequest.orderId,
+					fundRBFTransactionId: paymentResponse.result.txid
+				}
+			};
+		} catch (error) {
+			return {
+				status: "error",
+				error: {
+					code: RpcErrorCode.INTERNAL_ERROR,
+					message: error.message
+				}
+			};
+		}
+	}
+	async request(method, params) {
+		switch (method) {
+			case "runes_mint": return this.mintRunes(params);
+			case "runes_etch": return this.etchRunes(params);
+			case "runes_estimateMint": return this.estimateMint(params);
+			case "runes_estimateEtch": return this.estimateEtch(params);
+			case "runes_getOrder": return this.getOrder(params);
+			case "runes_estimateRbfOrder": return this.estimateRbfOrder(params);
+			case "runes_rbfOrder": return this.rbfOrder(params);
+			default: return this.requestInternal(method, params);
+		}
+	}
+};
+
+//#endregion
+//#region src/adapters/xverse.ts
+var XverseAdapter = class extends SatsConnectAdapter {
+	id = DefaultAdaptersInfo.xverse.id;
+	requestInternal = async (method, params) => {
+		return request(method, params, this.id);
+	};
+	addListener = (listenerInfo) => {
+		return addListener(listenerInfo, this.id);
+	};
+};
+
+//#endregion
+//#region src/adapters/unisat.ts
+function convertSignInputsToInputType(signInputs) {
+	let result = [];
+	if (!signInputs) return result;
+	for (let address in signInputs) {
+		let indexes = signInputs[address];
+		for (let index of indexes) result.push({
+			index,
+			address
+		});
+	}
+	return result;
+}
+var UnisatAdapter = class extends SatsConnectAdapter {
+	id = DefaultAdaptersInfo.unisat.id;
+	async getAccounts(params) {
+		const { purposes } = params;
+		if (purposes.includes(AddressPurpose.Stacks) || purposes.includes(AddressPurpose.Starknet) || purposes.includes(AddressPurpose.Spark)) throw new Error("Only bitcoin addresses are supported");
+		const accounts = await window.unisat.requestAccounts();
+		const publicKey = await window.unisat.getPublicKey();
+		const address = accounts[0];
+		const addressType = (0, bitcoin_address_validation.getAddressInfo)(accounts[0]).type;
+		const pk = addressType === bitcoin_address_validation.AddressType.p2tr ? publicKey.slice(2) : publicKey;
+		const paymentAddress = {
+			address,
+			publicKey: pk,
+			addressType,
+			purpose: AddressPurpose.Payment,
+			walletType: "software"
+		};
+		const ordinalsAddress = {
+			address,
+			publicKey: pk,
+			addressType,
+			purpose: AddressPurpose.Ordinals,
+			walletType: "software"
+		};
+		const response = [];
+		if (purposes.includes(AddressPurpose.Payment)) response.push({
+			...paymentAddress,
+			walletType: "software"
+		});
+		if (purposes.includes(AddressPurpose.Ordinals)) response.push({
+			...ordinalsAddress,
+			walletType: "software"
+		});
+		return response;
+	}
+	async signMessage(params) {
+		const { message, address } = params;
+		const addressType = (0, bitcoin_address_validation.getAddressInfo)(address).type;
+		if ([bitcoin_address_validation.AddressType.p2wpkh, bitcoin_address_validation.AddressType.p2tr].includes(addressType)) return {
+			address,
+			messageHash: "",
+			signature: await window.unisat.signMessage(message, "bip322-simple"),
+			protocol: MessageSigningProtocols.BIP322
+		};
+		return {
+			address,
+			messageHash: "",
+			signature: await window.unisat.signMessage(message, "ecdsa"),
+			protocol: MessageSigningProtocols.ECDSA
+		};
+	}
+	async sendTransfer(params) {
+		const { recipients } = params;
+		if (recipients.length > 1) throw new Error("Only one recipient is supported by this wallet provider");
+		return { txid: await window.unisat.sendBitcoin(recipients[0].address, recipients[0].amount) };
+	}
+	async signPsbt(params) {
+		const { psbt, signInputs, broadcast } = params;
+		const psbtHex = buffer.Buffer.from(psbt, "base64").toString("hex");
+		const signedPsbt = await window.unisat.signPsbt(psbtHex, {
+			autoFinalized: broadcast,
+			toSignInputs: convertSignInputsToInputType(signInputs)
+		});
+		const signedPsbtBase64 = buffer.Buffer.from(signedPsbt, "hex").toString("base64");
+		let txid;
+		if (broadcast) txid = await window.unisat.pushPsbt(signedPsbt);
+		return {
+			psbt: signedPsbtBase64,
+			txid
+		};
+	}
+	requestInternal = async (method, params) => {
+		try {
+			switch (method) {
+				case "getAccounts": return {
+					status: "success",
+					result: await this.getAccounts(params)
+				};
+				case "sendTransfer": return {
+					status: "success",
+					result: await this.sendTransfer(params)
+				};
+				case "signMessage": return {
+					status: "success",
+					result: await this.signMessage(params)
+				};
+				case "signPsbt": return {
+					status: "success",
+					result: await this.signPsbt(params)
+				};
+				default: {
+					const error = {
+						code: RpcErrorCode.METHOD_NOT_SUPPORTED,
+						message: "Method not supported by the selected wallet"
+					};
+					console.error("Error calling the method", error);
+					return {
+						status: "error",
+						error
+					};
+				}
+			}
+		} catch (error) {
+			console.error("Error calling the method", error);
+			return {
+				status: "error",
+				error: {
+					code: error.code === 4001 ? RpcErrorCode.USER_REJECTION : RpcErrorCode.INTERNAL_ERROR,
+					message: error.message ? error.message : "Wallet method call error",
+					data: error
+				}
+			};
+		}
+	};
+	addListener = ({ eventName, cb }) => {
+		switch (eventName) {
+			case "accountChange": {
+				const handler = () => {
+					cb({ type: "accountChange" });
+				};
+				window.unisat.on("accountsChanged", handler);
+				return () => {
+					window.unisat.removeListener("accountsChanged", handler);
+				};
+			}
+			case "networkChange": {
+				const handler = () => {
+					cb({ type: "networkChange" });
+				};
+				window.unisat.on("networkChanged", handler);
+				return () => {
+					window.unisat.removeListener("networkChanged", handler);
+				};
+			}
+			default:
+				console.error("Event not supported by the selected wallet");
+				return () => {};
+		}
+	};
+};
+
+//#endregion
+//#region src/adapters/fordefi.ts
+var FordefiAdapter = class extends SatsConnectAdapter {
+	id = DefaultAdaptersInfo.fordefi.id;
+	requestInternal = async (method, params) => {
+		const provider = getProviderById(this.id);
+		if (!provider) throw new Error("no wallet provider was found");
+		if (!method) throw new Error("A wallet method is required");
+		return await provider.request(method, params);
+	};
+	addListener = ({ eventName, cb }) => {
+		const provider = getProviderById(this.id);
+		if (!provider) throw new Error("no wallet provider was found");
+		if (!provider.addListener) {
+			console.error(`The wallet provider you are using does not support the addListener method. Please update your wallet provider.`);
+			return () => {};
+		}
+		return provider.addListener(eventName, cb);
+	};
+};
+
+//#endregion
+//#region src/adapters/BaseAdapter.ts
+var BaseAdapter = class extends SatsConnectAdapter {
+	id = "";
+	constructor(providerId) {
+		super();
+		this.id = providerId;
+	}
+	requestInternal = async (method, params) => {
+		return request(method, params, this.id);
+	};
+	addListener = (..._args) => {
+		throw new Error("Method not supported for `BaseAdapter`.");
+	};
+};
+
+//#endregion
+//#region src/adapters/index.ts
+const DefaultAdaptersInfo = {
+	fordefi: {
+		id: "FordefiProviders.UtxoProvider",
+		name: "Fordefi",
+		webUrl: "https://www.fordefi.com/",
+		chromeWebStoreUrl: "https://chromewebstore.google.com/detail/fordefi/hcmehenccjdmfbojapcbcofkgdpbnlle",
+		icon: "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPGcgY2xpcC1wYXRoPSJ1cmwoI2NsaXAwXzEzNDk0XzY2MjU0KSI+CjxwYXRoIGQ9Ik0xMC44NzY5IDE1LjYzNzhIMS41VjE4LjM5OUMxLjUgMTkuODAxMyAyLjYzNDQ3IDIwLjkzOCA0LjAzMzkyIDIwLjkzOEg4LjI0OTkyTDEwLjg3NjkgMTUuNjM3OFoiIGZpbGw9IiM3OTk0RkYiLz4KPHBhdGggZD0iTTEuNSA5Ljc3NTUxSDE5LjA1MTZMMTcuMDEzOSAxMy44NzExSDEuNVY5Ljc3NTUxWiIgZmlsbD0iIzQ4NkRGRiIvPgo8cGF0aCBkPSJNNy42NTk5NiAzSDEuNTI0NDFWOC4wMDcwNEgyMi40NjEyVjNIMTYuMzI1NlY2LjczOTQ0SDE1LjA2MDZWM0g4LjkyNTAyVjYuNzM5NDRINy42NTk5NlYzWiIgZmlsbD0iIzVDRDFGQSIvPgo8L2c+CjxkZWZzPgo8Y2xpcFBhdGggaWQ9ImNsaXAwXzEzNDk0XzY2MjU0Ij4KPHJlY3Qgd2lkdGg9IjIxIiBoZWlnaHQ9IjE4IiBmaWxsPSJ3aGl0ZSIgdHJhbnNmb3JtPSJ0cmFuc2xhdGUoMS41IDMpIi8+CjwvY2xpcFBhdGg+CjwvZGVmcz4KPC9zdmc+Cg=="
+	},
+	xverse: {
+		id: "XverseProviders.BitcoinProvider",
+		name: "Xverse",
+		webUrl: "https://www.xverse.app/",
+		googlePlayStoreUrl: "https://play.google.com/store/apps/details?id=com.secretkeylabs.xverse",
+		iOSAppStoreUrl: "https://apps.apple.com/app/xverse-bitcoin-web3-wallet/id1552272513",
+		chromeWebStoreUrl: "https://chromewebstore.google.com/detail/xverse-wallet/idnnbdplmphpflfnlkomgpfbpcgelopg",
+		icon: "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTAyIiBoZWlnaHQ9IjEwMiIgdmlld0JveD0iMCAwIDEwMiAxMDIiIGZpbGw9Im5vbmUiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+CjxnIGlkPSJJY29uX0FydCAoRWRpdCBNZSkiPgo8cmVjdCB3aWR0aD0iMTAyIiBoZWlnaHQ9IjEwMiIgZmlsbD0iIzE4MTgxOCIvPgo8ZyBpZD0iTG9nby9FbWJsZW0iIGNsaXAtcGF0aD0idXJsKCNjbGlwMF8yMF8xMjIzKSI+CjxwYXRoIGlkPSJWZWN0b3IiIGQ9Ik03NC42NTQyIDczLjg4ODNWNjUuMjMxMkM3NC42NTQyIDY0Ljg4OCA3NC41MTc3IDY0LjU2MDYgNzQuMjc0NSA2NC4zMTc0TDM3LjQzOTcgMjcuNDgyNUMzNy4xOTY1IDI3LjIzOTIgMzYuODY5MSAyNy4xMDI4IDM2LjUyNTggMjcuMTAyOEgyNy44NjlDMjcuNDQxNiAyNy4xMDI4IDI3LjA5MzggMjcuNDUwNiAyNy4wOTM4IDI3Ljg3OFYzNS45MjExQzI3LjA5MzggMzYuMjY0NCAyNy4yMzAyIDM2LjU5MTcgMjcuNDczNCAzNi44MzVMNDAuNjk1MiA1MC4wNTY3QzQwLjk5NzUgNTAuMzU5MSA0MC45OTc1IDUwLjg1MDEgNDAuNjk1MiA1MS4xNTI0TDI3LjMyMTEgNjQuNTI2NUMyNy4xNzU2IDY0LjY3MiAyNy4wOTM4IDY0Ljg2OTggMjcuMDkzOCA2NS4wNzQ0VjczLjg4ODNDMjcuMDkzOCA3NC4zMTUzIDI3LjQ0MTYgNzQuNjYzNSAyNy44NjkgNzQuNjYzNUg0Mi4zMzQyQzQyLjc2MTYgNzQuNjYzNSA0My4xMDk0IDc0LjMxNTMgNDMuMTA5NCA3My44ODgzVjY4LjY5NThDNDMuMTA5NCA2OC40OTEyIDQzLjE5MTIgNjguMjkzNSA0My4zMzY4IDY4LjE0NzlMNTAuNTExNCA2MC45NzMzQzUwLjgxMzggNjAuNjcwOSA1MS4zMDQ4IDYwLjY3MDkgNTEuNjA3MiA2MC45NzMzTDY0LjkxOTggNzQuMjg2MUM2NS4xNjMxIDc0LjUyOTMgNjUuNDkwNCA3NC42NjU4IDY1LjgzMzcgNzQuNjY1OEg3My44NzY3Qzc0LjMwNDIgNzQuNjY1OCA3NC42NTE5IDc0LjMxNzYgNzQuNjUxOSA3My44OTA2TDc0LjY1NDIgNzMuODg4M1oiIGZpbGw9IndoaXRlIi8+CjxwYXRoIGlkPSJWZWN0b3JfMiIgZD0iTTU1LjM1OCAzOC41NjcySDYyLjYwMzFDNjMuMDMyOCAzOC41NjcyIDYzLjM4MjkgMzguOTE3MyA2My4zODI5IDM5LjM0NjlWNDYuNTkyMUM2My4zODI5IDQ3LjI4NzcgNjQuMjI0IDQ3LjYzNTUgNjQuNzE1MSA0Ny4xNDIyTDc0LjY1NDEgMzcuMTg3M0M3NC43OTk0IDM3LjA0MTggNzQuODgxNiAzNi44NDQgNzQuODgxNiAzNi42MzcxVjI3LjkxODlDNzQuODgxNiAyNy40ODkyIDc0LjUzMzQgMjcuMTM5MSA3NC4xMDE3IDI3LjEzOTFMNjUuMjUzOCAyNy4xMjc3QzY1LjA0NyAyNy4xMjc3IDY0Ljg0OTIgMjcuMjA5NiA2NC43MDE0IDI3LjM1NTFMNTQuODA1NiAzNy4yMzVDNTQuMzE0NSAzNy43MjYgNTQuNjYyMyAzOC41NjcyIDU1LjM1NTcgMzguNTY3Mkg1NS4zNThaIiBmaWxsPSIjRUU3QTMwIi8+CjwvZz4KPC9nPgo8ZGVmcz4KPGNsaXBQYXRoIGlkPSJjbGlwMF8yMF8xMjIzIj4KPHJlY3Qgd2lkdGg9IjQ3LjgxMjUiIGhlaWdodD0iNDcuODEyNSIgZmlsbD0id2hpdGUiIHRyYW5zZm9ybT0idHJhbnNsYXRlKDI3LjA5MzggMjcuMDkzOCkiLz4KPC9jbGlwUGF0aD4KPC9kZWZzPgo8L3N2Zz4K"
+	},
+	unisat: {
+		id: "unisat",
+		name: "Unisat",
+		webUrl: "https://unisat.io/",
+		icon: "data:image/svg+xml;base64,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"
+	}
+};
+const defaultAdapters = {
+	[DefaultAdaptersInfo.fordefi.id]: FordefiAdapter,
+	[DefaultAdaptersInfo.xverse.id]: XverseAdapter,
+	[DefaultAdaptersInfo.unisat.id]: UnisatAdapter
+};
+
+//#endregion
+//#region src/capabilities/index.ts
+const extractOrValidateCapabilities = (provider, reportedCapabilities) => {
+	const validateCapability = (capability) => {
+		if (!provider[capability]) return false;
+		if (reportedCapabilities && !reportedCapabilities.has(capability)) return false;
+		return true;
+	};
+	const capabilityMap = {
+		request: validateCapability("request"),
+		connect: validateCapability("connect"),
+		signMessage: validateCapability("signMessage"),
+		signTransaction: validateCapability("signTransaction"),
+		sendBtcTransaction: validateCapability("sendBtcTransaction"),
+		createInscription: validateCapability("createInscription"),
+		createRepeatInscriptions: validateCapability("createRepeatInscriptions"),
+		signMultipleTransactions: validateCapability("signMultipleTransactions"),
+		addListener: validateCapability("addListener")
+	};
+	return Object.entries(capabilityMap).reduce((acc, [capability, value]) => {
+		if (value) return [...acc, capability];
+		return acc;
+	}, []);
+};
+const getCapabilities = async (options) => {
+	const provider = await getProviderOrThrow(options.getProvider);
+	const request$1 = (0, jsontokens.createUnsecuredToken)(options.payload);
+	if (provider.getCapabilities) try {
+		const response = await provider.getCapabilities(request$1);
+		options.onFinish?.(extractOrValidateCapabilities(provider, new Set(response)));
+	} catch (error) {
+		console.error("[Connect] Error during capabilities request", error);
+	}
+	try {
+		const inferredCapabilities = extractOrValidateCapabilities(provider);
+		options.onFinish?.(inferredCapabilities);
+	} catch (error) {
+		console.error("[Connect] Error during capabilities request", error);
+		options.onCancel?.();
+	}
+};
+
+//#endregion
+//#region src/inscriptions/utils.ts
+const MAX_CONTENT_LENGTH_MAINNET = 4e5;
+const MAX_CONTENT_LENGTH_TESTNET = 6e4;
+const validateInscriptionPayload = (payload) => {
+	const { contentType, content, payloadType, network, appFeeAddress, appFee } = payload;
+	if (!/^[a-z]+\/[a-z0-9\-\.\+]+(?=;.*|$)/.test(contentType)) throw new Error("Invalid content type detected");
+	if (!content || content.length === 0) throw new Error("Empty content not allowed");
+	if (!payloadType || payloadType !== "BASE_64" && payloadType !== "PLAIN_TEXT") throw new Error("Empty invalid payloadType specified");
+	if (content.length > (network.type === "Mainnet" ? MAX_CONTENT_LENGTH_MAINNET : MAX_CONTENT_LENGTH_TESTNET)) throw new Error("Content too large");
+	if ((appFeeAddress?.length ?? 0) > 0 && (appFee ?? 0) <= 0) throw new Error("Invalid combination of app fee address and fee provided");
+};
+
+//#endregion
+//#region src/inscriptions/createInscription.ts
+const createInscription = async (options) => {
+	const { getProvider } = options;
+	const provider = await getProviderOrThrow(getProvider);
+	validateInscriptionPayload(options.payload);
+	try {
+		const request$1 = (0, jsontokens.createUnsecuredToken)(options.payload);
+		const response = await provider.createInscription(request$1);
+		options.onFinish?.(response);
+	} catch (error) {
+		console.error("[Connect] Error during create inscription", error);
+		options.onCancel?.();
+	}
+};
+
+//#endregion
+//#region src/inscriptions/createRepeatInscriptions.ts
+const createRepeatInscriptions = async (options) => {
+	const { getProvider } = options;
+	const provider = await getProviderOrThrow(getProvider);
+	validateInscriptionPayload(options.payload);
+	try {
+		const request$1 = (0, jsontokens.createUnsecuredToken)(options.payload);
+		const response = await provider.createRepeatInscriptions(request$1);
+		options.onFinish?.(response);
+	} catch (error) {
+		console.error("[Connect] Error during create repeat inscriptions", error);
+		options.onCancel?.();
+	}
+};
+
+//#endregion
+//#region src/messages/index.ts
+const signMessage = async (options) => {
+	const provider = await getProviderOrThrow(options.getProvider);
+	const { address, message } = options.payload;
+	if (!address) throw new Error("An address is required to sign a message");
+	if (!message) throw new Error("A message to be signed is required");
+	try {
+		const request$1 = (0, jsontokens.createUnsecuredToken)(options.payload);
+		const response = await provider.signMessage(request$1);
+		options.onFinish?.(response);
+	} catch (error) {
+		console.error("[Connect] Error during sign message request", error);
+		options.onCancel?.();
+	}
+};
+
+//#endregion
+//#region src/transactions/sendBtcTransaction.ts
+const serializer = (recipient) => {
+	return recipient.map((value) => {
+		const { address, amountSats } = value;
+		return {
+			address,
+			amountSats: amountSats.toString()
+		};
+	});
+};
+const sendBtcTransaction = async (options) => {
+	const provider = await getProviderOrThrow(options.getProvider);
+	const { recipients, senderAddress, network, message } = options.payload;
+	if (!recipients || recipients.length === 0) throw new Error("At least one recipient is required");
+	if (recipients.some((item) => typeof item.address !== "string" || typeof item.amountSats !== "bigint")) throw new Error("Incorrect recipient format");
+	if (!senderAddress) throw new Error("The sender address is required");
+	try {
+		const request$1 = (0, jsontokens.createUnsecuredToken)({
+			network,
+			senderAddress,
+			message,
+			recipients: serializer(recipients)
+		});
+		const response = await provider.sendBtcTransaction(request$1);
+		options.onFinish?.(response);
+	} catch (error) {
+		console.error("[Connect] Error during send BTC transaction request", error);
+		options.onCancel?.();
+	}
+};
+
+//#endregion
+//#region src/transactions/signTransaction.ts
+const signTransaction = async (options) => {
+	const provider = await getProviderOrThrow(options.getProvider);
+	const { psbtBase64, inputsToSign } = options.payload;
+	if (!psbtBase64) throw new Error("A value for psbtBase64 representing the tx hash is required");
+	if (!inputsToSign) throw new Error("An array specifying the inputs to be signed by the wallet is required");
+	try {
+		const request$1 = (0, jsontokens.createUnsecuredToken)(options.payload);
+		const response = await provider.signTransaction(request$1);
+		options.onFinish?.(response);
+	} catch (error) {
+		console.error("[Connect] Error during sign transaction request", error);
+		options.onCancel?.();
+	}
+};
+
+//#endregion
+//#region src/transactions/signMultipleTransactions.ts
+const signMultipleTransactions = async (options) => {
+	const provider = await getProviderOrThrow(options.getProvider);
+	const { psbts } = options.payload;
+	if (!psbts || !psbts.length) throw new Error("psbts array is required");
+	if (psbts.length > 100) throw new Error("psbts array must contain less than 100 psbts");
+	try {
+		const request$1 = (0, jsontokens.createUnsecuredToken)(options.payload);
+		const response = await provider.signMultipleTransactions(request$1);
+		options.onFinish?.(response);
+	} catch (error) {
+		console.error("[Connect] Error during sign Multiple transactions request", error);
+		options.onCancel?.();
+	}
+};
+
+//#endregion
+exports.AddressPurpose = AddressPurpose;
+exports.AddressType = AddressType;
+exports.BaseAdapter = BaseAdapter;
+exports.BitcoinNetworkType = BitcoinNetworkType;
+exports.DefaultAdaptersInfo = DefaultAdaptersInfo;
+exports.MessageSigningProtocols = MessageSigningProtocols;
+exports.PermissionRequestParams = PermissionRequestParams;
+exports.ProviderPlatform = ProviderPlatform;
+exports.RpcErrorCode = RpcErrorCode;
+exports.RpcIdSchema = RpcIdSchema;
+exports.SatsConnectAdapter = SatsConnectAdapter;
+exports.SparkNetworkType = SparkNetworkType;
+exports.StacksNetworkType = StacksNetworkType;
+exports.StarknetNetworkType = StarknetNetworkType;
+exports.accountActionsSchema = accountActionsSchema;
+exports.accountChangeEventName = accountChangeEventName;
+exports.accountChangeSchema = accountChangeSchema;
+exports.accountPermissionSchema = accountPermissionSchema;
+exports.addListener = addListener;
+exports.addNetworkMethodName = addNetworkMethodName;
+exports.addNetworkParamsSchema = addNetworkParamsSchema;
+exports.addNetworkRequestMessageSchema = addNetworkRequestMessageSchema;
+exports.addNetworkResultSchema = addNetworkResultSchema;
+exports.addressSchema = addressSchema;
+exports.bitcoinNetworkDefinitionSchema = bitcoinNetworkDefinitionSchema;
+exports.changeNetworkByIdMethodName = changeNetworkByIdMethodName;
+exports.changeNetworkByIdParamsSchema = changeNetworkByIdParamsSchema;
+exports.changeNetworkByIdRequestMessageSchema = changeNetworkByIdRequestMessageSchema;
+exports.changeNetworkByIdResultSchema = changeNetworkByIdResultSchema;
+exports.changeNetworkMethodName = changeNetworkMethodName;
+exports.changeNetworkParamsSchema = changeNetworkParamsSchema;
+exports.changeNetworkRequestMessageSchema = changeNetworkRequestMessageSchema;
+exports.changeNetworkResultSchema = changeNetworkResultSchema;
+exports.connectMethodName = connectMethodName;
+exports.connectParamsSchema = connectParamsSchema;
+exports.connectRequestMessageSchema = connectRequestMessageSchema;
+exports.connectResultSchema = connectResultSchema;
+exports.createInscription = createInscription;
+exports.createRepeatInscriptions = createRepeatInscriptions;
+exports.defaultAdapters = defaultAdapters;
+exports.disconnectEventName = disconnectEventName;
+exports.disconnectMethodName = disconnectMethodName;
+exports.disconnectParamsSchema = disconnectParamsSchema;
+exports.disconnectRequestMessageSchema = disconnectRequestMessageSchema;
+exports.disconnectResultSchema = disconnectResultSchema;
+exports.disconnectSchema = disconnectSchema;
+exports.getAccountMethodName = getAccountMethodName;
+exports.getAccountParamsSchema = getAccountParamsSchema;
+exports.getAccountRequestMessageSchema = getAccountRequestMessageSchema;
+exports.getAccountResultSchema = getAccountResultSchema;
+exports.getAccountsMethodName = getAccountsMethodName;
+exports.getAccountsParamsSchema = getAccountsParamsSchema;
+exports.getAccountsRequestMessageSchema = getAccountsRequestMessageSchema;
+exports.getAccountsResultSchema = getAccountsResultSchema;
+exports.getAddress = getAddress;
+exports.getAddressesMethodName = getAddressesMethodName;
+exports.getAddressesParamsSchema = getAddressesParamsSchema;
+exports.getAddressesRequestMessageSchema = getAddressesRequestMessageSchema;
+exports.getAddressesResultSchema = getAddressesResultSchema;
+exports.getBalanceMethodName = getBalanceMethodName;
+exports.getBalanceParamsSchema = getBalanceParamsSchema;
+exports.getBalanceRequestMessageSchema = getBalanceRequestMessageSchema;
+exports.getBalanceResultSchema = getBalanceResultSchema;
+exports.getCapabilities = getCapabilities;
+exports.getCurrentPermissionsMethodName = getCurrentPermissionsMethodName;
+exports.getCurrentPermissionsParamsSchema = getCurrentPermissionsParamsSchema;
+exports.getCurrentPermissionsRequestMessageSchema = getCurrentPermissionsRequestMessageSchema;
+exports.getCurrentPermissionsResultSchema = getCurrentPermissionsResultSchema;
+exports.getDefaultProvider = getDefaultProvider;
+exports.getInfoMethodName = getInfoMethodName;
+exports.getInfoParamsSchema = getInfoParamsSchema;
+exports.getInfoRequestMessageSchema = getInfoRequestMessageSchema;
+exports.getInfoResultSchema = getInfoResultSchema;
+exports.getInscriptionsMethodName = getInscriptionsMethodName;
+exports.getInscriptionsParamsSchema = getInscriptionsParamsSchema;
+exports.getInscriptionsRequestMessageSchema = getInscriptionsRequestMessageSchema;
+exports.getInscriptionsResultSchema = getInscriptionsResultSchema;
+exports.getNetworkMethodName = getNetworkMethodName;
+exports.getNetworkParamsSchema = getNetworkParamsSchema;
+exports.getNetworkRequestMessageSchema = getNetworkRequestMessageSchema;
+exports.getNetworkResultSchema = getNetworkResultSchema;
+exports.getNetworksMethodName = getNetworksMethodName;
+exports.getNetworksParamsSchema = getNetworksParamsSchema;
+exports.getNetworksRequestMessageSchema = getNetworksRequestMessageSchema;
+exports.getNetworksResultSchema = getNetworksResultSchema;
+exports.getProviderById = getProviderById;
+exports.getProviderOrThrow = getProviderOrThrow;
+exports.getProviders = getProviders;
+exports.getSupportedWallets = getSupportedWallets;
+exports.getWalletTypeMethodName = getWalletTypeMethodName;
+exports.getWalletTypeParamsSchema = getWalletTypeParamsSchema;
+exports.getWalletTypeRequestMessageSchema = getWalletTypeRequestMessageSchema;
+exports.getWalletTypeResultSchema = getWalletTypeResultSchema;
+exports.isProviderInstalled = isProviderInstalled;
+exports.networkChangeEventName = networkChangeEventName;
+exports.networkChangeSchema = networkChangeSchema;
+exports.newNetworkDefinitionSchema = newNetworkDefinitionSchema;
+exports.permission = permission;
+exports.removeDefaultProvider = removeDefaultProvider;
+exports.renouncePermissionsMethodName = renouncePermissionsMethodName;
+exports.renouncePermissionsParamsSchema = renouncePermissionsParamsSchema;
+exports.renouncePermissionsRequestMessageSchema = renouncePermissionsRequestMessageSchema;
+exports.renouncePermissionsResultSchema = renouncePermissionsResultSchema;
+exports.request = request;
+exports.requestPermissionsMethodName = requestPermissionsMethodName;
+exports.requestPermissionsParamsSchema = requestPermissionsParamsSchema;
+exports.requestPermissionsRequestMessageSchema = requestPermissionsRequestMessageSchema;
+exports.requestPermissionsResultSchema = requestPermissionsResultSchema;
+exports.rpcErrorResponseMessageSchema = rpcErrorResponseMessageSchema;
+exports.rpcRequestMessageSchema = rpcRequestMessageSchema;
+exports.rpcResponseMessageSchema = rpcResponseMessageSchema;
+exports.rpcSuccessResponseMessageSchema = rpcSuccessResponseMessageSchema;
+exports.runesEtchMethodName = runesEtchMethodName;
+exports.runesEtchParamsSchema = runesEtchParamsSchema;
+exports.runesEtchRequestMessageSchema = runesEtchRequestMessageSchema;
+exports.runesEtchResultSchema = runesEtchResultSchema;
+exports.runesGetBalanceMethodName = runesGetBalanceMethodName;
+exports.runesGetBalanceParamsSchema = runesGetBalanceParamsSchema;
+exports.runesGetBalanceRequestMessageSchema = runesGetBalanceRequestMessageSchema;
+exports.runesGetBalanceResultSchema = runesGetBalanceResultSchema;
+exports.runesMintMethodName = runesMintMethodName;
+exports.runesMintParamsSchema = runesMintParamsSchema;
+exports.runesMintRequestMessageSchema = runesMintRequestMessageSchema;
+exports.runesMintResultSchema = runesMintResultSchema;
+exports.runesTransferMethodName = runesTransferMethodName;
+exports.runesTransferParamsSchema = runesTransferParamsSchema;
+exports.runesTransferRequestMessageSchema = runesTransferRequestMessageSchema;
+exports.runesTransferResultSchema = runesTransferResultSchema;
+exports.sendBtcTransaction = sendBtcTransaction;
+exports.sendInscriptionsMethodName = sendInscriptionsMethodName;
+exports.sendInscriptionsParamsSchema = sendInscriptionsParamsSchema;
+exports.sendInscriptionsRequestMessageSchema = sendInscriptionsRequestMessageSchema;
+exports.sendInscriptionsResultSchema = sendInscriptionsResultSchema;
+exports.sendTransferMethodName = sendTransferMethodName;
+exports.sendTransferParamsSchema = sendTransferParamsSchema;
+exports.sendTransferRequestMessageSchema = sendTransferRequestMessageSchema;
+exports.sendTransferResultSchema = sendTransferResultSchema;
+exports.setDefaultProvider = setDefaultProvider;
+exports.signMessage = signMessage;
+exports.signMessageMethodName = signMessageMethodName;
+exports.signMessageParamsSchema = signMessageParamsSchema;
+exports.signMessageRequestMessageSchema = signMessageRequestMessageSchema;
+exports.signMessageResultSchema = signMessageResultSchema;
+exports.signMultipleTransactions = signMultipleTransactions;
+exports.signPsbtMethodName = signPsbtMethodName;
+exports.signPsbtParamsSchema = signPsbtParamsSchema;
+exports.signPsbtRequestMessageSchema = signPsbtRequestMessageSchema;
+exports.signPsbtResultSchema = signPsbtResultSchema;
+exports.signTransaction = signTransaction;
+exports.sparkFlashnetAddLiquidityIntentSchema = sparkFlashnetAddLiquidityIntentSchema;
+exports.sparkFlashnetClawbackIntentSchema = sparkFlashnetClawbackIntentSchema;
+exports.sparkFlashnetConfirmInitialDepositIntentSchema = sparkFlashnetConfirmInitialDepositIntentSchema;
+exports.sparkFlashnetCreateConstantProductPoolIntentSchema = sparkFlashnetCreateConstantProductPoolIntentSchema;
+exports.sparkFlashnetCreateSingleSidedPoolIntentSchema = sparkFlashnetCreateSingleSidedPoolIntentSchema;
+exports.sparkFlashnetGetJwtMethodName = sparkFlashnetGetJwtMethodName;
+exports.sparkFlashnetGetJwtParamsSchema = sparkFlashnetGetJwtParamsSchema;
+exports.sparkFlashnetGetJwtRequestMessageSchema = sparkFlashnetGetJwtRequestMessageSchema;
+exports.sparkFlashnetGetJwtResultSchema = sparkFlashnetGetJwtResultSchema;
+exports.sparkFlashnetRemoveLiquidityIntentSchema = sparkFlashnetRemoveLiquidityIntentSchema;
+exports.sparkFlashnetRouteSwapIntentSchema = sparkFlashnetRouteSwapIntentSchema;
+exports.sparkFlashnetSignIntentMethodName = sparkFlashnetSignIntentMethodName;
+exports.sparkFlashnetSignIntentParamsSchema = sparkFlashnetSignIntentParamsSchema;
+exports.sparkFlashnetSignIntentRequestMessageSchema = sparkFlashnetSignIntentRequestMessageSchema;
+exports.sparkFlashnetSignIntentResultSchema = sparkFlashnetSignIntentResultSchema;
+exports.sparkFlashnetSignStructuredMessageMethodName = sparkFlashnetSignStructuredMessageMethodName;
+exports.sparkFlashnetSignStructuredMessageParamsSchema = sparkFlashnetSignStructuredMessageParamsSchema;
+exports.sparkFlashnetSignStructuredMessageRequestMessageSchema = sparkFlashnetSignStructuredMessageRequestMessageSchema;
+exports.sparkFlashnetSignStructuredMessageResultSchema = sparkFlashnetSignStructuredMessageResultSchema;
+exports.sparkFlashnetSwapIntentSchema = sparkFlashnetSwapIntentSchema;
+exports.sparkGetAddressesMethodName = sparkGetAddressesMethodName;
+exports.sparkGetAddressesParamsSchema = sparkGetAddressesParamsSchema;
+exports.sparkGetAddressesRequestMessageSchema = sparkGetAddressesRequestMessageSchema;
+exports.sparkGetAddressesResultSchema = sparkGetAddressesResultSchema;
+exports.sparkGetBalanceMethodName = sparkGetBalanceMethodName;
+exports.sparkGetBalanceParamsSchema = sparkGetBalanceParamsSchema;
+exports.sparkGetBalanceRequestMessageSchema = sparkGetBalanceRequestMessageSchema;
+exports.sparkGetBalanceResultSchema = sparkGetBalanceResultSchema;
+exports.sparkNetworkDefinitionSchema = sparkNetworkDefinitionSchema;
+exports.sparkSignMessageMethodName = sparkSignMessageMethodName;
+exports.sparkSignMessageParamsSchema = sparkSignMessageParamsSchema;
+exports.sparkSignMessageRequestMessageSchema = sparkSignMessageRequestMessageSchema;
+exports.sparkSignMessageResultSchema = sparkSignMessageResultSchema;
+exports.sparkTransferMethodName = sparkTransferMethodName;
+exports.sparkTransferParamsSchema = sparkTransferParamsSchema;
+exports.sparkTransferRequestMessageSchema = sparkTransferRequestMessageSchema;
+exports.sparkTransferResultSchema = sparkTransferResultSchema;
+exports.sparkTransferTokenMethodName = sparkTransferTokenMethodName;
+exports.sparkTransferTokenParamsSchema = sparkTransferTokenParamsSchema;
+exports.sparkTransferTokenRequestMessageSchema = sparkTransferTokenRequestMessageSchema;
+exports.sparkTransferTokenResultSchema = sparkTransferTokenResultSchema;
+exports.stacksNetworkDefinitionSchema = stacksNetworkDefinitionSchema;
+exports.starknetNetworkDefinitionSchema = starknetNetworkDefinitionSchema;
+exports.stxCallContractMethodName = stxCallContractMethodName;
+exports.stxCallContractParamsSchema = stxCallContractParamsSchema;
+exports.stxCallContractRequestMessageSchema = stxCallContractRequestMessageSchema;
+exports.stxCallContractResultSchema = stxCallContractResultSchema;
+exports.stxDeployContractMethodName = stxDeployContractMethodName;
+exports.stxDeployContractParamsSchema = stxDeployContractParamsSchema;
+exports.stxDeployContractRequestMessageSchema = stxDeployContractRequestMessageSchema;
+exports.stxDeployContractResultSchema = stxDeployContractResultSchema;
+exports.stxGetAccountsMethodName = stxGetAccountsMethodName;
+exports.stxGetAccountsParamsSchema = stxGetAccountsParamsSchema;
+exports.stxGetAccountsRequestMessageSchema = stxGetAccountsRequestMessageSchema;
+exports.stxGetAccountsResultSchema = stxGetAccountsResultSchema;
+exports.stxGetAddressesMethodName = stxGetAddressesMethodName;
+exports.stxGetAddressesParamsSchema = stxGetAddressesParamsSchema;
+exports.stxGetAddressesRequestMessageSchema = stxGetAddressesRequestMessageSchema;
+exports.stxGetAddressesResultSchema = stxGetAddressesResultSchema;
+exports.stxSignMessageMethodName = stxSignMessageMethodName;
+exports.stxSignMessageParamsSchema = stxSignMessageParamsSchema;
+exports.stxSignMessageRequestMessageSchema = stxSignMessageRequestMessageSchema;
+exports.stxSignMessageResultSchema = stxSignMessageResultSchema;
+exports.stxSignStructuredMessageMethodName = stxSignStructuredMessageMethodName;
+exports.stxSignStructuredMessageParamsSchema = stxSignStructuredMessageParamsSchema;
+exports.stxSignStructuredMessageRequestMessageSchema = stxSignStructuredMessageRequestMessageSchema;
+exports.stxSignStructuredMessageResultSchema = stxSignStructuredMessageResultSchema;
+exports.stxSignTransactionMethodName = stxSignTransactionMethodName;
+exports.stxSignTransactionParamsSchema = stxSignTransactionParamsSchema;
+exports.stxSignTransactionRequestMessageSchema = stxSignTransactionRequestMessageSchema;
+exports.stxSignTransactionResultSchema = stxSignTransactionResultSchema;
+exports.stxSignTransactionsMethodName = stxSignTransactionsMethodName;
+exports.stxSignTransactionsParamsSchema = stxSignTransactionsParamsSchema;
+exports.stxSignTransactionsRequestMessageSchema = stxSignTransactionsRequestMessageSchema;
+exports.stxSignTransactionsResultSchema = stxSignTransactionsResultSchema;
+exports.stxTransferStxMethodName = stxTransferStxMethodName;
+exports.stxTransferStxParamsSchema = stxTransferStxParamsSchema;
+exports.stxTransferStxRequestMessageSchema = stxTransferStxRequestMessageSchema;
+exports.stxTransferStxResultSchema = stxTransferStxResultSchema;
+exports.walletActionsSchema = walletActionsSchema;
+exports.walletEventSchema = walletEventSchema;
+exports.walletPermissionSchema = walletPermissionSchema;
+exports.walletTypeSchema = walletTypeSchema;
+exports.walletTypes = walletTypes;