@sats-connect/core 0.16.0 → 0.17.0-2dadc04

package/dist/index.cjs

@@ -0,0 +1,3690 @@
+//#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");
+let axios = require("axios");
+axios = __toESM(axios);
+let bitcoin_address_validation = require("bitcoin-address-validation");
+let buffer = require("buffer");
+let ts_pattern = require("ts-pattern");
+
+//#region src/request/rpc/objects/namespaces/wallet/shared/networks.ts
+const networkConfigurationChains = {
+	bitcoin: "bitcoin",
+	spark: "spark",
+	stacks: "stacks",
+	starknet: "starknet"
+};
+const networkConfigurationChainSchema = valibot.enum(networkConfigurationChains);
+const networkConfigurationSources = {
+	builtin: "builtin",
+	custom: "custom"
+};
+const networkConfigurationSourceSchema = valibot.enum(networkConfigurationSources);
+const commonNetworkConfigurationSchema = valibot.object({
+	id: valibot.string(),
+	name: valibot.string(),
+	mode: valibot.picklist([]),
+	source: networkConfigurationSourceSchema,
+	blockExplorerUrl: valibot.optional(valibot.union([valibot.pipe(valibot.literal(""), valibot.transform(() => void 0)), valibot.pipe(valibot.string(), valibot.url())]))
+});
+const bitcoinChainModeSchema = valibot.pipe(valibot.string(), valibot.enum({
+	mainnet: "mainnet",
+	testnet: "testnet",
+	testnet4: "testnet4",
+	signet: "signet",
+	regtest: "regtest"
+}));
+const bitcoinNetworkConfigurationSchema = valibot.object({
+	...commonNetworkConfigurationSchema.entries,
+	chain: valibot.literal(networkConfigurationChains.bitcoin),
+	mode: bitcoinChainModeSchema,
+	xverseApiUrl: valibot.pipe(valibot.string(), valibot.url()),
+	electrsApiUrl: valibot.pipe(valibot.string(), valibot.url())
+});
+const sparkChainMode = {
+	mainnet: "mainnet",
+	regtest: "regtest"
+};
+const sparkChainModeSchema = valibot.pipe(valibot.string(), valibot.enum(sparkChainMode));
+const sparkNetworkConfigurationSchema = valibot.object({
+	...commonNetworkConfigurationSchema.entries,
+	chain: valibot.literal(networkConfigurationChains.spark),
+	mode: sparkChainModeSchema,
+	electrsApiUrl: valibot.pipe(valibot.string(), valibot.url())
+});
+const stacksChainMode = {
+	mainnet: "mainnet",
+	testnet: "testnet",
+	devnet: "devnet",
+	mocknet: "mocknet"
+};
+const stacksChainModeSchema = valibot.pipe(valibot.string(), valibot.enum(stacksChainMode));
+const stacksNetworkConfigurationSchema = valibot.object({
+	...commonNetworkConfigurationSchema.entries,
+	chain: valibot.literal(networkConfigurationChains.stacks),
+	mode: stacksChainModeSchema,
+	stacksApiUrl: valibot.pipe(valibot.string(), valibot.url()),
+	xverseApiUrl: valibot.pipe(valibot.string(), valibot.url())
+});
+const starknetChainMode = {
+	mainnet: "mainnet",
+	sepolia: "sepolia"
+};
+const starknetChainModeSchema = valibot.pipe(valibot.string(), valibot.enum(starknetChainMode));
+const starknetNetworkConfigurationSchema = valibot.object({
+	...commonNetworkConfigurationSchema.entries,
+	chain: valibot.literal(networkConfigurationChains.starknet),
+	mode: starknetChainModeSchema,
+	rpcApiUrl: valibot.pipe(valibot.string(), valibot.url()),
+	xverseApiUrl: valibot.pipe(valibot.string(), valibot.url())
+});
+const networkConfigurationSchema = valibot.variant("chain", [
+	bitcoinNetworkConfigurationSchema,
+	sparkNetworkConfigurationSchema,
+	stacksNetworkConfigurationSchema,
+	starknetNetworkConfigurationSchema
+]);
+const omitFields = ["id", "source"];
+const bitcoinNetworkConfigurationOptionsSchema = valibot.omit(bitcoinNetworkConfigurationSchema, omitFields);
+const sparkNetworkConfigurationOptionsSchema = valibot.omit(sparkNetworkConfigurationSchema, omitFields);
+const stacksNetworkConfigurationOptionsSchema = valibot.omit(stacksNetworkConfigurationSchema, omitFields);
+const starknetNetworkConfigurationOptionsSchema = valibot.omit(starknetNetworkConfigurationSchema, omitFields);
+const networkConfigurationOptionsSchema = valibot.variant("chain", [
+	bitcoinNetworkConfigurationOptionsSchema,
+	sparkNetworkConfigurationOptionsSchema,
+	stacksNetworkConfigurationOptionsSchema,
+	starknetNetworkConfigurationOptionsSchema
+]);
+const allResolvedNetworksSchema = valibot.object({
+	active: valibot.object({
+		bitcoin: bitcoinNetworkConfigurationSchema,
+		spark: sparkNetworkConfigurationSchema,
+		stacks: stacksNetworkConfigurationSchema,
+		starknet: starknetNetworkConfigurationSchema
+	}),
+	all: valibot.array(networkConfigurationSchema)
+});
+
+//#endregion
+//#region src/request/rpc/objects/shared/index.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/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;
+}({});
+/**
+* @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;
+}({});
+
+//#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),
+	bitcoin: valibot.object({ name: valibot.enum(BitcoinNetworkType) }),
+	stacks: valibot.object({ name: valibot.string() }),
+	addresses: valibot.optional(valibot.array(addressSchema))
+});
+const networkChangeEventNameV2 = "networkChangeV2";
+const networkChangeV2Schema = valibot.object({
+	type: valibot.literal(networkChangeEventName),
+	networks: valibot.object({
+		bitcoin: bitcoinNetworkConfigurationSchema,
+		spark: sparkNetworkConfigurationSchema,
+		stacks: stacksNetworkConfigurationSchema,
+		starknet: starknetNetworkConfigurationSchema
+	}),
+	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/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/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/request/rpc/objects/namespaces/bitcoin/shared/index.ts
+let MessageSigningProtocols = /* @__PURE__ */ function(MessageSigningProtocols$1) {
+	MessageSigningProtocols$1["ECDSA"] = "ECDSA";
+	MessageSigningProtocols$1["BIP322"] = "BIP322";
+	return MessageSigningProtocols$1;
+}({});
+let ProviderPlatform = /* @__PURE__ */ function(ProviderPlatform$1) {
+	ProviderPlatform$1["Web"] = "web";
+	ProviderPlatform$1["Mobile"] = "mobile";
+	return ProviderPlatform$1;
+}({});
+
+//#endregion
+//#region src/adapters/unisat.ts
+function convertSignInputsToInputType(signInputs) {
+	const result = [];
+	if (!signInputs) return result;
+	for (const address in signInputs) {
+		const indexes = signInputs[address];
+		for (const 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/request/rpcSpec.ts
+const specIdSchema = valibot.union([
+	valibot.string(),
+	valibot.number(),
+	valibot.null()
+]);
+const specRequestSchema = 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.optional(specIdSchema)
+});
+const specSuccessResponseSchema = valibot.object({
+	jsonrpc: valibot.literal("2.0"),
+	result: valibot.unknown(),
+	id: specIdSchema
+});
+const warningSchema = valibot.variant("code", [valibot.object({
+	code: valibot.literal("DEPRECATION_NOTICE"),
+	message: valibot.string(),
+	sunsetDate: valibot.pipe(valibot.string(), valibot.isoDate())
+})]);
+/**
+* Extends the standard JSON RPC 2.0 with an additional field as a means of
+* providing clients with extra data, such as deprecation warnings, without
+* altering the main payloads.
+*
+* A JSON-RPC response must either be a result (success) or an error (failure).
+* To provide additional data, conventions must be layered atop these two types.
+* Having an additional property is the least disruptive approach, and is
+* acceptable when clients are known to be able to handle such a structure,
+* which they can since they're all part of Sats Connect.
+*/
+const specSuccessWithExtensionsResponseSchema = valibot.object({
+	...specSuccessResponseSchema.entries,
+	extensions: valibot.optional(valibot.object({ warnings: valibot.array(warningSchema) }))
+});
+const specErrorObjectSchema = valibot.object({
+	code: valibot.number(),
+	message: valibot.string(),
+	data: valibot.optional(valibot.unknown())
+});
+const specErrorResponseSchema = valibot.object({
+	jsonrpc: valibot.literal("2.0"),
+	error: specErrorObjectSchema,
+	id: specIdSchema
+});
+const specResponseSchema = valibot.union([specSuccessWithExtensionsResponseSchema, specErrorResponseSchema]);
+
+//#endregion
+//#region src/request/sanitizeRequest.ts
+const sanitizeRequest = (method, params, providerInfo) => {
+	try {
+		const [major, minor] = 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/methods.ts
+const bitcoinMethods = {
+	getAccounts: "getAccounts",
+	getAddresses: "getAddresses",
+	bitcoin_getAddressesV2: "bitcoin_getAddressesV2",
+	getBalance: "getBalance",
+	bitcoin_getBalanceV2: "bitcoin_getBalanceV2",
+	getInfo: "getInfo",
+	sendTransfer: "sendTransfer",
+	bitcoin_sendTransferV2: "bitcoin_sendTransferV2",
+	signMessage: "signMessage",
+	bitcoin_signMessageV2: "bitcoin_signMessageV2",
+	signMultipleMessages: "signMultipleMessages",
+	bitcoin_signMultipleMessagesV2: "bitcoin_signMultipleMessagesV2",
+	signPsbt: "signPsbt",
+	bitcoin_signPsbtV2: "bitcoin_signPsbtV2"
+};
+const stacksMethods = {
+	stx_callContract: "stx_callContract",
+	stx_deployContract: "stx_deployContract",
+	stx_getAccounts: "stx_getAccounts",
+	stx_getAddresses: "stx_getAddresses",
+	stx_signMessage: "stx_signMessage",
+	stx_signStructuredMessage: "stx_signStructuredMessage",
+	stx_signTransaction: "stx_signTransaction",
+	stx_signTransactions: "stx_signTransactions",
+	stx_transferStx: "stx_transferStx"
+};
+const sparkMethods = {
+	spark_getAddresses: "spark_getAddresses",
+	spark_getAddressesV2: "spark_getAddressesV2",
+	spark_getBalance: "spark_getBalance",
+	spark_transfer: "spark_transfer",
+	spark_transferToken: "spark_transferToken",
+	spark_signMessage: "spark_signMessage",
+	spark_flashnet_getJwt: "spark_flashnet_getJwt",
+	spark_flashnet_signIntent: "spark_flashnet_signIntent",
+	spark_flashnet_signStructuredMessage: "spark_flashnet_signStructuredMessage",
+	spark_flashnet_executeSwap: "spark_flashnet_executeSwap",
+	spark_flashnet_executeRouteSwap: "spark_flashnet_executeRouteSwap",
+	spark_flashnet_clawbackFunds: "spark_flashnet_clawbackFunds",
+	spark_flashnet_getClawbackEligibleTransfers: "spark_flashnet_getClawbackEligibleTransfers"
+};
+const runesMethods = {
+	runes_estimateEtch: "runes_estimateEtch",
+	runes_estimateMint: "runes_estimateMint",
+	runes_estimateRbfOrder: "runes_estimateRbfOrder",
+	runes_etch: "runes_etch",
+	runes_getBalance: "runes_getBalance",
+	runes_getOrder: "runes_getOrder",
+	runes_mint: "runes_mint",
+	runes_rbfOrder: "runes_rbfOrder",
+	runes_transfer: "runes_transfer"
+};
+const ordinalsMethods = {
+	ord_getInscriptions: "ord_getInscriptions",
+	ord_sendInscriptions: "ord_sendInscriptions"
+};
+const walletMethods = {
+	wallet_addNetwork: "wallet_addNetwork",
+	wallet_addNetworkV2: "wallet_addNetworkV2",
+	wallet_changeNetwork: "wallet_changeNetwork",
+	wallet_connect: "wallet_connect",
+	wallet_connectV2: "wallet_connectV2",
+	wallet_disconnect: "wallet_disconnect",
+	wallet_getAccount: "wallet_getAccount",
+	wallet_getAccountV2: "wallet_getAccountV2",
+	wallet_getCurrentPermissions: "wallet_getCurrentPermissions",
+	wallet_getNetwork: "wallet_getNetwork",
+	wallet_getNetworks: "wallet_getNetworks",
+	wallet_getWalletType: "wallet_getWalletType",
+	wallet_openBridge: "wallet_openBridge",
+	wallet_openBuy: "wallet_openBuy",
+	wallet_openReceive: "wallet_openReceive",
+	wallet_renouncePermissions: "wallet_renouncePermissions",
+	wallet_requestPermissions: "wallet_requestPermissions",
+	wallet_switchNetwork: "wallet_switchNetwork"
+};
+const methods = {
+	...bitcoinMethods,
+	...stacksMethods,
+	...sparkMethods,
+	...runesMethods,
+	...ordinalsMethods,
+	...walletMethods
+};
+
+//#endregion
+//#region src/request/rpc/compat.ts
+function bitcoinModeToLegacyBitcoinNetworkType(mode) {
+	return (0, ts_pattern.match)(mode).with("mainnet", () => BitcoinNetworkType.Mainnet).with("testnet", () => BitcoinNetworkType.Testnet).with("regtest", () => BitcoinNetworkType.Regtest).with("signet", () => BitcoinNetworkType.Signet).with("testnet4", () => BitcoinNetworkType.Testnet4).exhaustive();
+}
+function stacksModeToLegacyStacksNetworkType(mode) {
+	return (0, ts_pattern.match)(mode).with("mainnet", () => StacksNetworkType.Mainnet).with("testnet", () => StacksNetworkType.Testnet).otherwise(() => StacksNetworkType.Testnet);
+}
+function sparkModeToLegacySparkNetworkType(mode) {
+	return (0, ts_pattern.match)(mode).with("mainnet", () => SparkNetworkType.Mainnet).with("regtest", () => SparkNetworkType.Regtest).exhaustive();
+}
+
+//#endregion
+//#region src/request/rpc/methodSupport.ts
+const { active } = {
+	active: "active",
+	deprecated: "deprecated",
+	removed: "removed"
+};
+const methodSupport = {
+	[bitcoinMethods.getAccounts]: active,
+	[bitcoinMethods.getAddresses]: active,
+	[bitcoinMethods.bitcoin_getAddressesV2]: active,
+	[bitcoinMethods.getBalance]: active,
+	[bitcoinMethods.bitcoin_getBalanceV2]: active,
+	[bitcoinMethods.getInfo]: active,
+	[bitcoinMethods.sendTransfer]: active,
+	[bitcoinMethods.bitcoin_sendTransferV2]: active,
+	[bitcoinMethods.signMessage]: active,
+	[bitcoinMethods.bitcoin_signMessageV2]: active,
+	[bitcoinMethods.signMultipleMessages]: active,
+	[bitcoinMethods.bitcoin_signMultipleMessagesV2]: active,
+	[bitcoinMethods.signPsbt]: active,
+	[bitcoinMethods.bitcoin_signPsbtV2]: active,
+	[stacksMethods.stx_callContract]: active,
+	[stacksMethods.stx_deployContract]: active,
+	[stacksMethods.stx_getAccounts]: active,
+	[stacksMethods.stx_getAddresses]: active,
+	[stacksMethods.stx_signMessage]: active,
+	[stacksMethods.stx_signStructuredMessage]: active,
+	[stacksMethods.stx_signTransaction]: active,
+	[stacksMethods.stx_signTransactions]: active,
+	[stacksMethods.stx_transferStx]: active,
+	[sparkMethods.spark_getAddresses]: active,
+	[sparkMethods.spark_getAddressesV2]: active,
+	[sparkMethods.spark_getBalance]: active,
+	[sparkMethods.spark_transfer]: active,
+	[sparkMethods.spark_transferToken]: active,
+	[sparkMethods.spark_signMessage]: active,
+	[sparkMethods.spark_flashnet_getJwt]: active,
+	[sparkMethods.spark_flashnet_signIntent]: active,
+	[sparkMethods.spark_flashnet_signStructuredMessage]: active,
+	[sparkMethods.spark_flashnet_executeSwap]: active,
+	[sparkMethods.spark_flashnet_executeRouteSwap]: active,
+	[sparkMethods.spark_flashnet_clawbackFunds]: active,
+	[sparkMethods.spark_flashnet_getClawbackEligibleTransfers]: active,
+	[runesMethods.runes_estimateEtch]: active,
+	[runesMethods.runes_estimateMint]: active,
+	[runesMethods.runes_estimateRbfOrder]: active,
+	[runesMethods.runes_etch]: active,
+	[runesMethods.runes_getBalance]: active,
+	[runesMethods.runes_getOrder]: active,
+	[runesMethods.runes_mint]: active,
+	[runesMethods.runes_rbfOrder]: active,
+	[runesMethods.runes_transfer]: active,
+	[ordinalsMethods.ord_getInscriptions]: active,
+	[ordinalsMethods.ord_sendInscriptions]: active,
+	[walletMethods.wallet_addNetwork]: active,
+	[walletMethods.wallet_addNetworkV2]: active,
+	[walletMethods.wallet_changeNetwork]: active,
+	[walletMethods.wallet_connect]: active,
+	[walletMethods.wallet_connectV2]: active,
+	[walletMethods.wallet_disconnect]: active,
+	[walletMethods.wallet_getAccount]: active,
+	[walletMethods.wallet_getAccountV2]: active,
+	[walletMethods.wallet_getCurrentPermissions]: active,
+	[walletMethods.wallet_getNetwork]: active,
+	[walletMethods.wallet_getNetworks]: active,
+	[walletMethods.wallet_getWalletType]: active,
+	[walletMethods.wallet_openBridge]: active,
+	[walletMethods.wallet_openBuy]: active,
+	[walletMethods.wallet_openReceive]: active,
+	[walletMethods.wallet_renouncePermissions]: active,
+	[walletMethods.wallet_requestPermissions]: active,
+	[walletMethods.wallet_switchNetwork]: active
+};
+
+//#endregion
+//#region src/request/shared.ts
+const rpcIdSchema = valibot.string();
+
+//#endregion
+//#region src/request/createRequestSchema.ts
+function createRequestSchema({ paramsSchema, method }) {
+	return valibot.object({
+		...specRequestSchema.entries,
+		id: rpcIdSchema,
+		method: valibot.literal(method),
+		params: paramsSchema
+	});
+}
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/getAccounts/request.ts
+const bitcoinGetAccountsParamsSchema = valibot.object({
+	purposes: valibot.array(valibot.enum(AddressPurpose)),
+	message: valibot.optional(valibot.string())
+});
+const bitcoinGetAccountsRequestSchema = createRequestSchema({
+	paramsSchema: bitcoinGetAccountsParamsSchema,
+	method: bitcoinMethods.getAccounts
+});
+
+//#endregion
+//#region src/request/createSuccessResponseSchema.ts
+function createSuccessResponseSchema({ method, resultSchema }) {
+	return valibot.object({
+		...specSuccessWithExtensionsResponseSchema.entries,
+		id: rpcIdSchema,
+		result: resultSchema,
+		"~sats-connect-method": valibot.literal(method)
+	});
+}
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/getAccounts/response.ts
+const bitcoinGetAccountsResultSchema = valibot.array(valibot.object({
+	...addressSchema.entries,
+	...valibot.object({ walletType: walletTypeSchema }).entries
+}));
+const bitcoinGetAccountsSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: bitcoinGetAccountsResultSchema,
+	method: bitcoinMethods.getAccounts
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/getAddresses/request.ts
+const bitcoinGetAddressesParamsSchema = valibot.object({
+	purposes: valibot.array(valibot.enum(AddressPurpose)),
+	message: valibot.optional(valibot.string())
+});
+const bitcoinGetAddressesRequestSchema = createRequestSchema({
+	paramsSchema: bitcoinGetAddressesParamsSchema,
+	method: bitcoinMethods.getAddresses
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/getAddresses/response.ts
+const getNetworkResultSchema = valibot.object({
+	bitcoin: valibot.object({ name: valibot.string() }),
+	stacks: valibot.object({ name: valibot.string() }),
+	spark: valibot.object({ name: valibot.string() })
+});
+const bitcoinGetAddressesResultSchema = valibot.object({
+	addresses: valibot.array(addressSchema),
+	network: getNetworkResultSchema
+});
+const bitcoinGetAddressesSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: bitcoinGetAddressesResultSchema,
+	method: bitcoinMethods.getAddresses
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/getAddressesV2/request.ts
+const bitcoinGetAddressesV2ParamsSchema = valibot.object({
+	purposes: valibot.array(valibot.enum(AddressPurpose)),
+	message: valibot.optional(valibot.string())
+});
+const bitcoinGetAddressesV2RequestSchema = createRequestSchema({
+	paramsSchema: bitcoinGetAddressesV2ParamsSchema,
+	method: bitcoinMethods.bitcoin_getAddressesV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/addNetwork/request.ts
+const walletAddNetworkParamsSchema = valibot.variant("chain", [
+	valibot.object({
+		chain: valibot.literal("bitcoin"),
+		type: valibot.enum(BitcoinNetworkType),
+		name: valibot.string(),
+		rpcUrl: valibot.string(),
+		rpcFallbackUrl: valibot.optional(valibot.string()),
+		indexerUrl: valibot.optional(valibot.string()),
+		blockExplorerUrl: valibot.optional(valibot.string()),
+		switch: valibot.optional(valibot.boolean())
+	}),
+	valibot.object({
+		chain: valibot.literal("stacks"),
+		name: valibot.string(),
+		type: valibot.enum(StacksNetworkType),
+		rpcUrl: valibot.string(),
+		blockExplorerUrl: valibot.optional(valibot.string()),
+		switch: valibot.optional(valibot.boolean())
+	}),
+	valibot.object({
+		chain: valibot.literal("starknet"),
+		name: valibot.string(),
+		type: valibot.enum(StarknetNetworkType),
+		rpcUrl: valibot.string(),
+		blockExplorerUrl: valibot.optional(valibot.string()),
+		switch: valibot.optional(valibot.boolean())
+	})
+]);
+const walletAddNetworkRequestSchema = createRequestSchema({
+	paramsSchema: walletAddNetworkParamsSchema,
+	method: walletMethods.wallet_addNetwork
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/addNetwork/response.ts
+const walletAddNetworkResultSchema = valibot.object({ id: valibot.string() });
+const walletAddNetworkSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: walletAddNetworkResultSchema,
+	method: walletMethods.wallet_addNetwork
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/shared/permissions.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
+});
+const permissionSchema = valibot.variant("type", [accountPermissionSchema, walletPermissionSchema]);
+const permission = valibot.variant("type", [accountPermissionSchema, walletPermissionSchema]);
+/**
+* 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 permissionRequestParamsSchema = valibot.variant("type", [valibot.object({ ...valibot.omit(accountPermissionSchema, ["clientId"]).entries }), valibot.object({ ...valibot.omit(walletPermissionSchema, ["clientId"]).entries })]);
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/addNetworkV2/request.ts
+const walletAddNetworkV2ParamsSchema = valibot.object({
+	network: networkConfigurationOptionsSchema,
+	switch: valibot.optional(valibot.boolean(), false)
+});
+const walletAddNetworkV2RequestSchema = createRequestSchema({
+	paramsSchema: walletAddNetworkV2ParamsSchema,
+	method: walletMethods.wallet_addNetworkV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/addNetworkV2/response.ts
+const walletAddNetworkV2ResultSchema = networkConfigurationSchema;
+const walletAddNetworkV2SuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: walletAddNetworkV2ResultSchema,
+	method: walletMethods.wallet_addNetworkV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/changeNetwork/request.ts
+const walletChangeNetworkParamsSchema = valibot.object({ name: valibot.enum(BitcoinNetworkType) });
+const walletChangeNetworkRequestSchema = createRequestSchema({
+	paramsSchema: walletChangeNetworkParamsSchema,
+	method: walletMethods.wallet_changeNetwork
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/changeNetwork/response.ts
+const walletChangeNetworkResultSchema = valibot.nullish(valibot.null());
+const walletChangeNetworkSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: walletChangeNetworkResultSchema,
+	method: walletMethods.wallet_changeNetwork
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/connect/request.ts
+const walletConnectParamsSchema = valibot.nullish(valibot.object({
+	permissions: valibot.optional(valibot.array(permissionRequestParamsSchema)),
+	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."))),
+	network: valibot.optional(valibot.picklist([
+		"Mainnet",
+		"Testnet",
+		"Signet"
+	]))
+}));
+const walletConnectRequestSchema = createRequestSchema({
+	paramsSchema: walletConnectParamsSchema,
+	method: walletMethods.wallet_connect
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/getNetwork/request.ts
+const walletGetNetworkParamsSchema = valibot.nullish(valibot.null());
+const walletGetNetworkRequestSchema = createRequestSchema({
+	paramsSchema: walletGetNetworkParamsSchema,
+	method: walletMethods.wallet_getNetwork
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/getNetwork/response.ts
+const walletGetNetworkResultSchema = valibot.object({
+	bitcoin: valibot.object({ name: valibot.enum(BitcoinNetworkType) }),
+	stacks: valibot.object({ name: valibot.enum(StacksNetworkType) }),
+	spark: valibot.object({ name: valibot.enum(SparkNetworkType) })
+});
+const walletGetNetworkSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: walletGetNetworkResultSchema,
+	method: walletMethods.wallet_getNetwork
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/connect/response.ts
+const walletConnectResultSchema = valibot.object({
+	id: valibot.string(),
+	addresses: valibot.array(addressSchema),
+	walletType: walletTypeSchema,
+	network: walletGetNetworkResultSchema
+});
+const walletConnectSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: walletConnectResultSchema,
+	method: walletMethods.wallet_connect
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/connectV2/request.ts
+const walletConnectV2ParamsSchema = valibot.nullish(valibot.object({
+	permissions: permissionRequestParamsSchema,
+	addressPurposes: 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 walletConnectV2RequestSchema = createRequestSchema({
+	paramsSchema: walletConnectV2ParamsSchema,
+	method: walletMethods.wallet_connectV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/getNetworks/request.ts
+const walletGetNetworksParamsSchema = valibot.nullish(valibot.null());
+const walletGetNetworksRequestSchema = createRequestSchema({
+	paramsSchema: walletGetNetworksParamsSchema,
+	method: walletMethods.wallet_getNetworks
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/getNetworks/response.ts
+const walletGetNetworksResultSchema = allResolvedNetworksSchema;
+const walletGetNetworksSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: walletGetNetworksResultSchema,
+	method: walletMethods.wallet_getNetworks
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/connectV2/response.ts
+const walletConnectV2ResultSchema = valibot.object({
+	accountId: valibot.string(),
+	addresses: valibot.array(addressSchema),
+	walletType: walletTypeSchema,
+	networks: walletGetNetworksResultSchema
+});
+const walletConnectV2SuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: walletConnectV2ResultSchema,
+	method: walletMethods.wallet_connectV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/disconnect/request.ts
+const walletDisconnectParamsSchema = valibot.nullish(valibot.null());
+const walletDisconnectRequestSchema = createRequestSchema({
+	paramsSchema: walletDisconnectParamsSchema,
+	method: walletMethods.wallet_disconnect
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/disconnect/response.ts
+const walletDisconnectResultSchema = valibot.nullish(valibot.null());
+const walletDisconnectSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: walletDisconnectResultSchema,
+	method: walletMethods.wallet_disconnect
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/getAccount/request.ts
+const walletGetAccountParamsSchema = valibot.nullish(valibot.null());
+const walletGetAccountRequestSchema = createRequestSchema({
+	paramsSchema: walletGetAccountParamsSchema,
+	method: walletMethods.wallet_getAccount
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/getAccount/response.ts
+const walletGetAccountResultSchema = valibot.object({
+	id: valibot.string(),
+	addresses: valibot.array(addressSchema),
+	walletType: walletTypeSchema,
+	network: walletGetNetworkResultSchema
+});
+const walletGetAccountSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: walletGetAccountResultSchema,
+	method: walletMethods.wallet_getAccount
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/getAccountV2/request.ts
+const walletGetAccountV2ParamsSchema = valibot.nullish(valibot.null());
+const walletGetAccountV2RequestSchema = createRequestSchema({
+	paramsSchema: walletGetAccountV2ParamsSchema,
+	method: walletMethods.wallet_getAccountV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/getAccountV2/response.ts
+const walletGetAccountV2ResultSchema = valibot.object({
+	id: valibot.string(),
+	addresses: valibot.array(addressSchema),
+	walletType: walletTypeSchema,
+	networks: walletGetNetworksResultSchema
+});
+const walletGetAccountV2SuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: walletGetAccountV2ResultSchema,
+	method: walletMethods.wallet_getAccountV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/getCurrentPermissions/request.ts
+const walletGetCurrentPermissionsParamsSchema = valibot.nullish(valibot.null());
+const walletGetCurrentPermissionsRequestSchema = createRequestSchema({
+	paramsSchema: walletGetCurrentPermissionsParamsSchema,
+	method: walletMethods.wallet_getCurrentPermissions
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/getCurrentPermissions/response.ts
+const walletGetCurrentPermissionsResultSchema = permission;
+const walletGetCurrentPermissionsSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: walletGetCurrentPermissionsResultSchema,
+	method: walletMethods.wallet_getCurrentPermissions
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/getWalletType/request.ts
+const walletGetWalletTypeParamsSchema = valibot.nullish(valibot.null());
+const walletGetWalletTypeRequestSchema = createRequestSchema({
+	paramsSchema: walletGetWalletTypeParamsSchema,
+	method: walletMethods.wallet_getWalletType
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/getWalletType/response.ts
+const walletGetWalletTypeResultSchema = walletTypeSchema;
+const walletGetWalletTypeSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: walletGetWalletTypeResultSchema,
+	method: walletMethods.wallet_getWalletType
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/openBridge/request.ts
+const walletOpenBridgeParamsSchema = valibot.object({
+	fromAsset: valibot.string(),
+	toAsset: valibot.string()
+});
+const walletOpenBridgeRequestSchema = createRequestSchema({
+	paramsSchema: walletOpenBridgeParamsSchema,
+	method: walletMethods.wallet_openBridge
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/openBridge/response.ts
+const walletOpenBridgeResultSchema = valibot.nullish(valibot.null());
+const walletOpenBridgeSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: walletOpenBridgeResultSchema,
+	method: walletMethods.wallet_openBridge
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/openBuy/request.ts
+const walletOpenBuyParamsSchema = valibot.object({ asset: valibot.string() });
+const walletOpenBuyRequestSchema = createRequestSchema({
+	paramsSchema: walletOpenBuyParamsSchema,
+	method: walletMethods.wallet_openBuy
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/openBuy/response.ts
+const walletOpenBuyResultSchema = valibot.nullish(valibot.null());
+const walletOpenBuySuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: walletOpenBuyResultSchema,
+	method: walletMethods.wallet_openBuy
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/openReceive/request.ts
+const walletOpenReceiveParamsSchema = valibot.object({ address: valibot.string() });
+const walletOpenReceiveRequestSchema = createRequestSchema({
+	paramsSchema: walletOpenReceiveParamsSchema,
+	method: walletMethods.wallet_openReceive
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/openReceive/response.ts
+const walletOpenReceiveResultSchema = addressSchema;
+const walletOpenReceiveSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: walletOpenReceiveResultSchema,
+	method: walletMethods.wallet_openReceive
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/renouncePermissions/request.ts
+const walletRenouncePermissionsParamsSchema = valibot.nullish(valibot.null());
+const walletRenouncePermissionsRequestSchema = createRequestSchema({
+	paramsSchema: walletRenouncePermissionsParamsSchema,
+	method: walletMethods.wallet_renouncePermissions
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/renouncePermissions/response.ts
+const walletRenouncePermissionsResultSchema = valibot.nullish(valibot.null());
+const walletRenouncePermissionsSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: walletRenouncePermissionsResultSchema,
+	method: walletMethods.wallet_renouncePermissions
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/requestPermissions/request.ts
+const walletRequestPermissionsParamsSchema = valibot.array(permissionRequestParamsSchema);
+const walletRequestPermissionsRequestSchema = createRequestSchema({
+	paramsSchema: walletRequestPermissionsParamsSchema,
+	method: walletMethods.wallet_requestPermissions
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/requestPermissions/response.ts
+const walletRequestPermissionsResultSchema = valibot.literal(true);
+const walletRequestPermissionsSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: walletRequestPermissionsResultSchema,
+	method: walletMethods.wallet_requestPermissions
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/switchNetwork/request.ts
+const walletSwitchNetworkParamsSchema = valibot.variant("selector", [valibot.object({
+	selector: valibot.literal("id"),
+	id: valibot.string()
+})]);
+const walletSwitchNetworkRequestSchema = createRequestSchema({
+	paramsSchema: walletSwitchNetworkParamsSchema,
+	method: walletMethods.wallet_switchNetwork
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/switchNetwork/response.ts
+const walletSwitchNetworkResultSchema = valibot.nullish(valibot.null());
+const walletSwitchNetworkSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: walletSwitchNetworkResultSchema,
+	method: walletMethods.wallet_switchNetwork
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/index.ts
+const walletRequestSchema = valibot.variant("method", [
+	walletAddNetworkRequestSchema,
+	walletAddNetworkV2RequestSchema,
+	walletChangeNetworkRequestSchema,
+	walletConnectRequestSchema,
+	walletConnectV2RequestSchema,
+	walletDisconnectRequestSchema,
+	walletGetAccountRequestSchema,
+	walletGetAccountV2RequestSchema,
+	walletGetCurrentPermissionsRequestSchema,
+	walletGetNetworkRequestSchema,
+	walletGetNetworksRequestSchema,
+	walletGetWalletTypeRequestSchema,
+	walletOpenBridgeRequestSchema,
+	walletOpenBuyRequestSchema,
+	walletOpenReceiveRequestSchema,
+	walletRenouncePermissionsRequestSchema,
+	walletRequestPermissionsRequestSchema,
+	walletSwitchNetworkRequestSchema
+]);
+const walletSuccessResponseSchema = valibot.variant("~sats-connect-method", [
+	walletAddNetworkSuccessResponseSchema,
+	walletAddNetworkV2SuccessResponseSchema,
+	walletChangeNetworkSuccessResponseSchema,
+	walletConnectSuccessResponseSchema,
+	walletConnectV2SuccessResponseSchema,
+	walletDisconnectSuccessResponseSchema,
+	walletGetAccountSuccessResponseSchema,
+	walletGetAccountV2SuccessResponseSchema,
+	walletGetCurrentPermissionsSuccessResponseSchema,
+	walletGetNetworksSuccessResponseSchema,
+	walletGetNetworkSuccessResponseSchema,
+	walletGetWalletTypeSuccessResponseSchema,
+	walletOpenBridgeSuccessResponseSchema,
+	walletOpenBuySuccessResponseSchema,
+	walletOpenReceiveSuccessResponseSchema,
+	walletRenouncePermissionsSuccessResponseSchema,
+	walletRequestPermissionsSuccessResponseSchema,
+	walletSwitchNetworkSuccessResponseSchema
+]);
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/getAddressesV2/response.ts
+const bitcoinGetAddressesV2ResultSchema = valibot.object({
+	addresses: valibot.array(addressSchema),
+	networks: allResolvedNetworksSchema
+});
+const bitcoinGetAddressesV2SuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: bitcoinGetAddressesV2ResultSchema,
+	method: bitcoinMethods.bitcoin_getAddressesV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/getBalance/request.ts
+const bitcoinGetBalanceParamsSchema = valibot.nullish(valibot.null());
+const bitcoinGetBalanceRequestSchema = createRequestSchema({
+	paramsSchema: bitcoinGetBalanceParamsSchema,
+	method: bitcoinMethods.getBalance
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/shared/balanceResultSchema.ts
+const balanceResultSchema = valibot.object({
+	confirmed: valibot.string(),
+	unconfirmed: valibot.string(),
+	total: valibot.string()
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/getBalance/response.ts
+const bitcoinGetBalanceResultSchema = balanceResultSchema;
+const bitcoinGetBalanceSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: bitcoinGetBalanceResultSchema,
+	method: bitcoinMethods.getBalance
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/getBalanceV2/request.ts
+const bitcoinGetBalanceV2ParamsSchema = valibot.nullish(valibot.null());
+const bitcoinGetBalanceV2RequestSchema = createRequestSchema({
+	paramsSchema: bitcoinGetBalanceV2ParamsSchema,
+	method: bitcoinMethods.bitcoin_getBalanceV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/getBalanceV2/response.ts
+const bitcoinGetBalanceV2ResultSchema = balanceResultSchema;
+const bitcoinGetBalanceV2SuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: bitcoinGetBalanceV2ResultSchema,
+	method: bitcoinMethods.bitcoin_getBalanceV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/getInfo/request.ts
+const bitcoinGetInfoParamsSchema = valibot.nullish(valibot.null());
+const bitcoinGetInfoRequestSchema = createRequestSchema({
+	paramsSchema: bitcoinGetInfoParamsSchema,
+	method: bitcoinMethods.getInfo
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/getInfo/response.ts
+const bitcoinGetInfoResultSchema = valibot.object({
+	version: valibot.string(),
+	platform: valibot.optional(valibot.enum(ProviderPlatform)),
+	methods: valibot.optional(valibot.array(valibot.string())),
+	supports: valibot.array(valibot.string())
+});
+const bitcoinGetInfoSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: bitcoinGetInfoResultSchema,
+	method: bitcoinMethods.getInfo
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/shared/sendTransfer.ts
+const sendTransferParamsSchema = valibot.object({ recipients: valibot.array(valibot.object({
+	address: valibot.string(),
+	amount: valibot.number()
+})) });
+const sendTransferResultSchema = valibot.object({ txid: valibot.string() });
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/sendTransfer/request.ts
+const bitcoinSendTransferParamsSchema = sendTransferParamsSchema;
+const bitcoinSendTransferRequestSchema = createRequestSchema({
+	paramsSchema: bitcoinSendTransferParamsSchema,
+	method: bitcoinMethods.sendTransfer
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/sendTransfer/response.ts
+const bitcoinSendTransferResultSchema = sendTransferResultSchema;
+const bitcoinSendTransferSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: bitcoinSendTransferResultSchema,
+	method: bitcoinMethods.sendTransfer
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/sendTransferV2/request.ts
+const bitcoinSendTransferV2ParamsSchema = sendTransferParamsSchema;
+const bitcoinSendTransferV2RequestSchema = createRequestSchema({
+	paramsSchema: bitcoinSendTransferV2ParamsSchema,
+	method: bitcoinMethods.bitcoin_sendTransferV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/sendTransferV2/response.ts
+const bitcoinSendTransferV2ResultSchema = sendTransferResultSchema;
+const bitcoinSendTransferV2SuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: bitcoinSendTransferV2ResultSchema,
+	method: bitcoinMethods.bitcoin_sendTransferV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/shared/signMessage.ts
+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)
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/signMessage/request.ts
+const bitcoinSignMessageParamsSchema = signMessageParamsSchema;
+const bitcoinSignMessageRequestSchema = createRequestSchema({
+	paramsSchema: bitcoinSignMessageParamsSchema,
+	method: bitcoinMethods.signMessage
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/signMessage/response.ts
+const bitcoinSignMessageResultSchema = signMessageResultSchema;
+const bitcoinSignMessageSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: bitcoinSignMessageResultSchema,
+	method: bitcoinMethods.signMessage
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/signMessageV2/request.ts
+const bitcoinSignMessageV2ParamsSchema = signMessageParamsSchema;
+const bitcoinSignMessageV2RequestSchema = createRequestSchema({
+	paramsSchema: bitcoinSignMessageV2ParamsSchema,
+	method: bitcoinMethods.bitcoin_signMessageV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/signMessageV2/response.ts
+const bitcoinSignMessageV2ResultSchema = signMessageResultSchema;
+const bitcoinSignMessageV2SuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: bitcoinSignMessageV2ResultSchema,
+	method: bitcoinMethods.bitcoin_signMessageV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/shared/signMultipleMessages.ts
+const signMultipleMessagesParamsSchema = valibot.array(signMessageParamsSchema);
+const signMultipleMessagesResultSchema = valibot.array(valibot.object({
+	...signMessageResultSchema.entries,
+	message: valibot.string()
+}));
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/signMultipleMessages/request.ts
+const bitcoinSignMultipleMessagesParamsSchema = signMultipleMessagesParamsSchema;
+const bitcoinSignMultipleMessagesRequestSchema = createRequestSchema({
+	paramsSchema: bitcoinSignMultipleMessagesParamsSchema,
+	method: bitcoinMethods.signMultipleMessages
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/signMultipleMessages/response.ts
+const bitcoinSignMultipleMessagesResultSchema = signMultipleMessagesResultSchema;
+const bitcoinSignMultipleMessagesSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: bitcoinSignMultipleMessagesResultSchema,
+	method: bitcoinMethods.signMultipleMessages
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/signMultipleMessagesV2/request.ts
+const bitcoinSignMultipleMessagesV2ParamsSchema = signMultipleMessagesParamsSchema;
+const bitcoinSignMultipleMessagesV2RequestSchema = createRequestSchema({
+	paramsSchema: bitcoinSignMultipleMessagesV2ParamsSchema,
+	method: bitcoinMethods.bitcoin_signMultipleMessagesV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/signMultipleMessagesV2/response.ts
+const bitcoinSignMultipleMessagesV2ResultSchema = signMultipleMessagesResultSchema;
+const bitcoinSignMultipleMessagesV2SuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: bitcoinSignMultipleMessagesV2ResultSchema,
+	method: bitcoinMethods.bitcoin_signMultipleMessagesV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/shared/signPsbt.ts
+const signPsbtParamsSchema = valibot.object({
+	psbt: valibot.string(),
+	signInputs: valibot.optional(valibot.record(valibot.string(), valibot.array(valibot.number()))),
+	broadcast: valibot.optional(valibot.boolean(), false)
+});
+const signPsbtResultSchema = valibot.object({
+	psbt: valibot.string(),
+	txid: valibot.optional(valibot.string())
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/signPsbt/request.ts
+const bitcoinSignPsbtParamsSchema = signPsbtParamsSchema;
+const bitcoinSignPsbtRequestSchema = createRequestSchema({
+	paramsSchema: bitcoinSignPsbtParamsSchema,
+	method: bitcoinMethods.signPsbt
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/signPsbt/response.ts
+const bitcoinSignPsbtResultSchema = signPsbtResultSchema;
+const bitcoinSignPsbtSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: bitcoinSignPsbtResultSchema,
+	method: bitcoinMethods.signPsbt
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/signPsbtV2/request.ts
+const bitcoinSignPsbtV2ParamsSchema = signPsbtParamsSchema;
+const bitcoinSignPsbtV2RequestSchema = createRequestSchema({
+	paramsSchema: bitcoinSignPsbtV2ParamsSchema,
+	method: bitcoinMethods.bitcoin_signPsbtV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/signPsbtV2/response.ts
+const bitcoinSignPsbtV2ResultSchema = signPsbtResultSchema;
+const bitcoinSignPsbtV2SuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: bitcoinSignPsbtV2ResultSchema,
+	method: bitcoinMethods.bitcoin_signPsbtV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/index.ts
+const bitcoinRequestSchema = valibot.variant("method", [
+	bitcoinGetAccountsRequestSchema,
+	bitcoinGetAddressesRequestSchema,
+	bitcoinGetAddressesV2RequestSchema,
+	bitcoinGetBalanceRequestSchema,
+	bitcoinGetBalanceV2RequestSchema,
+	bitcoinGetInfoRequestSchema,
+	bitcoinSendTransferRequestSchema,
+	bitcoinSendTransferV2RequestSchema,
+	bitcoinSignMessageRequestSchema,
+	bitcoinSignMessageV2RequestSchema,
+	bitcoinSignMultipleMessagesRequestSchema,
+	bitcoinSignMultipleMessagesV2RequestSchema,
+	bitcoinSignPsbtRequestSchema,
+	bitcoinSignPsbtV2RequestSchema
+]);
+const bitcoinSuccessResponseSchema = valibot.variant("~sats-connect-method", [
+	bitcoinGetAccountsSuccessResponseSchema,
+	bitcoinGetAddressesSuccessResponseSchema,
+	bitcoinGetAddressesV2SuccessResponseSchema,
+	bitcoinGetBalanceSuccessResponseSchema,
+	bitcoinGetBalanceV2SuccessResponseSchema,
+	bitcoinGetInfoSuccessResponseSchema,
+	bitcoinSendTransferSuccessResponseSchema,
+	bitcoinSendTransferV2SuccessResponseSchema,
+	bitcoinSignMessageSuccessResponseSchema,
+	bitcoinSignMessageV2SuccessResponseSchema,
+	bitcoinSignMultipleMessagesSuccessResponseSchema,
+	bitcoinSignMultipleMessagesV2SuccessResponseSchema,
+	bitcoinSignPsbtSuccessResponseSchema,
+	bitcoinSignPsbtV2SuccessResponseSchema
+]);
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/ordinals/methods/getInscriptions/request.ts
+const ordinalsGetInscriptionsParamsSchema = valibot.object({
+	offset: valibot.number(),
+	limit: valibot.number()
+});
+const ordinalsGetInscriptionsRequestSchema = createRequestSchema({
+	paramsSchema: ordinalsGetInscriptionsParamsSchema,
+	method: ordinalsMethods.ord_getInscriptions
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/ordinals/methods/getInscriptions/response.ts
+const ordinalsGetInscriptionsResultSchema = 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 ordinalsGetInscriptionsSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: ordinalsGetInscriptionsResultSchema,
+	method: ordinalsMethods.ord_getInscriptions
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/ordinals/methods/sendInscriptions/request.ts
+const ordinalsSendInscriptionsParamsSchema = valibot.object({ transfers: valibot.array(valibot.object({
+	address: valibot.string(),
+	inscriptionId: valibot.string()
+})) });
+const ordinalsSendInscriptionsRequestSchema = createRequestSchema({
+	paramsSchema: ordinalsSendInscriptionsParamsSchema,
+	method: ordinalsMethods.ord_sendInscriptions
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/ordinals/methods/sendInscriptions/response.ts
+const ordinalsSendInscriptionsResultSchema = valibot.object({ txid: valibot.string() });
+const ordinalsSendInscriptionsSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: ordinalsSendInscriptionsResultSchema,
+	method: ordinalsMethods.ord_sendInscriptions
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/ordinals/index.ts
+const ordinalsRequestSchema = valibot.variant("method", [ordinalsGetInscriptionsRequestSchema, ordinalsSendInscriptionsRequestSchema]);
+const ordinalsSuccessResponseSchema = valibot.variant("~sats-connect-method", [ordinalsGetInscriptionsSuccessResponseSchema, ordinalsSendInscriptionsSuccessResponseSchema]);
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/runes/methods/estimateEtch/request.ts
+const etchTermsSchema$1 = valibot.object({
+	amount: valibot.optional(valibot.string()),
+	cap: valibot.optional(valibot.string()),
+	heightStart: valibot.optional(valibot.string()),
+	heightEnd: valibot.optional(valibot.string()),
+	offsetStart: valibot.optional(valibot.string()),
+	offsetEnd: valibot.optional(valibot.string())
+});
+const inscriptionDetailsSchema$1 = valibot.object({
+	contentType: valibot.string(),
+	contentBase64: valibot.string()
+});
+const runesEstimateEtchParamsSchema = valibot.object({
+	runeName: valibot.string(),
+	divisibility: valibot.optional(valibot.number()),
+	symbol: valibot.optional(valibot.string()),
+	premine: valibot.optional(valibot.string()),
+	isMintable: valibot.boolean(),
+	terms: valibot.optional(etchTermsSchema$1),
+	inscriptionDetails: valibot.optional(inscriptionDetailsSchema$1),
+	delegateInscriptionId: valibot.optional(valibot.string()),
+	destinationAddress: valibot.string(),
+	feeRate: valibot.number(),
+	appServiceFee: valibot.optional(valibot.number()),
+	appServiceFeeAddress: valibot.optional(valibot.string()),
+	network: valibot.optional(valibot.enum(BitcoinNetworkType))
+});
+const runesEstimateEtchRequestSchema = createRequestSchema({
+	paramsSchema: runesEstimateEtchParamsSchema,
+	method: runesMethods.runes_estimateEtch
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/runes/methods/estimateEtch/response.ts
+const runesEstimateEtchResultSchema = valibot.object({
+	totalSize: valibot.number(),
+	totalCost: valibot.number(),
+	costBreakdown: valibot.object({
+		postage: valibot.number(),
+		networkFee: valibot.number(),
+		serviceFee: valibot.number(),
+		appServiceFee: valibot.number()
+	})
+});
+const runesEstimateEtchSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: runesEstimateEtchResultSchema,
+	method: runesMethods.runes_estimateEtch
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/runes/methods/estimateMint/request.ts
+const runesEstimateMintParamsSchema = valibot.object({
+	runeName: valibot.string(),
+	repeats: valibot.number(),
+	destinationAddress: valibot.string(),
+	feeRate: valibot.number(),
+	appServiceFee: valibot.optional(valibot.number()),
+	appServiceFeeAddress: valibot.optional(valibot.string()),
+	network: valibot.optional(valibot.enum(BitcoinNetworkType))
+});
+const runesEstimateMintRequestSchema = createRequestSchema({
+	paramsSchema: runesEstimateMintParamsSchema,
+	method: runesMethods.runes_estimateMint
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/runes/methods/estimateMint/response.ts
+const runesEstimateMintResultSchema = valibot.object({
+	totalSize: valibot.number(),
+	totalCost: valibot.number(),
+	costBreakdown: valibot.object({
+		postage: valibot.number(),
+		networkFee: valibot.number(),
+		serviceFee: valibot.number(),
+		appServiceFee: valibot.number()
+	})
+});
+const runesEstimateMintSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: runesEstimateMintResultSchema,
+	method: runesMethods.runes_estimateMint
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/runes/methods/estimateRbfOrder/request.ts
+const runesEstimateRbfOrderParamsSchema = valibot.object({
+	orderId: valibot.string(),
+	newFeeRate: valibot.number(),
+	network: valibot.optional(valibot.enum(BitcoinNetworkType))
+});
+const runesEstimateRbfOrderRequestSchema = createRequestSchema({
+	paramsSchema: runesEstimateRbfOrderParamsSchema,
+	method: runesMethods.runes_estimateRbfOrder
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/runes/methods/estimateRbfOrder/response.ts
+const runesEstimateRbfOrderResultSchema = valibot.object({
+	rbfCost: valibot.number(),
+	fundingAddress: valibot.string()
+});
+const runesEstimateRbfOrderSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: runesEstimateRbfOrderResultSchema,
+	method: runesMethods.runes_estimateRbfOrder
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/runes/methods/etch/request.ts
+const etchTermsSchema = valibot.object({
+	amount: valibot.optional(valibot.string()),
+	cap: valibot.optional(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(),
+	terms: valibot.optional(etchTermsSchema),
+	inscriptionDetails: valibot.optional(inscriptionDetailsSchema),
+	delegateInscriptionId: valibot.optional(valibot.string()),
+	destinationAddress: valibot.string(),
+	refundAddress: valibot.string(),
+	feeRate: valibot.number(),
+	appServiceFee: valibot.optional(valibot.number()),
+	appServiceFeeAddress: valibot.optional(valibot.string()),
+	network: valibot.optional(valibot.enum(BitcoinNetworkType))
+});
+const runesEtchRequestSchema = createRequestSchema({
+	paramsSchema: runesEtchParamsSchema,
+	method: runesMethods.runes_etch
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/runes/methods/etch/response.ts
+const runesEtchResultSchema = valibot.object({
+	orderId: valibot.string(),
+	fundTransactionId: valibot.string(),
+	fundingAddress: valibot.string()
+});
+const runesEtchSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: runesEtchResultSchema,
+	method: runesMethods.runes_etch
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/runes/methods/getBalance/request.ts
+const runesGetBalanceParamsSchema = valibot.nullish(valibot.null());
+const runesGetBalanceRequestSchema = createRequestSchema({
+	paramsSchema: runesGetBalanceParamsSchema,
+	method: runesMethods.runes_getBalance
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/runes/methods/getBalance/response.ts
+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 runesGetBalanceSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: runesGetBalanceResultSchema,
+	method: runesMethods.runes_getBalance
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/runes/methods/getOrder/request.ts
+const runesGetOrderParamsSchema = valibot.object({
+	id: valibot.string(),
+	network: valibot.optional(valibot.enum(BitcoinNetworkType))
+});
+const runesGetOrderRequestSchema = createRequestSchema({
+	paramsSchema: runesGetOrderParamsSchema,
+	method: runesMethods.runes_getOrder
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/runes/methods/getOrder/response.ts
+const runesGetOrderResultSchema = valibot.object({
+	id: valibot.string(),
+	orderType: valibot.union([valibot.literal("rune_mint"), valibot.literal("rune_etch")]),
+	state: valibot.union([
+		valibot.literal("new"),
+		valibot.literal("pending"),
+		valibot.literal("executing"),
+		valibot.literal("complete"),
+		valibot.literal("failed"),
+		valibot.literal("refunded"),
+		valibot.literal("stale")
+	]),
+	fundingAddress: valibot.string(),
+	reason: valibot.optional(valibot.string()),
+	createdAt: valibot.string()
+});
+const runesGetOrderSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: runesGetOrderResultSchema,
+	method: runesMethods.runes_getOrder
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/runes/methods/mint/request.ts
+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 runesMintRequestSchema = createRequestSchema({
+	paramsSchema: runesMintParamsSchema,
+	method: runesMethods.runes_mint
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/runes/methods/mint/response.ts
+const runesMintResultSchema = valibot.object({
+	orderId: valibot.string(),
+	fundTransactionId: valibot.string(),
+	fundingAddress: valibot.string()
+});
+const runesMintSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: runesMintResultSchema,
+	method: runesMethods.runes_mint
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/runes/methods/rbfOrder/request.ts
+const runesRbfOrderParamsSchema = valibot.object({
+	orderId: valibot.string(),
+	newFeeRate: valibot.number(),
+	network: valibot.optional(valibot.enum(BitcoinNetworkType))
+});
+const runesRbfOrderRequestSchema = createRequestSchema({
+	paramsSchema: runesRbfOrderParamsSchema,
+	method: runesMethods.runes_rbfOrder
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/runes/methods/rbfOrder/response.ts
+const runesRbfOrderResultSchema = valibot.object({
+	orderId: valibot.string(),
+	fundRBFTransactionId: valibot.string(),
+	fundingAddress: valibot.string()
+});
+const runesRbfOrderSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: runesRbfOrderResultSchema,
+	method: runesMethods.runes_rbfOrder
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/runes/methods/transfer/request.ts
+const runesTransferParamsSchema = valibot.object({
+	recipients: valibot.array(valibot.object({
+		runeName: valibot.string(),
+		amount: valibot.string(),
+		address: valibot.string()
+	})),
+	network: valibot.optional(valibot.enum(BitcoinNetworkType))
+});
+const runesTransferRequestSchema = createRequestSchema({
+	paramsSchema: runesTransferParamsSchema,
+	method: runesMethods.runes_transfer
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/runes/methods/transfer/response.ts
+const runesTransferResultSchema = valibot.object({ txid: valibot.string() });
+const runesTransferSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: runesTransferResultSchema,
+	method: runesMethods.runes_transfer
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/runes/index.ts
+const runesRequestSchema = valibot.variant("method", [
+	runesEstimateEtchRequestSchema,
+	runesEstimateMintRequestSchema,
+	runesEstimateRbfOrderRequestSchema,
+	runesEtchRequestSchema,
+	runesGetBalanceRequestSchema,
+	runesGetOrderRequestSchema,
+	runesMintRequestSchema,
+	runesRbfOrderRequestSchema,
+	runesTransferRequestSchema
+]);
+const runesSuccessResponseSchema = valibot.variant("~sats-connect-method", [
+	runesEstimateEtchSuccessResponseSchema,
+	runesEstimateMintSuccessResponseSchema,
+	runesEstimateRbfOrderSuccessResponseSchema,
+	runesEtchSuccessResponseSchema,
+	runesGetBalanceSuccessResponseSchema,
+	runesGetOrderSuccessResponseSchema,
+	runesMintSuccessResponseSchema,
+	runesRbfOrderSuccessResponseSchema,
+	runesTransferSuccessResponseSchema
+]);
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/spark/methods/flashnetClawbackFunds/request.ts
+const sparkFlashnetClawbackFundsParamsSchema = valibot.object({
+	sparkTransferId: valibot.string(),
+	lpIdentityPublicKey: valibot.string()
+});
+const sparkFlashnetClawbackFundsRequestSchema = createRequestSchema({
+	paramsSchema: sparkFlashnetClawbackFundsParamsSchema,
+	method: sparkMethods.spark_flashnet_clawbackFunds
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/spark/methods/flashnetClawbackFunds/response.ts
+const sparkFlashnetClawbackFundsResultSchema = valibot.object({
+	requestId: valibot.string(),
+	accepted: valibot.boolean(),
+	internalRequestId: valibot.optional(valibot.string()),
+	sparkStatusTrackingId: valibot.optional(valibot.string()),
+	error: valibot.optional(valibot.string())
+});
+const sparkFlashnetClawbackFundsSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: sparkFlashnetClawbackFundsResultSchema,
+	method: sparkMethods.spark_flashnet_clawbackFunds
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/spark/methods/flashnetExecuteRouteSwap/request.ts
+const sparkFlashnetExecuteRouteSwapParamsSchema = valibot.object({
+	hops: valibot.array(valibot.object({
+		poolId: valibot.string(),
+		assetInAddress: valibot.string(),
+		assetOutAddress: valibot.string(),
+		hopIntegratorFeeRateBps: valibot.optional(valibot.number())
+	})),
+	initialAssetAddress: valibot.string(),
+	inputAmount: valibot.string(),
+	maxRouteSlippageBps: valibot.string(),
+	minAmountOut: valibot.optional(valibot.string()),
+	integratorFeeRateBps: valibot.optional(valibot.number()),
+	integratorPublicKey: valibot.optional(valibot.string())
+});
+const sparkFlashnetExecuteRouteSwapRequestSchema = createRequestSchema({
+	paramsSchema: sparkFlashnetExecuteRouteSwapParamsSchema,
+	method: sparkMethods.spark_flashnet_executeRouteSwap
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/spark/methods/flashnetExecuteRouteSwap/response.ts
+const sparkFlashnetExecuteRouteSwapResultSchema = valibot.object({
+	requestId: valibot.string(),
+	accepted: valibot.boolean(),
+	outputAmount: valibot.string(),
+	executionPrice: valibot.string(),
+	finalOutboundTransferId: valibot.string(),
+	error: valibot.optional(valibot.string())
+});
+const sparkFlashnetExecuteRouteSwapSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: sparkFlashnetExecuteRouteSwapResultSchema,
+	method: sparkMethods.spark_flashnet_executeRouteSwap
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/spark/methods/flashnetExecuteSwap/request.ts
+const sparkFlashnetExecuteSwapParamsSchema = valibot.object({
+	poolId: valibot.string(),
+	assetInAddress: valibot.string(),
+	assetOutAddress: valibot.string(),
+	amountIn: valibot.string(),
+	maxSlippageBps: valibot.number(),
+	minAmountOut: valibot.optional(valibot.string()),
+	integratorFeeRateBps: valibot.optional(valibot.number()),
+	integratorPublicKey: valibot.optional(valibot.string())
+});
+const sparkFlashnetExecuteSwapRequestSchema = createRequestSchema({
+	paramsSchema: sparkFlashnetExecuteSwapParamsSchema,
+	method: sparkMethods.spark_flashnet_executeSwap
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/spark/methods/flashnetExecuteSwap/response.ts
+const sparkFlashnetExecuteSwapResultSchema = valibot.object({
+	requestId: valibot.string(),
+	accepted: valibot.boolean(),
+	amountOut: valibot.optional(valibot.string()),
+	feeAmount: valibot.optional(valibot.string()),
+	executionPrice: valibot.optional(valibot.string()),
+	assetOutAddress: valibot.optional(valibot.string()),
+	assetInAddress: valibot.optional(valibot.string()),
+	outboundTransferId: valibot.optional(valibot.string()),
+	error: valibot.optional(valibot.string())
+});
+const sparkFlashnetExecuteSwapSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: sparkFlashnetExecuteSwapResultSchema,
+	method: sparkMethods.spark_flashnet_executeSwap
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/spark/methods/flashnetGetClawbackEligibleTransfers/request.ts
+const sparkGetClawbackEligibleTransfersParamsSchema = valibot.nullish(valibot.null());
+const sparkGetClawbackEligibleTransfersRequestSchema = createRequestSchema({
+	paramsSchema: sparkGetClawbackEligibleTransfersParamsSchema,
+	method: sparkMethods.spark_flashnet_getClawbackEligibleTransfers
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/spark/methods/flashnetGetClawbackEligibleTransfers/response.ts
+const sparkGetClawbackEligibleTransfersResultSchema = valibot.object({ eligibleTransfers: valibot.array(valibot.object({
+	txId: valibot.string(),
+	createdAt: valibot.string(),
+	lpIdentityPublicKey: valibot.string()
+})) });
+const sparkGetClawbackEligibleTransfersSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: sparkGetClawbackEligibleTransfersResultSchema,
+	method: sparkMethods.spark_flashnet_getClawbackEligibleTransfers
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/spark/methods/flashnetGetJwt/request.ts
+const sparkFlashnetGetJwtParamsSchema = valibot.null();
+const sparkFlashnetGetJwtRequestSchema = createRequestSchema({
+	paramsSchema: sparkFlashnetGetJwtParamsSchema,
+	method: sparkMethods.spark_flashnet_getJwt
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/spark/methods/flashnetGetJwt/response.ts
+const sparkFlashnetGetJwtResultSchema = valibot.object({ jwt: valibot.string() });
+const sparkFlashnetGetJwtSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: sparkFlashnetGetJwtResultSchema,
+	method: sparkMethods.spark_flashnet_getJwt
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/spark/methods/flashnetSignIntent/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/rpc/objects/namespaces/spark/methods/flashnetSignIntent/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/rpc/objects/namespaces/spark/methods/flashnetSignIntent/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/rpc/objects/namespaces/spark/methods/flashnetSignIntent/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/rpc/objects/namespaces/spark/methods/flashnetSignIntent/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/rpc/objects/namespaces/spark/methods/flashnetSignIntent/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/rpc/objects/namespaces/spark/methods/flashnetSignIntent/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/rpc/objects/namespaces/spark/methods/flashnetSignIntent/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/rpc/objects/namespaces/spark/methods/flashnetSignIntent/request.ts
+const sparkFlashnetSignIntentParamsSchema = valibot.union([
+	sparkFlashnetSwapIntentSchema,
+	sparkFlashnetRouteSwapIntentSchema,
+	sparkFlashnetAddLiquidityIntentSchema,
+	sparkFlashnetClawbackIntentSchema,
+	sparkFlashnetConfirmInitialDepositIntentSchema,
+	sparkFlashnetCreateConstantProductPoolIntentSchema,
+	sparkFlashnetCreateSingleSidedPoolIntentSchema,
+	sparkFlashnetRemoveLiquidityIntentSchema
+]);
+const sparkFlashnetSignIntentRequestSchema = createRequestSchema({
+	paramsSchema: sparkFlashnetSignIntentParamsSchema,
+	method: sparkMethods.spark_flashnet_signIntent
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/spark/methods/flashnetSignIntent/response.ts
+const sparkFlashnetSignIntentResultSchema = valibot.object({ signature: valibot.string() });
+const sparkFlashnetSignIntentSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: sparkFlashnetSignIntentResultSchema,
+	method: sparkMethods.spark_flashnet_signIntent
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/spark/methods/flashnetSignStructuredMessage/request.ts
+const sparkFlashnetSignStructuredMessageParamsSchema = valibot.object({ message: valibot.string() });
+const sparkFlashnetSignStructuredMessageRequestSchema = createRequestSchema({
+	paramsSchema: sparkFlashnetSignStructuredMessageParamsSchema,
+	method: sparkMethods.spark_flashnet_signStructuredMessage
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/spark/methods/flashnetSignStructuredMessage/response.ts
+const sparkFlashnetSignStructuredMessageResultSchema = valibot.object({
+	message: valibot.string(),
+	signature: valibot.string()
+});
+const sparkFlashnetSignStructuredMessageSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: sparkFlashnetSignStructuredMessageResultSchema,
+	method: sparkMethods.spark_flashnet_signStructuredMessage
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/spark/methods/getAddresses/request.ts
+const sparkGetAddressesParamsSchema = valibot.nullish(valibot.object({ message: valibot.optional(valibot.string()) }));
+const sparkGetAddressesRequestSchema = createRequestSchema({
+	paramsSchema: sparkGetAddressesParamsSchema,
+	method: sparkMethods.spark_getAddresses
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/spark/methods/getAddresses/response.ts
+const sparkGetAddressesResultSchema = valibot.object({
+	addresses: valibot.array(addressSchema),
+	network: walletGetNetworkResultSchema
+});
+const sparkGetAddressesSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: sparkGetAddressesResultSchema,
+	method: sparkMethods.spark_getAddresses
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/spark/methods/getAddressesV2/request.ts
+const sparkGetAddressesV2ParamsSchema = valibot.nullish(valibot.object({ message: valibot.optional(valibot.string()) }));
+const sparkGetAddressesV2RequestSchema = createRequestSchema({
+	paramsSchema: sparkGetAddressesV2ParamsSchema,
+	method: sparkMethods.spark_getAddressesV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/spark/methods/getAddressesV2/response.ts
+const sparkGetAddressesV2ResultSchema = valibot.object({
+	addresses: valibot.array(addressSchema),
+	network: sparkNetworkConfigurationSchema
+});
+const sparkGetAddressesV2SuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: sparkGetAddressesV2ResultSchema,
+	method: sparkMethods.spark_getAddressesV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/spark/methods/getBalance/request.ts
+const sparkGetBalanceParamsSchema = valibot.nullish(valibot.null());
+const sparkGetBalanceRequestSchema = createRequestSchema({
+	paramsSchema: sparkGetBalanceParamsSchema,
+	method: sparkMethods.spark_getBalance
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/spark/methods/getBalance/response.ts
+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 sparkGetBalanceSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: sparkGetBalanceResultSchema,
+	method: sparkMethods.spark_getBalance
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/spark/methods/signMessage/request.ts
+const sparkSignMessageParamsSchema = valibot.object({ message: valibot.string() });
+const sparkSignMessageRequestSchema = createRequestSchema({
+	paramsSchema: sparkSignMessageParamsSchema,
+	method: sparkMethods.spark_signMessage
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/spark/methods/signMessage/response.ts
+const sparkSignMessageResultSchema = valibot.object({ signature: valibot.string() });
+const sparkSignMessageSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: sparkSignMessageResultSchema,
+	method: sparkMethods.spark_signMessage
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/spark/methods/transfer/request.ts
+const sparkTransferParamsSchema = valibot.object({
+	amountSats: valibot.union([valibot.number(), valibot.string()]),
+	receiverSparkAddress: valibot.string()
+});
+const sparkTransferRequestSchema = createRequestSchema({
+	paramsSchema: sparkTransferParamsSchema,
+	method: sparkMethods.spark_transfer
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/spark/methods/transfer/response.ts
+const sparkTransferResultSchema = valibot.object({ id: valibot.string() });
+const sparkTransferSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: sparkTransferResultSchema,
+	method: sparkMethods.spark_transfer
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/spark/methods/transferToken/request.ts
+const sparkTransferTokenParamsSchema = valibot.object({
+	tokenAmount: valibot.union([valibot.number(), valibot.string()]),
+	tokenIdentifier: valibot.string(),
+	receiverSparkAddress: valibot.string()
+});
+const sparkTransferTokenRequestSchema = createRequestSchema({
+	paramsSchema: sparkTransferTokenParamsSchema,
+	method: sparkMethods.spark_transferToken
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/spark/methods/transferToken/response.ts
+const sparkTransferTokenResultSchema = valibot.object({ id: valibot.string() });
+const sparkTransferTokenSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: sparkTransferTokenResultSchema,
+	method: sparkMethods.spark_transferToken
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/spark/index.ts
+const sparkRequestSchema = valibot.variant("method", [
+	sparkGetAddressesRequestSchema,
+	sparkGetAddressesV2RequestSchema,
+	sparkGetBalanceRequestSchema,
+	sparkTransferRequestSchema,
+	sparkTransferTokenRequestSchema,
+	sparkSignMessageRequestSchema,
+	sparkFlashnetGetJwtRequestSchema,
+	sparkFlashnetSignIntentRequestSchema,
+	sparkFlashnetSignStructuredMessageRequestSchema,
+	sparkFlashnetExecuteSwapRequestSchema,
+	sparkFlashnetExecuteRouteSwapRequestSchema,
+	sparkFlashnetClawbackFundsRequestSchema,
+	sparkGetClawbackEligibleTransfersRequestSchema
+]);
+const sparkSuccessResponseSchema = valibot.variant("~sats-connect-method", [
+	sparkGetAddressesSuccessResponseSchema,
+	sparkGetAddressesV2SuccessResponseSchema,
+	sparkGetBalanceSuccessResponseSchema,
+	sparkTransferSuccessResponseSchema,
+	sparkTransferTokenSuccessResponseSchema,
+	sparkSignMessageSuccessResponseSchema,
+	sparkFlashnetGetJwtSuccessResponseSchema,
+	sparkFlashnetSignIntentSuccessResponseSchema,
+	sparkFlashnetSignStructuredMessageSuccessResponseSchema,
+	sparkFlashnetExecuteSwapSuccessResponseSchema,
+	sparkFlashnetExecuteRouteSwapSuccessResponseSchema,
+	sparkFlashnetClawbackFundsSuccessResponseSchema,
+	sparkGetClawbackEligibleTransfersSuccessResponseSchema
+]);
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/stacks/methods/callContract/request.ts
+const stacksCallContractParamsSchema = 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 stacksCallContractRequestSchema = createRequestSchema({
+	paramsSchema: stacksCallContractParamsSchema,
+	method: stacksMethods.stx_callContract
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/stacks/methods/callContract/response.ts
+const stacksCallContractResultSchema = valibot.object({
+	txid: valibot.string(),
+	transaction: valibot.string()
+});
+const stacksCallContractSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: stacksCallContractResultSchema,
+	method: stacksMethods.stx_callContract
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/stacks/methods/deployContract/request.ts
+const stacksDeployContractParamsSchema = 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 stacksDeployContractRequestSchema = createRequestSchema({
+	paramsSchema: stacksDeployContractParamsSchema,
+	method: stacksMethods.stx_deployContract
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/stacks/methods/deployContract/response.ts
+const stacksDeployContractResultSchema = valibot.object({
+	txid: valibot.string(),
+	transaction: valibot.string()
+});
+const stacksDeployContractSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: stacksDeployContractResultSchema,
+	method: stacksMethods.stx_deployContract
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/stacks/methods/getAccounts/request.ts
+const stacksGetAccountsParamsSchema = valibot.nullish(valibot.null());
+const stacksGetAccountsRequestSchema = createRequestSchema({
+	paramsSchema: stacksGetAccountsParamsSchema,
+	method: stacksMethods.stx_getAccounts
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/stacks/methods/getAccounts/response.ts
+const stacksGetAccountsResultSchema = valibot.object({
+	addresses: valibot.array(valibot.object({
+		address: valibot.string(),
+		publicKey: valibot.string(),
+		gaiaHubUrl: valibot.string(),
+		gaiaAppKey: valibot.string()
+	})),
+	network: walletGetNetworkResultSchema
+});
+const stacksGetAccountsSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: stacksGetAccountsResultSchema,
+	method: stacksMethods.stx_getAccounts
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/stacks/methods/getAddresses/request.ts
+const stacksGetAddressesParamsSchema = valibot.nullish(valibot.object({ message: valibot.optional(valibot.string()) }));
+const stacksGetAddressesRequestSchema = createRequestSchema({
+	paramsSchema: stacksGetAddressesParamsSchema,
+	method: stacksMethods.stx_getAddresses
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/stacks/methods/getAddresses/response.ts
+const stacksGetAddressesResultSchema = valibot.object({
+	addresses: valibot.array(addressSchema),
+	network: walletGetNetworkResultSchema
+});
+const stacksGetAddressesSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: stacksGetAddressesResultSchema,
+	method: stacksMethods.stx_getAddresses
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/stacks/methods/signMessage/request.ts
+const stacksSignMessageParamsSchema = valibot.object({ message: valibot.string() });
+const stacksSignMessageRequestSchema = createRequestSchema({
+	paramsSchema: stacksSignMessageParamsSchema,
+	method: stacksMethods.stx_signMessage
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/stacks/methods/signMessage/response.ts
+const stacksSignMessageResultSchema = valibot.object({
+	signature: valibot.string(),
+	publicKey: valibot.string()
+});
+const stacksSignMessageSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: stacksSignMessageResultSchema,
+	method: stacksMethods.stx_signMessage
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/stacks/methods/signStructuredMessage/request.ts
+const stacksSignStructuredMessageParamsSchema = valibot.object({
+	domain: valibot.string(),
+	message: valibot.string(),
+	publicKey: valibot.optional(valibot.string())
+});
+const stacksSignStructuredMessageRequestSchema = createRequestSchema({
+	paramsSchema: stacksSignStructuredMessageParamsSchema,
+	method: stacksMethods.stx_signStructuredMessage
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/stacks/methods/signStructuredMessage/response.ts
+const stacksSignStructuredMessageResultSchema = valibot.object({
+	signature: valibot.string(),
+	publicKey: valibot.string()
+});
+const stacksSignStructuredMessageSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: stacksSignStructuredMessageResultSchema,
+	method: stacksMethods.stx_signStructuredMessage
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/stacks/methods/signTransaction/request.ts
+const stacksSignTransactionParamsSchema = valibot.object({
+	transaction: valibot.string(),
+	pubkey: valibot.optional(valibot.string()),
+	broadcast: valibot.optional(valibot.boolean())
+});
+const stacksSignTransactionRequestSchema = createRequestSchema({
+	paramsSchema: stacksSignTransactionParamsSchema,
+	method: stacksMethods.stx_signTransaction
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/stacks/methods/signTransaction/response.ts
+const stacksSignTransactionResultSchema = valibot.object({ transaction: valibot.string() });
+const stacksSignTransactionSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: stacksSignTransactionResultSchema,
+	method: stacksMethods.stx_signTransaction
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/stacks/methods/signTransactions/request.ts
+const stacksSignTransactionsParamsSchema = valibot.object({
+	transactions: valibot.pipe(valibot.array(valibot.pipe(valibot.string(), valibot.check(() => {
+		return true;
+	}, "Invalid hex-encoded Stacks transaction."))), valibot.minLength(1)),
+	broadcast: valibot.optional(valibot.boolean(), true)
+});
+const stacksSignTransactionsRequestSchema = createRequestSchema({
+	paramsSchema: stacksSignTransactionsParamsSchema,
+	method: stacksMethods.stx_signTransactions
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/stacks/methods/signTransactions/response.ts
+const stacksSignTransactionsResultSchema = valibot.object({ transactions: valibot.array(valibot.string()) });
+const stacksSignTransactionsSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: stacksSignTransactionsResultSchema,
+	method: stacksMethods.stx_signTransactions
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/stacks/methods/transferStx/request.ts
+const stacksTransferStxParamsSchema = 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 stacksTransferStxRequestSchema = createRequestSchema({
+	paramsSchema: stacksTransferStxParamsSchema,
+	method: stacksMethods.stx_transferStx
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/stacks/methods/transferStx/response.ts
+const stacksTransferStxResultSchema = valibot.object({
+	txid: valibot.string(),
+	transaction: valibot.string()
+});
+const stacksTransferStxSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: stacksTransferStxResultSchema,
+	method: stacksMethods.stx_transferStx
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/stacks/index.ts
+const stacksRequestSchema = valibot.variant("method", [
+	stacksCallContractRequestSchema,
+	stacksDeployContractRequestSchema,
+	stacksGetAccountsRequestSchema,
+	stacksGetAddressesRequestSchema,
+	stacksSignMessageRequestSchema,
+	stacksSignStructuredMessageRequestSchema,
+	stacksSignTransactionRequestSchema,
+	stacksSignTransactionsRequestSchema,
+	stacksTransferStxRequestSchema
+]);
+const stacksSuccessResponseSchema = valibot.variant("~sats-connect-method", [
+	stacksCallContractSuccessResponseSchema,
+	stacksDeployContractSuccessResponseSchema,
+	stacksGetAccountsSuccessResponseSchema,
+	stacksGetAddressesSuccessResponseSchema,
+	stacksSignMessageSuccessResponseSchema,
+	stacksSignStructuredMessageSuccessResponseSchema,
+	stacksSignTransactionSuccessResponseSchema,
+	stacksSignTransactionsSuccessResponseSchema,
+	stacksTransferStxSuccessResponseSchema
+]);
+
+//#endregion
+//#region src/request/rpc/requests.ts
+const rpcRequestSchema = valibot.variant("method", [
+	bitcoinRequestSchema,
+	stacksRequestSchema,
+	sparkRequestSchema,
+	runesRequestSchema,
+	ordinalsRequestSchema,
+	walletRequestSchema
+]);
+function createRpcRequest({ method, params, id }) {
+	return {
+		jsonrpc: "2.0",
+		method,
+		params,
+		id
+	};
+}
+
+//#endregion
+//#region src/request/rpc/responses.ts
+const rpcSuccessResponseSchema = valibot.variant("~sats-connect-method", [
+	bitcoinSuccessResponseSchema,
+	stacksSuccessResponseSchema,
+	sparkSuccessResponseSchema,
+	runesSuccessResponseSchema,
+	ordinalsSuccessResponseSchema,
+	walletSuccessResponseSchema
+]);
+function createRpcSuccessResponse({ method, result, id }) {
+	return {
+		jsonrpc: "2.0",
+		id,
+		result,
+		"~sats-connect-method": method
+	};
+}
+
+//#endregion
+//#region src/request/index.ts
+const cache = {};
+const requestInternal = async (provider, method, params) => {
+	const response = await provider.request(method, params);
+	if (valibot.is(specErrorResponseSchema, response)) return {
+		status: "error",
+		error: response.error
+	};
+	if (valibot.is(specSuccessWithExtensionsResponseSchema, 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/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/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,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"
+	},
+	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/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
+//#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
+exports.AddressPurpose = AddressPurpose;
+exports.AddressType = AddressType;
+exports.BaseAdapter = BaseAdapter;
+exports.BitcoinNetworkType = BitcoinNetworkType;
+exports.DefaultAdaptersInfo = DefaultAdaptersInfo;
+exports.MessageSigningProtocols = MessageSigningProtocols;
+exports.ProviderPlatform = ProviderPlatform;
+exports.RpcErrorCode = RpcErrorCode;
+exports.SatsConnectAdapter = SatsConnectAdapter;
+exports.SparkNetworkType = SparkNetworkType;
+exports.StacksNetworkType = StacksNetworkType;
+exports.StarknetNetworkType = StarknetNetworkType;
+exports.accountChangeEventName = accountChangeEventName;
+exports.accountChangeSchema = accountChangeSchema;
+exports.addListener = addListener;
+exports.addressSchema = addressSchema;
+exports.allResolvedNetworksSchema = allResolvedNetworksSchema;
+exports.bitcoinGetAccountsParamsSchema = bitcoinGetAccountsParamsSchema;
+exports.bitcoinGetAccountsRequestSchema = bitcoinGetAccountsRequestSchema;
+exports.bitcoinGetAccountsResultSchema = bitcoinGetAccountsResultSchema;
+exports.bitcoinGetAccountsSuccessResponseSchema = bitcoinGetAccountsSuccessResponseSchema;
+exports.bitcoinGetAddressesParamsSchema = bitcoinGetAddressesParamsSchema;
+exports.bitcoinGetAddressesRequestSchema = bitcoinGetAddressesRequestSchema;
+exports.bitcoinGetAddressesResultSchema = bitcoinGetAddressesResultSchema;
+exports.bitcoinGetAddressesSuccessResponseSchema = bitcoinGetAddressesSuccessResponseSchema;
+exports.bitcoinGetAddressesV2ParamsSchema = bitcoinGetAddressesV2ParamsSchema;
+exports.bitcoinGetAddressesV2RequestSchema = bitcoinGetAddressesV2RequestSchema;
+exports.bitcoinGetAddressesV2ResultSchema = bitcoinGetAddressesV2ResultSchema;
+exports.bitcoinGetAddressesV2SuccessResponseSchema = bitcoinGetAddressesV2SuccessResponseSchema;
+exports.bitcoinGetBalanceParamsSchema = bitcoinGetBalanceParamsSchema;
+exports.bitcoinGetBalanceRequestSchema = bitcoinGetBalanceRequestSchema;
+exports.bitcoinGetBalanceResultSchema = bitcoinGetBalanceResultSchema;
+exports.bitcoinGetBalanceSuccessResponseSchema = bitcoinGetBalanceSuccessResponseSchema;
+exports.bitcoinGetBalanceV2ParamsSchema = bitcoinGetBalanceV2ParamsSchema;
+exports.bitcoinGetBalanceV2RequestSchema = bitcoinGetBalanceV2RequestSchema;
+exports.bitcoinGetBalanceV2ResultSchema = bitcoinGetBalanceV2ResultSchema;
+exports.bitcoinGetBalanceV2SuccessResponseSchema = bitcoinGetBalanceV2SuccessResponseSchema;
+exports.bitcoinGetInfoParamsSchema = bitcoinGetInfoParamsSchema;
+exports.bitcoinGetInfoRequestSchema = bitcoinGetInfoRequestSchema;
+exports.bitcoinGetInfoResultSchema = bitcoinGetInfoResultSchema;
+exports.bitcoinGetInfoSuccessResponseSchema = bitcoinGetInfoSuccessResponseSchema;
+exports.bitcoinMethods = bitcoinMethods;
+exports.bitcoinModeToLegacyBitcoinNetworkType = bitcoinModeToLegacyBitcoinNetworkType;
+exports.bitcoinNetworkConfigurationOptionsSchema = bitcoinNetworkConfigurationOptionsSchema;
+exports.bitcoinRequestSchema = bitcoinRequestSchema;
+exports.bitcoinSendTransferParamsSchema = bitcoinSendTransferParamsSchema;
+exports.bitcoinSendTransferRequestSchema = bitcoinSendTransferRequestSchema;
+exports.bitcoinSendTransferResultSchema = bitcoinSendTransferResultSchema;
+exports.bitcoinSendTransferSuccessResponseSchema = bitcoinSendTransferSuccessResponseSchema;
+exports.bitcoinSendTransferV2ParamsSchema = bitcoinSendTransferV2ParamsSchema;
+exports.bitcoinSendTransferV2RequestSchema = bitcoinSendTransferV2RequestSchema;
+exports.bitcoinSendTransferV2ResultSchema = bitcoinSendTransferV2ResultSchema;
+exports.bitcoinSendTransferV2SuccessResponseSchema = bitcoinSendTransferV2SuccessResponseSchema;
+exports.bitcoinSignMessageParamsSchema = bitcoinSignMessageParamsSchema;
+exports.bitcoinSignMessageRequestSchema = bitcoinSignMessageRequestSchema;
+exports.bitcoinSignMessageResultSchema = bitcoinSignMessageResultSchema;
+exports.bitcoinSignMessageSuccessResponseSchema = bitcoinSignMessageSuccessResponseSchema;
+exports.bitcoinSignMessageV2ParamsSchema = bitcoinSignMessageV2ParamsSchema;
+exports.bitcoinSignMessageV2RequestSchema = bitcoinSignMessageV2RequestSchema;
+exports.bitcoinSignMessageV2ResultSchema = bitcoinSignMessageV2ResultSchema;
+exports.bitcoinSignMessageV2SuccessResponseSchema = bitcoinSignMessageV2SuccessResponseSchema;
+exports.bitcoinSignMultipleMessagesParamsSchema = bitcoinSignMultipleMessagesParamsSchema;
+exports.bitcoinSignMultipleMessagesRequestSchema = bitcoinSignMultipleMessagesRequestSchema;
+exports.bitcoinSignMultipleMessagesResultSchema = bitcoinSignMultipleMessagesResultSchema;
+exports.bitcoinSignMultipleMessagesSuccessResponseSchema = bitcoinSignMultipleMessagesSuccessResponseSchema;
+exports.bitcoinSignMultipleMessagesV2ParamsSchema = bitcoinSignMultipleMessagesV2ParamsSchema;
+exports.bitcoinSignMultipleMessagesV2RequestSchema = bitcoinSignMultipleMessagesV2RequestSchema;
+exports.bitcoinSignMultipleMessagesV2ResultSchema = bitcoinSignMultipleMessagesV2ResultSchema;
+exports.bitcoinSignMultipleMessagesV2SuccessResponseSchema = bitcoinSignMultipleMessagesV2SuccessResponseSchema;
+exports.bitcoinSignPsbtParamsSchema = bitcoinSignPsbtParamsSchema;
+exports.bitcoinSignPsbtRequestSchema = bitcoinSignPsbtRequestSchema;
+exports.bitcoinSignPsbtResultSchema = bitcoinSignPsbtResultSchema;
+exports.bitcoinSignPsbtSuccessResponseSchema = bitcoinSignPsbtSuccessResponseSchema;
+exports.bitcoinSignPsbtV2ParamsSchema = bitcoinSignPsbtV2ParamsSchema;
+exports.bitcoinSignPsbtV2RequestSchema = bitcoinSignPsbtV2RequestSchema;
+exports.bitcoinSignPsbtV2ResultSchema = bitcoinSignPsbtV2ResultSchema;
+exports.bitcoinSignPsbtV2SuccessResponseSchema = bitcoinSignPsbtV2SuccessResponseSchema;
+exports.bitcoinSuccessResponseSchema = bitcoinSuccessResponseSchema;
+exports.createInscription = createInscription;
+exports.createRepeatInscriptions = createRepeatInscriptions;
+exports.createRpcRequest = createRpcRequest;
+exports.createRpcSuccessResponse = createRpcSuccessResponse;
+exports.defaultAdapters = defaultAdapters;
+exports.disconnectEventName = disconnectEventName;
+exports.disconnectSchema = disconnectSchema;
+exports.getAddress = getAddress;
+exports.getCapabilities = getCapabilities;
+exports.getDefaultProvider = getDefaultProvider;
+exports.getProviderById = getProviderById;
+exports.getProviderOrThrow = getProviderOrThrow;
+exports.getProviders = getProviders;
+exports.getSupportedWallets = getSupportedWallets;
+exports.isProviderInstalled = isProviderInstalled;
+exports.methodSupport = methodSupport;
+exports.methods = methods;
+exports.networkChangeEventName = networkChangeEventName;
+exports.networkChangeEventNameV2 = networkChangeEventNameV2;
+exports.networkChangeSchema = networkChangeSchema;
+exports.networkChangeV2Schema = networkChangeV2Schema;
+exports.networkConfigurationOptionsSchema = networkConfigurationOptionsSchema;
+exports.ordinalsGetInscriptionsParamsSchema = ordinalsGetInscriptionsParamsSchema;
+exports.ordinalsGetInscriptionsRequestSchema = ordinalsGetInscriptionsRequestSchema;
+exports.ordinalsGetInscriptionsResultSchema = ordinalsGetInscriptionsResultSchema;
+exports.ordinalsGetInscriptionsSuccessResponseSchema = ordinalsGetInscriptionsSuccessResponseSchema;
+exports.ordinalsMethods = ordinalsMethods;
+exports.ordinalsRequestSchema = ordinalsRequestSchema;
+exports.ordinalsSendInscriptionsParamsSchema = ordinalsSendInscriptionsParamsSchema;
+exports.ordinalsSendInscriptionsRequestSchema = ordinalsSendInscriptionsRequestSchema;
+exports.ordinalsSendInscriptionsResultSchema = ordinalsSendInscriptionsResultSchema;
+exports.ordinalsSendInscriptionsSuccessResponseSchema = ordinalsSendInscriptionsSuccessResponseSchema;
+exports.ordinalsSuccessResponseSchema = ordinalsSuccessResponseSchema;
+exports.permissionRequestParamsSchema = permissionRequestParamsSchema;
+exports.removeDefaultProvider = removeDefaultProvider;
+exports.request = request;
+exports.rpcIdSchema = rpcIdSchema;
+exports.rpcRequestSchema = rpcRequestSchema;
+exports.rpcSuccessResponseSchema = rpcSuccessResponseSchema;
+exports.runesEstimateEtchParamsSchema = runesEstimateEtchParamsSchema;
+exports.runesEstimateEtchRequestSchema = runesEstimateEtchRequestSchema;
+exports.runesEstimateEtchResultSchema = runesEstimateEtchResultSchema;
+exports.runesEstimateEtchSuccessResponseSchema = runesEstimateEtchSuccessResponseSchema;
+exports.runesEstimateMintParamsSchema = runesEstimateMintParamsSchema;
+exports.runesEstimateMintRequestSchema = runesEstimateMintRequestSchema;
+exports.runesEstimateMintResultSchema = runesEstimateMintResultSchema;
+exports.runesEstimateMintSuccessResponseSchema = runesEstimateMintSuccessResponseSchema;
+exports.runesEstimateRbfOrderParamsSchema = runesEstimateRbfOrderParamsSchema;
+exports.runesEstimateRbfOrderRequestSchema = runesEstimateRbfOrderRequestSchema;
+exports.runesEstimateRbfOrderResultSchema = runesEstimateRbfOrderResultSchema;
+exports.runesEstimateRbfOrderSuccessResponseSchema = runesEstimateRbfOrderSuccessResponseSchema;
+exports.runesEtchParamsSchema = runesEtchParamsSchema;
+exports.runesEtchRequestSchema = runesEtchRequestSchema;
+exports.runesEtchResultSchema = runesEtchResultSchema;
+exports.runesEtchSuccessResponseSchema = runesEtchSuccessResponseSchema;
+exports.runesGetBalanceParamsSchema = runesGetBalanceParamsSchema;
+exports.runesGetBalanceRequestSchema = runesGetBalanceRequestSchema;
+exports.runesGetBalanceResultSchema = runesGetBalanceResultSchema;
+exports.runesGetBalanceSuccessResponseSchema = runesGetBalanceSuccessResponseSchema;
+exports.runesGetOrderParamsSchema = runesGetOrderParamsSchema;
+exports.runesGetOrderRequestSchema = runesGetOrderRequestSchema;
+exports.runesGetOrderResultSchema = runesGetOrderResultSchema;
+exports.runesGetOrderSuccessResponseSchema = runesGetOrderSuccessResponseSchema;
+exports.runesMethods = runesMethods;
+exports.runesMintParamsSchema = runesMintParamsSchema;
+exports.runesMintRequestSchema = runesMintRequestSchema;
+exports.runesMintResultSchema = runesMintResultSchema;
+exports.runesMintSuccessResponseSchema = runesMintSuccessResponseSchema;
+exports.runesRbfOrderParamsSchema = runesRbfOrderParamsSchema;
+exports.runesRbfOrderRequestSchema = runesRbfOrderRequestSchema;
+exports.runesRbfOrderResultSchema = runesRbfOrderResultSchema;
+exports.runesRbfOrderSuccessResponseSchema = runesRbfOrderSuccessResponseSchema;
+exports.runesRequestSchema = runesRequestSchema;
+exports.runesSuccessResponseSchema = runesSuccessResponseSchema;
+exports.runesTransferParamsSchema = runesTransferParamsSchema;
+exports.runesTransferRequestSchema = runesTransferRequestSchema;
+exports.runesTransferResultSchema = runesTransferResultSchema;
+exports.runesTransferSuccessResponseSchema = runesTransferSuccessResponseSchema;
+exports.sendBtcTransaction = sendBtcTransaction;
+exports.setDefaultProvider = setDefaultProvider;
+exports.signMessage = signMessage;
+exports.signMultipleTransactions = signMultipleTransactions;
+exports.signTransaction = signTransaction;
+exports.sparkFlashnetClawbackFundsParamsSchema = sparkFlashnetClawbackFundsParamsSchema;
+exports.sparkFlashnetClawbackFundsRequestSchema = sparkFlashnetClawbackFundsRequestSchema;
+exports.sparkFlashnetClawbackFundsResultSchema = sparkFlashnetClawbackFundsResultSchema;
+exports.sparkFlashnetClawbackFundsSuccessResponseSchema = sparkFlashnetClawbackFundsSuccessResponseSchema;
+exports.sparkFlashnetExecuteRouteSwapParamsSchema = sparkFlashnetExecuteRouteSwapParamsSchema;
+exports.sparkFlashnetExecuteRouteSwapRequestSchema = sparkFlashnetExecuteRouteSwapRequestSchema;
+exports.sparkFlashnetExecuteRouteSwapResultSchema = sparkFlashnetExecuteRouteSwapResultSchema;
+exports.sparkFlashnetExecuteRouteSwapSuccessResponseSchema = sparkFlashnetExecuteRouteSwapSuccessResponseSchema;
+exports.sparkFlashnetExecuteSwapParamsSchema = sparkFlashnetExecuteSwapParamsSchema;
+exports.sparkFlashnetExecuteSwapRequestSchema = sparkFlashnetExecuteSwapRequestSchema;
+exports.sparkFlashnetExecuteSwapResultSchema = sparkFlashnetExecuteSwapResultSchema;
+exports.sparkFlashnetExecuteSwapSuccessResponseSchema = sparkFlashnetExecuteSwapSuccessResponseSchema;
+exports.sparkFlashnetGetJwtParamsSchema = sparkFlashnetGetJwtParamsSchema;
+exports.sparkFlashnetGetJwtRequestSchema = sparkFlashnetGetJwtRequestSchema;
+exports.sparkFlashnetGetJwtResultSchema = sparkFlashnetGetJwtResultSchema;
+exports.sparkFlashnetGetJwtSuccessResponseSchema = sparkFlashnetGetJwtSuccessResponseSchema;
+exports.sparkFlashnetSignIntentParamsSchema = sparkFlashnetSignIntentParamsSchema;
+exports.sparkFlashnetSignIntentRequestSchema = sparkFlashnetSignIntentRequestSchema;
+exports.sparkFlashnetSignIntentResultSchema = sparkFlashnetSignIntentResultSchema;
+exports.sparkFlashnetSignIntentSuccessResponseSchema = sparkFlashnetSignIntentSuccessResponseSchema;
+exports.sparkFlashnetSignStructuredMessageParamsSchema = sparkFlashnetSignStructuredMessageParamsSchema;
+exports.sparkFlashnetSignStructuredMessageRequestSchema = sparkFlashnetSignStructuredMessageRequestSchema;
+exports.sparkFlashnetSignStructuredMessageResultSchema = sparkFlashnetSignStructuredMessageResultSchema;
+exports.sparkFlashnetSignStructuredMessageSuccessResponseSchema = sparkFlashnetSignStructuredMessageSuccessResponseSchema;
+exports.sparkGetAddressesParamsSchema = sparkGetAddressesParamsSchema;
+exports.sparkGetAddressesRequestSchema = sparkGetAddressesRequestSchema;
+exports.sparkGetAddressesResultSchema = sparkGetAddressesResultSchema;
+exports.sparkGetAddressesSuccessResponseSchema = sparkGetAddressesSuccessResponseSchema;
+exports.sparkGetAddressesV2ParamsSchema = sparkGetAddressesV2ParamsSchema;
+exports.sparkGetAddressesV2RequestSchema = sparkGetAddressesV2RequestSchema;
+exports.sparkGetAddressesV2ResultSchema = sparkGetAddressesV2ResultSchema;
+exports.sparkGetAddressesV2SuccessResponseSchema = sparkGetAddressesV2SuccessResponseSchema;
+exports.sparkGetBalanceParamsSchema = sparkGetBalanceParamsSchema;
+exports.sparkGetBalanceRequestSchema = sparkGetBalanceRequestSchema;
+exports.sparkGetBalanceResultSchema = sparkGetBalanceResultSchema;
+exports.sparkGetBalanceSuccessResponseSchema = sparkGetBalanceSuccessResponseSchema;
+exports.sparkGetClawbackEligibleTransfersParamsSchema = sparkGetClawbackEligibleTransfersParamsSchema;
+exports.sparkGetClawbackEligibleTransfersRequestSchema = sparkGetClawbackEligibleTransfersRequestSchema;
+exports.sparkGetClawbackEligibleTransfersResultSchema = sparkGetClawbackEligibleTransfersResultSchema;
+exports.sparkGetClawbackEligibleTransfersSuccessResponseSchema = sparkGetClawbackEligibleTransfersSuccessResponseSchema;
+exports.sparkMethods = sparkMethods;
+exports.sparkModeToLegacySparkNetworkType = sparkModeToLegacySparkNetworkType;
+exports.sparkNetworkConfigurationOptionsSchema = sparkNetworkConfigurationOptionsSchema;
+exports.sparkRequestSchema = sparkRequestSchema;
+exports.sparkSignMessageParamsSchema = sparkSignMessageParamsSchema;
+exports.sparkSignMessageRequestSchema = sparkSignMessageRequestSchema;
+exports.sparkSignMessageResultSchema = sparkSignMessageResultSchema;
+exports.sparkSignMessageSuccessResponseSchema = sparkSignMessageSuccessResponseSchema;
+exports.sparkSuccessResponseSchema = sparkSuccessResponseSchema;
+exports.sparkTransferParamsSchema = sparkTransferParamsSchema;
+exports.sparkTransferRequestSchema = sparkTransferRequestSchema;
+exports.sparkTransferResultSchema = sparkTransferResultSchema;
+exports.sparkTransferSuccessResponseSchema = sparkTransferSuccessResponseSchema;
+exports.sparkTransferTokenParamsSchema = sparkTransferTokenParamsSchema;
+exports.sparkTransferTokenRequestSchema = sparkTransferTokenRequestSchema;
+exports.sparkTransferTokenResultSchema = sparkTransferTokenResultSchema;
+exports.sparkTransferTokenSuccessResponseSchema = sparkTransferTokenSuccessResponseSchema;
+exports.specErrorObjectSchema = specErrorObjectSchema;
+exports.specErrorResponseSchema = specErrorResponseSchema;
+exports.specIdSchema = specIdSchema;
+exports.specRequestSchema = specRequestSchema;
+exports.specResponseSchema = specResponseSchema;
+exports.specSuccessResponseSchema = specSuccessResponseSchema;
+exports.specSuccessWithExtensionsResponseSchema = specSuccessWithExtensionsResponseSchema;
+exports.stacksCallContractParamsSchema = stacksCallContractParamsSchema;
+exports.stacksCallContractRequestSchema = stacksCallContractRequestSchema;
+exports.stacksCallContractResultSchema = stacksCallContractResultSchema;
+exports.stacksCallContractSuccessResponseSchema = stacksCallContractSuccessResponseSchema;
+exports.stacksDeployContractParamsSchema = stacksDeployContractParamsSchema;
+exports.stacksDeployContractRequestSchema = stacksDeployContractRequestSchema;
+exports.stacksDeployContractResultSchema = stacksDeployContractResultSchema;
+exports.stacksDeployContractSuccessResponseSchema = stacksDeployContractSuccessResponseSchema;
+exports.stacksGetAccountsParamsSchema = stacksGetAccountsParamsSchema;
+exports.stacksGetAccountsRequestSchema = stacksGetAccountsRequestSchema;
+exports.stacksGetAccountsResultSchema = stacksGetAccountsResultSchema;
+exports.stacksGetAccountsSuccessResponseSchema = stacksGetAccountsSuccessResponseSchema;
+exports.stacksGetAddressesParamsSchema = stacksGetAddressesParamsSchema;
+exports.stacksGetAddressesRequestSchema = stacksGetAddressesRequestSchema;
+exports.stacksGetAddressesResultSchema = stacksGetAddressesResultSchema;
+exports.stacksGetAddressesSuccessResponseSchema = stacksGetAddressesSuccessResponseSchema;
+exports.stacksMethods = stacksMethods;
+exports.stacksModeToLegacyStacksNetworkType = stacksModeToLegacyStacksNetworkType;
+exports.stacksNetworkConfigurationOptionsSchema = stacksNetworkConfigurationOptionsSchema;
+exports.stacksRequestSchema = stacksRequestSchema;
+exports.stacksSignMessageParamsSchema = stacksSignMessageParamsSchema;
+exports.stacksSignMessageRequestSchema = stacksSignMessageRequestSchema;
+exports.stacksSignMessageResultSchema = stacksSignMessageResultSchema;
+exports.stacksSignMessageSuccessResponseSchema = stacksSignMessageSuccessResponseSchema;
+exports.stacksSignStructuredMessageParamsSchema = stacksSignStructuredMessageParamsSchema;
+exports.stacksSignStructuredMessageRequestSchema = stacksSignStructuredMessageRequestSchema;
+exports.stacksSignStructuredMessageResultSchema = stacksSignStructuredMessageResultSchema;
+exports.stacksSignStructuredMessageSuccessResponseSchema = stacksSignStructuredMessageSuccessResponseSchema;
+exports.stacksSignTransactionParamsSchema = stacksSignTransactionParamsSchema;
+exports.stacksSignTransactionRequestSchema = stacksSignTransactionRequestSchema;
+exports.stacksSignTransactionResultSchema = stacksSignTransactionResultSchema;
+exports.stacksSignTransactionSuccessResponseSchema = stacksSignTransactionSuccessResponseSchema;
+exports.stacksSignTransactionsParamsSchema = stacksSignTransactionsParamsSchema;
+exports.stacksSignTransactionsRequestSchema = stacksSignTransactionsRequestSchema;
+exports.stacksSignTransactionsResultSchema = stacksSignTransactionsResultSchema;
+exports.stacksSignTransactionsSuccessResponseSchema = stacksSignTransactionsSuccessResponseSchema;
+exports.stacksSuccessResponseSchema = stacksSuccessResponseSchema;
+exports.stacksTransferStxParamsSchema = stacksTransferStxParamsSchema;
+exports.stacksTransferStxRequestSchema = stacksTransferStxRequestSchema;
+exports.stacksTransferStxResultSchema = stacksTransferStxResultSchema;
+exports.stacksTransferStxSuccessResponseSchema = stacksTransferStxSuccessResponseSchema;
+exports.starknetNetworkConfigurationOptionsSchema = starknetNetworkConfigurationOptionsSchema;
+exports.walletAddNetworkParamsSchema = walletAddNetworkParamsSchema;
+exports.walletAddNetworkRequestSchema = walletAddNetworkRequestSchema;
+exports.walletAddNetworkResultSchema = walletAddNetworkResultSchema;
+exports.walletAddNetworkSuccessResponseSchema = walletAddNetworkSuccessResponseSchema;
+exports.walletAddNetworkV2ParamsSchema = walletAddNetworkV2ParamsSchema;
+exports.walletAddNetworkV2RequestSchema = walletAddNetworkV2RequestSchema;
+exports.walletAddNetworkV2ResultSchema = walletAddNetworkV2ResultSchema;
+exports.walletAddNetworkV2SuccessResponseSchema = walletAddNetworkV2SuccessResponseSchema;
+exports.walletChangeNetworkParamsSchema = walletChangeNetworkParamsSchema;
+exports.walletChangeNetworkRequestSchema = walletChangeNetworkRequestSchema;
+exports.walletChangeNetworkResultSchema = walletChangeNetworkResultSchema;
+exports.walletChangeNetworkSuccessResponseSchema = walletChangeNetworkSuccessResponseSchema;
+exports.walletConnectParamsSchema = walletConnectParamsSchema;
+exports.walletConnectRequestSchema = walletConnectRequestSchema;
+exports.walletConnectResultSchema = walletConnectResultSchema;
+exports.walletConnectSuccessResponseSchema = walletConnectSuccessResponseSchema;
+exports.walletConnectV2ParamsSchema = walletConnectV2ParamsSchema;
+exports.walletConnectV2RequestSchema = walletConnectV2RequestSchema;
+exports.walletConnectV2ResultSchema = walletConnectV2ResultSchema;
+exports.walletConnectV2SuccessResponseSchema = walletConnectV2SuccessResponseSchema;
+exports.walletDisconnectParamsSchema = walletDisconnectParamsSchema;
+exports.walletDisconnectRequestSchema = walletDisconnectRequestSchema;
+exports.walletDisconnectResultSchema = walletDisconnectResultSchema;
+exports.walletDisconnectSuccessResponseSchema = walletDisconnectSuccessResponseSchema;
+exports.walletEventSchema = walletEventSchema;
+exports.walletGetAccountParamsSchema = walletGetAccountParamsSchema;
+exports.walletGetAccountRequestSchema = walletGetAccountRequestSchema;
+exports.walletGetAccountResultSchema = walletGetAccountResultSchema;
+exports.walletGetAccountSuccessResponseSchema = walletGetAccountSuccessResponseSchema;
+exports.walletGetAccountV2ParamsSchema = walletGetAccountV2ParamsSchema;
+exports.walletGetAccountV2RequestSchema = walletGetAccountV2RequestSchema;
+exports.walletGetAccountV2ResultSchema = walletGetAccountV2ResultSchema;
+exports.walletGetAccountV2SuccessResponseSchema = walletGetAccountV2SuccessResponseSchema;
+exports.walletGetCurrentPermissionsParamsSchema = walletGetCurrentPermissionsParamsSchema;
+exports.walletGetCurrentPermissionsRequestSchema = walletGetCurrentPermissionsRequestSchema;
+exports.walletGetCurrentPermissionsResultSchema = walletGetCurrentPermissionsResultSchema;
+exports.walletGetCurrentPermissionsSuccessResponseSchema = walletGetCurrentPermissionsSuccessResponseSchema;
+exports.walletGetNetworkParamsSchema = walletGetNetworkParamsSchema;
+exports.walletGetNetworkRequestSchema = walletGetNetworkRequestSchema;
+exports.walletGetNetworkResultSchema = walletGetNetworkResultSchema;
+exports.walletGetNetworkSuccessResponseSchema = walletGetNetworkSuccessResponseSchema;
+exports.walletGetNetworksParamsSchema = walletGetNetworksParamsSchema;
+exports.walletGetNetworksRequestSchema = walletGetNetworksRequestSchema;
+exports.walletGetNetworksResultSchema = walletGetNetworksResultSchema;
+exports.walletGetNetworksSuccessResponseSchema = walletGetNetworksSuccessResponseSchema;
+exports.walletGetWalletTypeParamsSchema = walletGetWalletTypeParamsSchema;
+exports.walletGetWalletTypeRequestSchema = walletGetWalletTypeRequestSchema;
+exports.walletGetWalletTypeResultSchema = walletGetWalletTypeResultSchema;
+exports.walletGetWalletTypeSuccessResponseSchema = walletGetWalletTypeSuccessResponseSchema;
+exports.walletMethods = walletMethods;
+exports.walletOpenBridgeParamsSchema = walletOpenBridgeParamsSchema;
+exports.walletOpenBridgeRequestSchema = walletOpenBridgeRequestSchema;
+exports.walletOpenBridgeResultSchema = walletOpenBridgeResultSchema;
+exports.walletOpenBridgeSuccessResponseSchema = walletOpenBridgeSuccessResponseSchema;
+exports.walletOpenBuyParamsSchema = walletOpenBuyParamsSchema;
+exports.walletOpenBuyRequestSchema = walletOpenBuyRequestSchema;
+exports.walletOpenBuyResultSchema = walletOpenBuyResultSchema;
+exports.walletOpenBuySuccessResponseSchema = walletOpenBuySuccessResponseSchema;
+exports.walletOpenReceiveParamsSchema = walletOpenReceiveParamsSchema;
+exports.walletOpenReceiveRequestSchema = walletOpenReceiveRequestSchema;
+exports.walletOpenReceiveResultSchema = walletOpenReceiveResultSchema;
+exports.walletOpenReceiveSuccessResponseSchema = walletOpenReceiveSuccessResponseSchema;
+exports.walletRenouncePermissionsParamsSchema = walletRenouncePermissionsParamsSchema;
+exports.walletRenouncePermissionsRequestSchema = walletRenouncePermissionsRequestSchema;
+exports.walletRenouncePermissionsResultSchema = walletRenouncePermissionsResultSchema;
+exports.walletRenouncePermissionsSuccessResponseSchema = walletRenouncePermissionsSuccessResponseSchema;
+exports.walletRequestPermissionsParamsSchema = walletRequestPermissionsParamsSchema;
+exports.walletRequestPermissionsRequestSchema = walletRequestPermissionsRequestSchema;
+exports.walletRequestPermissionsResultSchema = walletRequestPermissionsResultSchema;
+exports.walletRequestPermissionsSuccessResponseSchema = walletRequestPermissionsSuccessResponseSchema;
+exports.walletRequestSchema = walletRequestSchema;
+exports.walletSuccessResponseSchema = walletSuccessResponseSchema;
+exports.walletSwitchNetworkParamsSchema = walletSwitchNetworkParamsSchema;
+exports.walletSwitchNetworkRequestSchema = walletSwitchNetworkRequestSchema;
+exports.walletSwitchNetworkResultSchema = walletSwitchNetworkResultSchema;
+exports.walletSwitchNetworkSuccessResponseSchema = walletSwitchNetworkSuccessResponseSchema;
+exports.walletTypeSchema = walletTypeSchema;
+exports.walletTypes = walletTypes;