@sats-connect/core 0.16.0-4c59967 → 0.16.0-51b6afa

package/dist/index.cjs

@@ -32,8 +32,105 @@ 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/types/common.ts
+//#region src/request/rpc/objects/namespaces/wallet/shared/networks.ts
+const commonNetworkConfigurationSchema = valibot.object({
+	id: valibot.string(),
+	name: valibot.string(),
+	mode: valibot.picklist([]),
+	blockExplorerUrl: valibot.optional(valibot.union([valibot.pipe(valibot.literal(""), valibot.transform(() => void 0)), valibot.pipe(valibot.string(), valibot.url())]))
+});
+const bitcoinChainModeSchema = valibot.enum({
+	mainnet: "mainnet",
+	testnet: "testnet",
+	testnet4: "testnet4",
+	signet: "signet",
+	regtest: "regtest"
+});
+const bitcoinNetworkConfigurationSchema = valibot.object({
+	chain: valibot.literal("bitcoin"),
+	...commonNetworkConfigurationSchema.entries,
+	mode: valibot.pipe(valibot.string(), bitcoinChainModeSchema),
+	xverseApiUrl: valibot.pipe(valibot.string(), valibot.url()),
+	electrsApiUrl: valibot.pipe(valibot.string(), valibot.url())
+});
+const sparkChainMode = {
+	mainnet: "mainnet",
+	regtest: "regtest"
+};
+const sparkChainModeSchema = valibot.enum(sparkChainMode);
+const sparkNetworkConfigurationSchema = valibot.object({
+	chain: valibot.literal("spark"),
+	...commonNetworkConfigurationSchema.entries,
+	mode: valibot.pipe(valibot.string(), sparkChainModeSchema),
+	electrsApiUrl: valibot.pipe(valibot.string(), valibot.url())
+});
+const stacksChainMode = {
+	mainnet: "mainnet",
+	testnet: "testnet",
+	devnet: "devnet",
+	mocknet: "mocknet"
+};
+const stacksChainModeSchema = valibot.enum(stacksChainMode);
+const stacksNetworkConfigurationSchema = valibot.object({
+	chain: valibot.literal("stacks"),
+	...commonNetworkConfigurationSchema.entries,
+	mode: valibot.pipe(valibot.string(), stacksChainModeSchema),
+	stacksApiUrl: valibot.pipe(valibot.string(), valibot.url()),
+	xverseApiUrl: valibot.pipe(valibot.string(), valibot.url())
+});
+const starknetChainMode = {
+	mainnet: "mainnet",
+	sepolia: "sepolia"
+};
+const starknetChainModeSchema = valibot.enum(starknetChainMode);
+const starknetNetworkConfigurationSchema = valibot.object({
+	chain: valibot.literal("starknet"),
+	...commonNetworkConfigurationSchema.entries,
+	mode: valibot.pipe(valibot.string(), 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 bitcoinNetworkConfigurationOptionsSchema = valibot.omit(bitcoinNetworkConfigurationSchema, ["id"]);
+const sparkNetworkConfigurationOptionsSchema = valibot.omit(sparkNetworkConfigurationSchema, ["id"]);
+const stacksNetworkConfigurationOptionsSchema = valibot.omit(stacksNetworkConfigurationSchema, ["id"]);
+const starknetNetworkConfigurationOptionsSchema = valibot.omit(starknetNetworkConfigurationSchema, ["id"]);
+const networkConfigurationOptionsSchema = valibot.variant("chain", [
+	bitcoinNetworkConfigurationOptionsSchema,
+	sparkNetworkConfigurationOptionsSchema,
+	stacksNetworkConfigurationOptionsSchema,
+	starknetNetworkConfigurationOptionsSchema
+]);
+const allResolvedNetworksSchema = valibot.object({
+	active: valibot.object({
+		bitcoin: bitcoinNetworkConfigurationSchema,
+		spark: sparkNetworkConfigurationSchema,
+		stacks: stacksNetworkConfigurationSchema,
+		starknet: starknetNetworkConfigurationSchema
+	}),
+	builtin: valibot.object({
+		bitcoin: valibot.array(bitcoinNetworkConfigurationSchema),
+		spark: valibot.array(sparkNetworkConfigurationSchema),
+		stacks: valibot.array(stacksNetworkConfigurationSchema),
+		starknet: valibot.array(starknetNetworkConfigurationSchema)
+	}),
+	custom: valibot.object({
+		bitcoin: valibot.array(bitcoinNetworkConfigurationSchema),
+		spark: valibot.array(sparkNetworkConfigurationSchema),
+		stacks: valibot.array(stacksNetworkConfigurationSchema),
+		starknet: valibot.array(starknetNetworkConfigurationSchema)
+	})
+});
+
+//#endregion
+//#region src/request/rpc/objects/shared/index.ts
 const walletTypes = [
 	"software",
 	"ledger",
@@ -114,21 +211,6 @@ let SparkNetworkType = /* @__PURE__ */ function(SparkNetworkType$1) {
 	SparkNetworkType$1["Regtest"] = "regtest";
 	return SparkNetworkType$1;
 }({});
-const RpcIdSchema = valibot.optional(valibot.union([
-	valibot.string(),
-	valibot.number(),
-	valibot.null()
-]));
-const rpcRequestMessageSchema = valibot.object({
-	jsonrpc: valibot.literal("2.0"),
-	method: valibot.string(),
-	params: valibot.optional(valibot.union([
-		valibot.array(valibot.unknown()),
-		valibot.looseObject({}),
-		valibot.null()
-	])),
-	id: valibot.unwrap(RpcIdSchema)
-});
 /**
 * @enum {number} RpcErrorCode
 * @description JSON-RPC error codes
@@ -170,83 +252,6 @@ let RpcErrorCode = /* @__PURE__ */ function(RpcErrorCode$1) {
 	RpcErrorCode$1[RpcErrorCode$1["ACCESS_DENIED"] = -32002] = "ACCESS_DENIED";
 	return RpcErrorCode$1;
 }({});
-const rpcSuccessResponseMessageSchema = valibot.object({
-	jsonrpc: valibot.literal("2.0"),
-	result: valibot.nonOptional(valibot.unknown()),
-	id: RpcIdSchema
-});
-const rpcErrorResponseMessageSchema = valibot.object({
-	jsonrpc: valibot.literal("2.0"),
-	error: valibot.nonOptional(valibot.unknown()),
-	id: RpcIdSchema
-});
-const rpcResponseMessageSchema = valibot.union([rpcSuccessResponseMessageSchema, rpcErrorResponseMessageSchema]);
-
-//#endregion
-//#region src/request/types/walletMethods/utils.ts
-const commonNetworkConfigurationSchema = valibot.object({
-	id: valibot.string(),
-	name: valibot.string(),
-	mode: valibot.picklist([]),
-	blockExplorerUrl: valibot.optional(valibot.union([valibot.pipe(valibot.literal(""), valibot.transform(() => void 0)), valibot.pipe(valibot.string(), valibot.url())]))
-});
-const bitcoinChainModeSchema = valibot.enum({
-	mainnet: "mainnet",
-	testnet: "testnet",
-	testnet4: "testnet4",
-	signet: "signet",
-	regtest: "regtest"
-});
-const bitcoinNetworkConfigurationSchema = valibot.object({
-	chain: valibot.literal("bitcoin"),
-	...commonNetworkConfigurationSchema.entries,
-	mode: valibot.pipe(valibot.string(), bitcoinChainModeSchema),
-	xverseApiUrl: valibot.pipe(valibot.string(), valibot.url()),
-	electrsApiUrl: valibot.pipe(valibot.string(), valibot.url())
-});
-const sparkChainMode = {
-	mainnet: "mainnet",
-	regtest: "regtest"
-};
-const sparkChainModeSchema = valibot.enum(sparkChainMode);
-const sparkNetworkConfigurationSchema = valibot.object({
-	chain: valibot.literal("spark"),
-	...commonNetworkConfigurationSchema.entries,
-	mode: valibot.pipe(valibot.string(), sparkChainModeSchema),
-	electrsApiUrl: valibot.pipe(valibot.string(), valibot.url())
-});
-const stacksChainMode = {
-	mainnet: "mainnet",
-	testnet: "testnet",
-	devnet: "devnet",
-	mocknet: "mocknet"
-};
-const stacksChainModeSchema = valibot.enum(stacksChainMode);
-const stacksNetworkConfigurationSchema = valibot.object({
-	chain: valibot.literal("stacks"),
-	...commonNetworkConfigurationSchema.entries,
-	mode: valibot.pipe(valibot.string(), stacksChainModeSchema),
-	stacksApiUrl: valibot.pipe(valibot.string(), valibot.url()),
-	xverseApiUrl: valibot.pipe(valibot.string(), valibot.url())
-});
-const starknetChainMode = {
-	mainnet: "mainnet",
-	sepolia: "sepolia"
-};
-const starknetChainModeSchema = valibot.enum(starknetChainMode);
-const starknetNetworkConfigurationSchema = valibot.object({
-	chain: valibot.literal("starknet"),
-	...commonNetworkConfigurationSchema.entries,
-	mode: valibot.pipe(valibot.string(), starknetChainModeSchema),
-	rpcApiUrl: valibot.pipe(valibot.string(), valibot.url()),
-	xverseApiUrl: valibot.pipe(valibot.string(), valibot.url())
-});
-const networkConfigurationSchema = valibot.variant("chain", [
-	bitcoinNetworkConfigurationSchema,
-	sparkNetworkConfigurationSchema,
-	stacksNetworkConfigurationSchema,
-	starknetNetworkConfigurationSchema
-]);
 
 //#endregion
 //#region src/provider/types.ts
@@ -317,292 +322,26 @@ function getSupportedWallets() {
 }
 
 //#endregion
-//#region src/request/sanitizeRequest.ts
-const sanitizeRequest = (method, params, providerInfo) => {
-	try {
-		const [major, minor, patch] = providerInfo.version.split(".").map((part) => parseInt(part, 10));
-		const platform = providerInfo.platform;
-		if (!platform || platform === ProviderPlatform.Web && major <= 1 && minor <= 4 || platform === ProviderPlatform.Mobile && major <= 1 && minor <= 54) {
-			const v1Sanitized = sanitizeAddressPurposeRequest(method, params);
-			method = v1Sanitized.method;
-			params = v1Sanitized.params;
-		}
-	} catch {}
-	return {
-		method,
-		params
-	};
+//#region src/runes/api.ts
+const urlNetworkSuffix = {
+	[BitcoinNetworkType.Mainnet]: "",
+	[BitcoinNetworkType.Testnet]: "-testnet",
+	[BitcoinNetworkType.Testnet4]: "-testnet4",
+	[BitcoinNetworkType.Signet]: "-signet"
 };
-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)
-			}
-		};
+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) });
 	}
-	if (method === "getAddresses") {
-		const { purposes, ...rest } = params;
+	parseError = (error) => {
 		return {
-			method,
-			params: {
-				...rest,
-				purposes: filterPurposes(purposes)
-			}
-		};
-	}
-	return {
-		method,
-		params
-	};
-};
-
-//#endregion
-//#region src/request/rpc.ts
-const rpcIdSchema = valibot.union([
-	valibot.string(),
-	valibot.number(),
-	valibot.null()
-]);
-const rpcRequestSchema = 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(rpcIdSchema)
-});
-const rpcSuccessResponseSchema = valibot.object({
-	jsonrpc: valibot.literal("2.0"),
-	result: valibot.unknown(),
-	id: rpcIdSchema
-});
-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 rpcSuccessWithExtensionsResponseSchema = valibot.object({
-	...rpcSuccessResponseSchema.entries,
-	extensions: valibot.optional(valibot.object({ warnings: valibot.array(warningSchema) }))
-});
-const rpcErrorObject = valibot.object({
-	code: valibot.number(),
-	message: valibot.string(),
-	data: valibot.optional(valibot.unknown())
-});
-const rpcErrorResponseSchema = valibot.object({
-	jsonrpc: valibot.literal("2.0"),
-	error: rpcErrorObject,
-	id: rpcIdSchema
-});
-
-//#endregion
-//#region src/request/createSuccessResponseSchema.ts
-function createSuccessResponseSchema({ method, resultSchema }) {
-	return valibot.object({
-		...rpcSuccessWithExtensionsResponseSchema.entries,
-		id: valibot.string(),
-		result: resultSchema,
-		"~sats-connect-method": valibot.literal(method)
-	});
-}
-
-//#endregion
-//#region src/request/methods.ts
-const bitcoinMethods = {
-	getAccounts: "getAccounts",
-	bitcoin_getAccountsV2: "bitcoin_getAccountsV2",
-	getAddresses: "getAddresses",
-	bitcoin_getAddressesV2: "bitcoin_getAddressesV2",
-	getBalance: "getBalance",
-	bitcoin_getBalanceV2: "bitcoin_getBalanceV2",
-	getInfo: "getInfo",
-	bitcoin_getInfoV2: "bitcoin_getInfoV2",
-	sendTransfer: "sendTransfer",
-	bitcoin_sendTransferV2: "bitcoin_sendTransferV2",
-	signMessage: "signMessage",
-	bitcoin_signMessageV2: "bitcoin_signMessageV2",
-	signMultipleMessages: "signMultipleMessages",
-	bitcoin_signMultipleMessagesV2: "bitcoin_signMultipleMessagesV2",
-	signPsbt: "signPsbt",
-	bitcoin_signPsbtV2: "bitcoin_signPsbtV2"
-};
-
-//#endregion
-//#region src/request/rpc/methodSchemas/bitcoin/getInfo/response.ts
-let ProviderPlatform = /* @__PURE__ */ function(ProviderPlatform$1) {
-	ProviderPlatform$1["Web"] = "web";
-	ProviderPlatform$1["Mobile"] = "mobile";
-	return ProviderPlatform$1;
-}({});
-const bitcoinGetInfoSuccessResponseSchema = createSuccessResponseSchema({
-	resultSchema: valibot.object({
-		version: valibot.string(),
-		platform: valibot.optional(valibot.enum(ProviderPlatform)),
-		methods: valibot.optional(valibot.array(valibot.string())),
-		supports: valibot.array(valibot.string())
-	}),
-	method: bitcoinMethods.getInfo
-});
-
-//#endregion
-//#region src/request/createRequestSchema.ts
-function createRequestSchema({ paramsSchema, method }) {
-	return valibot.object({
-		...rpcRequestSchema.entries,
-		id: valibot.string(),
-		method: valibot.literal(method),
-		params: paramsSchema
-	});
-}
-
-//#endregion
-//#region src/request/rpc/methodSchemas/bitcoin/signMessage/request.ts
-let MessageSigningProtocols = /* @__PURE__ */ function(MessageSigningProtocols$1) {
-	MessageSigningProtocols$1["ECDSA"] = "ECDSA";
-	MessageSigningProtocols$1["BIP322"] = "BIP322";
-	return MessageSigningProtocols$1;
-}({});
-const bitcoinSignMessageRequestSchema = createRequestSchema({
-	paramsSchema: valibot.object({
-		address: valibot.string(),
-		message: valibot.string(),
-		protocol: valibot.optional(valibot.enum(MessageSigningProtocols))
-	}),
-	method: bitcoinMethods.signMessage
-});
-
-//#endregion
-//#region src/request/index.ts
-const cache = {};
-const requestInternal = async (provider, method, params) => {
-	const response = await provider.request(method, params);
-	if (valibot.is(rpcErrorResponseMessageSchema, response)) return {
-		status: "error",
-		error: response.error
-	};
-	if (valibot.is(rpcSuccessResponseMessageSchema, response)) return {
-		status: "success",
-		result: response.result
-	};
-	return {
-		status: "error",
-		error: {
-			code: RpcErrorCode.INTERNAL_ERROR,
-			message: "Received unknown response from provider.",
-			data: response
-		}
-	};
-};
-const request = async (method, params, providerId) => {
-	let provider = window.XverseProviders?.BitcoinProvider || window.BitcoinProvider;
-	if (providerId) provider = await getProviderById(providerId);
-	if (!provider) throw new Error("no wallet provider was found");
-	if (!method) throw new Error("A wallet method is required");
-	if (!cache.providerInfo) {
-		const infoResult = await requestInternal(provider, "getInfo", null);
-		if (infoResult.status === "success") cache.providerInfo = infoResult.result;
-	}
-	if (cache.providerInfo) {
-		if (method === "getInfo") return {
-			status: "success",
-			result: cache.providerInfo
-		};
-		const sanitized = sanitizeRequest(method, params, cache.providerInfo);
-		if (sanitized.overrideResponse) return sanitized.overrideResponse;
-		method = sanitized.method;
-		params = sanitized.params;
-	}
-	return requestInternal(provider, method, params);
-};
-/**
-* Adds an event listener.
-*
-* Currently expects 2 arguments, although is also capable of handling legacy
-* calls with 3 arguments consisting of:
-*
-* - event name (string)
-* - callback (function)
-* - provider ID (optional string)
-*/
-const addListener = (...rawArgs) => {
-	const [listenerInfo, providerId] = (() => {
-		if (rawArgs.length === 1) return [rawArgs[0], void 0];
-		if (rawArgs.length === 2) if (typeof rawArgs[1] === "function") return [{
-			eventName: rawArgs[0],
-			cb: rawArgs[1]
-		}, void 0];
-		else return rawArgs;
-		if (rawArgs.length === 3) return [{
-			eventName: rawArgs[0],
-			cb: rawArgs[1]
-		}, rawArgs[2]];
-		throw new Error("Unexpected number of arguments. Expecting 2 (or 3 for legacy requests).", { cause: rawArgs });
-	})();
-	let provider = window.XverseProviders?.BitcoinProvider || window.BitcoinProvider;
-	if (providerId) provider = getProviderById(providerId);
-	if (!provider) throw new Error("no wallet provider was found");
-	if (!provider.addListener) {
-		console.error(`The wallet provider you are using does not support the addListener method. Please update your wallet provider.`);
-		return () => {};
-	}
-	return provider.addListener(listenerInfo);
-};
-
-//#endregion
-//#region src/runes/api.ts
-const urlNetworkSuffix = {
-	[BitcoinNetworkType.Mainnet]: "",
-	[BitcoinNetworkType.Testnet]: "-testnet",
-	[BitcoinNetworkType.Testnet4]: "-testnet4",
-	[BitcoinNetworkType.Signet]: "-signet"
-};
-const ORDINALS_API_BASE_URL = (network = BitcoinNetworkType.Mainnet) => {
-	if (network === BitcoinNetworkType.Regtest) throw new Error(`Ordinals API does not support ${network} network`);
-	return `https://ordinals${urlNetworkSuffix[network]}.xverse.app/v1`;
-};
-var RunesApi = class {
-	client;
-	constructor(network) {
-		this.client = axios.default.create({ baseURL: ORDINALS_API_BASE_URL(network) });
-	}
-	parseError = (error) => {
-		return {
-			code: error.response?.status,
-			message: JSON.stringify(error.response?.data)
+			code: error.response?.status,
+			message: JSON.stringify(error.response?.data)
 		};
 	};
 	estimateMintCost = async (mintParams) => {
@@ -914,18 +653,2614 @@ var SatsConnectAdapter = class {
 			};
 		}
 	}
-	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);
-		}
+	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) {
+	let result = [];
+	if (!signInputs) return result;
+	for (let address in signInputs) {
+		let indexes = signInputs[address];
+		for (let index of indexes) result.push({
+			index,
+			address
+		});
+	}
+	return result;
+}
+var UnisatAdapter = class extends SatsConnectAdapter {
+	id = DefaultAdaptersInfo.unisat.id;
+	async getAccounts(params) {
+		const { purposes } = params;
+		if (purposes.includes(AddressPurpose.Stacks) || purposes.includes(AddressPurpose.Starknet) || purposes.includes(AddressPurpose.Spark)) throw new Error("Only bitcoin addresses are supported");
+		const accounts = await window.unisat.requestAccounts();
+		const publicKey = await window.unisat.getPublicKey();
+		const address = accounts[0];
+		const addressType = (0, bitcoin_address_validation.getAddressInfo)(accounts[0]).type;
+		const pk = addressType === bitcoin_address_validation.AddressType.p2tr ? publicKey.slice(2) : publicKey;
+		const paymentAddress = {
+			address,
+			publicKey: pk,
+			addressType,
+			purpose: AddressPurpose.Payment,
+			walletType: "software"
+		};
+		const ordinalsAddress = {
+			address,
+			publicKey: pk,
+			addressType,
+			purpose: AddressPurpose.Ordinals,
+			walletType: "software"
+		};
+		const response = [];
+		if (purposes.includes(AddressPurpose.Payment)) response.push({
+			...paymentAddress,
+			walletType: "software"
+		});
+		if (purposes.includes(AddressPurpose.Ordinals)) response.push({
+			...ordinalsAddress,
+			walletType: "software"
+		});
+		return response;
+	}
+	async signMessage(params) {
+		const { message, address } = params;
+		const addressType = (0, bitcoin_address_validation.getAddressInfo)(address).type;
+		if ([bitcoin_address_validation.AddressType.p2wpkh, bitcoin_address_validation.AddressType.p2tr].includes(addressType)) return {
+			address,
+			messageHash: "",
+			signature: await window.unisat.signMessage(message, "bip322-simple"),
+			protocol: MessageSigningProtocols.BIP322
+		};
+		return {
+			address,
+			messageHash: "",
+			signature: await window.unisat.signMessage(message, "ecdsa"),
+			protocol: MessageSigningProtocols.ECDSA
+		};
+	}
+	async sendTransfer(params) {
+		const { recipients } = params;
+		if (recipients.length > 1) throw new Error("Only one recipient is supported by this wallet provider");
+		return { txid: await window.unisat.sendBitcoin(recipients[0].address, recipients[0].amount) };
+	}
+	async signPsbt(params) {
+		const { psbt, signInputs, broadcast } = params;
+		const psbtHex = buffer.Buffer.from(psbt, "base64").toString("hex");
+		const signedPsbt = await window.unisat.signPsbt(psbtHex, {
+			autoFinalized: broadcast,
+			toSignInputs: convertSignInputsToInputType(signInputs)
+		});
+		const signedPsbtBase64 = buffer.Buffer.from(signedPsbt, "hex").toString("base64");
+		let txid;
+		if (broadcast) txid = await window.unisat.pushPsbt(signedPsbt);
+		return {
+			psbt: signedPsbtBase64,
+			txid
+		};
+	}
+	requestInternal = async (method, params) => {
+		try {
+			switch (method) {
+				case "getAccounts": return {
+					status: "success",
+					result: await this.getAccounts(params)
+				};
+				case "sendTransfer": return {
+					status: "success",
+					result: await this.sendTransfer(params)
+				};
+				case "signMessage": return {
+					status: "success",
+					result: await this.signMessage(params)
+				};
+				case "signPsbt": return {
+					status: "success",
+					result: await this.signPsbt(params)
+				};
+				default: {
+					const error = {
+						code: RpcErrorCode.METHOD_NOT_SUPPORTED,
+						message: "Method not supported by the selected wallet"
+					};
+					console.error("Error calling the method", error);
+					return {
+						status: "error",
+						error
+					};
+				}
+			}
+		} catch (error) {
+			console.error("Error calling the method", error);
+			return {
+				status: "error",
+				error: {
+					code: error.code === 4001 ? RpcErrorCode.USER_REJECTION : RpcErrorCode.INTERNAL_ERROR,
+					message: error.message ? error.message : "Wallet method call error",
+					data: error
+				}
+			};
+		}
+	};
+	addListener = ({ eventName, cb }) => {
+		switch (eventName) {
+			case "accountChange": {
+				const handler = () => {
+					cb({ type: "accountChange" });
+				};
+				window.unisat.on("accountsChanged", handler);
+				return () => {
+					window.unisat.removeListener("accountsChanged", handler);
+				};
+			}
+			case "networkChange": {
+				const handler = () => {
+					cb({ type: "networkChange" });
+				};
+				window.unisat.on("networkChanged", handler);
+				return () => {
+					window.unisat.removeListener("networkChanged", handler);
+				};
+			}
+			default:
+				console.error("Event not supported by the selected wallet");
+				return () => {};
+		}
+	};
+};
+
+//#endregion
+//#region src/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, patch] = providerInfo.version.split(".").map((part) => parseInt(part, 10));
+		const platform = providerInfo.platform;
+		if (!platform || platform === ProviderPlatform.Web && major <= 1 && minor <= 4 || platform === ProviderPlatform.Mobile && major <= 1 && minor <= 54) {
+			const v1Sanitized = sanitizeAddressPurposeRequest(method, params);
+			method = v1Sanitized.method;
+			params = v1Sanitized.params;
+		}
+	} catch {}
+	return {
+		method,
+		params
+	};
+};
+const sanitizeAddressPurposeRequest = (method, params) => {
+	const filterPurposes = (purposes) => purposes?.filter((purpose) => purpose !== AddressPurpose.Spark && purpose !== AddressPurpose.Starknet);
+	if (method === "wallet_connect") {
+		const typedParams = params;
+		if (!typedParams) return {
+			method,
+			params
+		};
+		const { addresses, ...rest } = typedParams;
+		return {
+			method,
+			params: {
+				...rest,
+				addresses: filterPurposes(addresses)
+			}
+		};
+	}
+	if (method === "getAccounts") {
+		const { purposes, ...rest } = params;
+		return {
+			method,
+			params: {
+				...rest,
+				purposes: filterPurposes(purposes)
+			}
+		};
+	}
+	if (method === "getAddresses") {
+		const { purposes, ...rest } = params;
+		return {
+			method,
+			params: {
+				...rest,
+				purposes: filterPurposes(purposes)
+			}
+		};
+	}
+	return {
+		method,
+		params
+	};
+};
+
+//#endregion
+//#region src/request/methods.ts
+const bitcoinMethods = {
+	getAccounts: "getAccounts",
+	bitcoin_getAccountsV2: "bitcoin_getAccountsV2",
+	getAddresses: "getAddresses",
+	bitcoin_getAddressesV2: "bitcoin_getAddressesV2",
+	getBalance: "getBalance",
+	bitcoin_getBalanceV2: "bitcoin_getBalanceV2",
+	getInfo: "getInfo",
+	bitcoin_getInfoV2: "bitcoin_getInfoV2",
+	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",
+	stacks_getAddressesV2: "stacks_getAddressesV2",
+	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_changeNetworkById: "wallet_changeNetworkById",
+	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"
+};
+
+//#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.bitcoin_getAccountsV2]: active,
+	[bitcoinMethods.getAddresses]: active,
+	[bitcoinMethods.bitcoin_getAddressesV2]: active,
+	[bitcoinMethods.getBalance]: active,
+	[bitcoinMethods.bitcoin_getBalanceV2]: active,
+	[bitcoinMethods.getInfo]: active,
+	[bitcoinMethods.bitcoin_getInfoV2]: 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.stacks_getAddressesV2]: 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_changeNetworkById]: 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
+};
+
+//#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/getAccountsV2/request.ts
+const bitcoinGetAccountsV2ParamsSchema = valibot.object({
+	purposes: valibot.array(valibot.enum(AddressPurpose)),
+	message: valibot.optional(valibot.string())
+});
+const bitcoinGetAccountsV2RequestSchema = createRequestSchema({
+	paramsSchema: bitcoinGetAccountsV2ParamsSchema,
+	method: bitcoinMethods.bitcoin_getAccountsV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/getAccountsV2/response.ts
+const bitcoinGetAccountsV2ResultSchema = valibot.array(valibot.object({
+	...addressSchema.entries,
+	...valibot.object({ walletType: walletTypeSchema }).entries
+}));
+const bitcoinGetAccountsV2SuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: bitcoinGetAccountsV2ResultSchema,
+	method: bitcoinMethods.bitcoin_getAccountsV2
+});
+
+//#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/bitcoin/methods/getAddressesV2/response.ts
+const getNetworksResultSchema = valibot.object({
+	active: valibot.object({
+		bitcoin: valibot.object({
+			id: valibot.string(),
+			type: valibot.string(),
+			name: valibot.string()
+		}),
+		stacks: valibot.object({
+			id: valibot.string(),
+			type: valibot.string(),
+			name: valibot.string()
+		}),
+		spark: valibot.object({
+			id: valibot.string(),
+			type: valibot.string(),
+			name: valibot.string()
+		}),
+		starknet: valibot.object({
+			id: valibot.string(),
+			type: valibot.string(),
+			name: valibot.string()
+		})
+	}),
+	builtin: valibot.object({
+		bitcoin: valibot.array(valibot.any()),
+		stacks: valibot.array(valibot.any()),
+		spark: valibot.array(valibot.any()),
+		starknet: valibot.array(valibot.any())
+	}),
+	custom: valibot.object({
+		bitcoin: valibot.array(valibot.any()),
+		stacks: valibot.array(valibot.any()),
+		spark: valibot.array(valibot.any()),
+		starknet: valibot.array(valibot.any())
+	})
+});
+const bitcoinGetAddressesV2ResultSchema = valibot.object({
+	addresses: valibot.array(addressSchema),
+	networks: getNetworksResultSchema
+});
+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/methods/getBalance/response.ts
+const bitcoinGetBalanceResultSchema = valibot.object({
+	confirmed: valibot.string(),
+	unconfirmed: valibot.string(),
+	total: valibot.string()
+});
+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 = valibot.object({
+	confirmed: valibot.string(),
+	unconfirmed: valibot.string(),
+	total: valibot.string()
+});
+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/methods/getInfoV2/request.ts
+const bitcoinGetInfoV2ParamsSchema = valibot.nullish(valibot.null());
+const bitcoinGetInfoV2RequestSchema = createRequestSchema({
+	paramsSchema: bitcoinGetInfoV2ParamsSchema,
+	method: bitcoinMethods.bitcoin_getInfoV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/getInfoV2/response.ts
+const bitcoinGetInfoV2ResultSchema = valibot.object({
+	version: valibot.string(),
+	platform: valibot.optional(valibot.enum(ProviderPlatform)),
+	methods: valibot.optional(valibot.array(valibot.string())),
+	supports: valibot.array(valibot.string())
+});
+const bitcoinGetInfoV2SuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: bitcoinGetInfoV2ResultSchema,
+	method: bitcoinMethods.bitcoin_getInfoV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/sendTransfer/request.ts
+const bitcoinSendTransferParamsSchema = valibot.object({ recipients: valibot.array(valibot.object({
+	address: valibot.string(),
+	amount: valibot.number()
+})) });
+const bitcoinSendTransferRequestSchema = createRequestSchema({
+	paramsSchema: bitcoinSendTransferParamsSchema,
+	method: bitcoinMethods.sendTransfer
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/sendTransfer/response.ts
+const bitcoinSendTransferResultSchema = valibot.object({ txid: valibot.string() });
+const bitcoinSendTransferSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: bitcoinSendTransferResultSchema,
+	method: bitcoinMethods.sendTransfer
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/sendTransferV2/request.ts
+const bitcoinSendTransferV2ParamsSchema = valibot.object({ recipients: valibot.array(valibot.object({
+	address: valibot.string(),
+	amount: valibot.number()
+})) });
+const bitcoinSendTransferV2RequestSchema = createRequestSchema({
+	paramsSchema: bitcoinSendTransferV2ParamsSchema,
+	method: bitcoinMethods.bitcoin_sendTransferV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/sendTransferV2/response.ts
+const bitcoinSendTransferV2ResultSchema = valibot.object({ txid: valibot.string() });
+const bitcoinSendTransferV2SuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: bitcoinSendTransferV2ResultSchema,
+	method: bitcoinMethods.bitcoin_sendTransferV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/signMessage/request.ts
+const bitcoinSignMessageParamsSchema = valibot.object({
+	address: valibot.string(),
+	message: valibot.string(),
+	protocol: valibot.optional(valibot.enum(MessageSigningProtocols))
+});
+const bitcoinSignMessageRequestSchema = createRequestSchema({
+	paramsSchema: bitcoinSignMessageParamsSchema,
+	method: bitcoinMethods.signMessage
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/signMessage/response.ts
+const bitcoinSignMessageResultSchema = valibot.object({
+	signature: valibot.string(),
+	messageHash: valibot.string(),
+	address: valibot.string(),
+	protocol: valibot.enum(MessageSigningProtocols)
+});
+const bitcoinSignMessageSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: bitcoinSignMessageResultSchema,
+	method: bitcoinMethods.signMessage
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/signMessageV2/request.ts
+const bitcoinSignMessageV2ParamsSchema = valibot.object({
+	address: valibot.string(),
+	message: valibot.string(),
+	protocol: valibot.optional(valibot.enum(MessageSigningProtocols))
+});
+const bitcoinSignMessageV2RequestSchema = createRequestSchema({
+	paramsSchema: bitcoinSignMessageV2ParamsSchema,
+	method: bitcoinMethods.bitcoin_signMessageV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/signMessageV2/response.ts
+const bitcoinSignMessageV2ResultSchema = valibot.object({
+	signature: valibot.string(),
+	messageHash: valibot.string(),
+	address: valibot.string(),
+	protocol: valibot.enum(MessageSigningProtocols)
+});
+const bitcoinSignMessageV2SuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: bitcoinSignMessageV2ResultSchema,
+	method: bitcoinMethods.bitcoin_signMessageV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/signMultipleMessages/request.ts
+const bitcoinSignMultipleMessagesParamsSchema = valibot.array(valibot.object({
+	address: valibot.string(),
+	message: valibot.string(),
+	protocol: valibot.optional(valibot.enum(MessageSigningProtocols))
+}));
+const bitcoinSignMultipleMessagesRequestSchema = createRequestSchema({
+	paramsSchema: bitcoinSignMultipleMessagesParamsSchema,
+	method: bitcoinMethods.signMultipleMessages
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/signMultipleMessages/response.ts
+const bitcoinSignMultipleMessagesResultSchema = valibot.array(valibot.object({
+	signature: valibot.string(),
+	message: valibot.string(),
+	messageHash: valibot.string(),
+	address: valibot.string(),
+	protocol: valibot.enum(MessageSigningProtocols)
+}));
+const bitcoinSignMultipleMessagesSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: bitcoinSignMultipleMessagesResultSchema,
+	method: bitcoinMethods.signMultipleMessages
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/signMultipleMessagesV2/request.ts
+const bitcoinSignMultipleMessagesV2ParamsSchema = valibot.array(valibot.object({
+	address: valibot.string(),
+	message: valibot.string(),
+	protocol: valibot.optional(valibot.enum(MessageSigningProtocols))
+}));
+const bitcoinSignMultipleMessagesV2RequestSchema = createRequestSchema({
+	paramsSchema: bitcoinSignMultipleMessagesV2ParamsSchema,
+	method: bitcoinMethods.bitcoin_signMultipleMessagesV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/signMultipleMessagesV2/response.ts
+const bitcoinSignMultipleMessagesV2ResultSchema = valibot.array(valibot.object({
+	signature: valibot.string(),
+	message: valibot.string(),
+	messageHash: valibot.string(),
+	address: valibot.string(),
+	protocol: valibot.enum(MessageSigningProtocols)
+}));
+const bitcoinSignMultipleMessagesV2SuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: bitcoinSignMultipleMessagesV2ResultSchema,
+	method: bitcoinMethods.bitcoin_signMultipleMessagesV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/signPsbt/request.ts
+const bitcoinSignPsbtParamsSchema = valibot.object({
+	psbt: valibot.string(),
+	signInputs: valibot.optional(valibot.record(valibot.string(), valibot.array(valibot.number()))),
+	broadcast: valibot.optional(valibot.boolean())
+});
+const bitcoinSignPsbtRequestSchema = createRequestSchema({
+	paramsSchema: bitcoinSignPsbtParamsSchema,
+	method: bitcoinMethods.signPsbt
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/signPsbt/response.ts
+const bitcoinSignPsbtResultSchema = valibot.object({
+	psbt: valibot.string(),
+	txid: valibot.optional(valibot.string())
+});
+const bitcoinSignPsbtSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: bitcoinSignPsbtResultSchema,
+	method: bitcoinMethods.signPsbt
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/signPsbtV2/request.ts
+const bitcoinSignPsbtV2ParamsSchema = valibot.object({
+	psbt: valibot.string(),
+	signInputs: valibot.optional(valibot.record(valibot.string(), valibot.array(valibot.number()))),
+	broadcast: valibot.optional(valibot.boolean())
+});
+const bitcoinSignPsbtV2RequestSchema = createRequestSchema({
+	paramsSchema: bitcoinSignPsbtV2ParamsSchema,
+	method: bitcoinMethods.bitcoin_signPsbtV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/signPsbtV2/response.ts
+const bitcoinSignPsbtV2ResultSchema = valibot.object({
+	psbt: valibot.string(),
+	txid: valibot.optional(valibot.string())
+});
+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,
+	bitcoinGetAccountsV2RequestSchema,
+	bitcoinGetAddressesRequestSchema,
+	bitcoinGetAddressesV2RequestSchema,
+	bitcoinGetBalanceRequestSchema,
+	bitcoinGetBalanceV2RequestSchema,
+	bitcoinGetInfoRequestSchema,
+	bitcoinGetInfoV2RequestSchema,
+	bitcoinSendTransferRequestSchema,
+	bitcoinSendTransferV2RequestSchema,
+	bitcoinSignMessageRequestSchema,
+	bitcoinSignMessageV2RequestSchema,
+	bitcoinSignMultipleMessagesRequestSchema,
+	bitcoinSignMultipleMessagesV2RequestSchema,
+	bitcoinSignPsbtRequestSchema,
+	bitcoinSignPsbtV2RequestSchema
+]);
+const bitcoinSuccessResponseSchema = valibot.variant("~sats-connect-method", [
+	bitcoinGetAccountsSuccessResponseSchema,
+	bitcoinGetAccountsV2SuccessResponseSchema,
+	bitcoinGetAddressesSuccessResponseSchema,
+	bitcoinGetAddressesV2SuccessResponseSchema,
+	bitcoinGetBalanceSuccessResponseSchema,
+	bitcoinGetBalanceV2SuccessResponseSchema,
+	bitcoinGetInfoSuccessResponseSchema,
+	bitcoinGetInfoV2SuccessResponseSchema,
+	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/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$2 = valibot.object({ read: valibot.optional(valibot.boolean()) });
+const walletActionsSchema$2 = valibot.object({ readNetwork: valibot.optional(valibot.boolean()) });
+const accountPermissionSchema$1 = valibot.object({
+	type: valibot.literal("account"),
+	resourceId: valibot.string(),
+	clientId: valibot.string(),
+	actions: accountActionsSchema$2
+});
+const walletPermissionSchema$1 = valibot.object({
+	type: valibot.literal("wallet"),
+	resourceId: valibot.string(),
+	clientId: valibot.string(),
+	actions: walletActionsSchema$2
+});
+const permissionSchema$1 = valibot.variant("type", [accountPermissionSchema$1, walletPermissionSchema$1]);
+/**
+* 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$1, ["clientId"]).entries }), valibot.object({ ...valibot.omit(walletPermissionSchema$1, ["clientId"]).entries })]);
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/addNetworkV2/request.ts
+const walletAddNetworkV2ParamsSchema = valibot.object({
+	network: networkConfigurationOptionsSchema,
+	isActive: valibot.optional(valibot.boolean())
+});
+const walletAddNetworkV2RequestSchema = createRequestSchema({
+	paramsSchema: walletAddNetworkV2ParamsSchema,
+	method: walletMethods.wallet_addNetworkV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/addNetworkV2/response.ts
+const walletAddNetworkV2ResultSchema = valibot.object({ id: valibot.string() });
+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.picklist([
+	"Mainnet",
+	"Testnet",
+	"Signet"
+]) });
+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/changeNetworkById/request.ts
+const walletChangeNetworkByIdParamsSchema = valibot.object({ id: valibot.string() });
+const walletChangeNetworkByIdRequestSchema = createRequestSchema({
+	paramsSchema: walletChangeNetworkByIdParamsSchema,
+	method: walletMethods.wallet_changeNetworkById
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/changeNetworkById/response.ts
+const walletChangeNetworkByIdResultSchema = valibot.nullish(valibot.null());
+const walletChangeNetworkByIdSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: walletChangeNetworkByIdResultSchema,
+	method: walletMethods.wallet_changeNetworkById
+});
+
+//#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,
+	addresses: valibot.optional(valibot.array(valibot.enum(AddressPurpose))),
+	message: valibot.optional(valibot.pipe(valibot.string(), valibot.maxLength(80, "The message must not exceed 80 characters."))),
+	networkId: valibot.optional(valibot.string())
+}));
+const 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 accountActionsSchema$1 = valibot.object({ read: valibot.optional(valibot.boolean()) });
+const walletActionsSchema$1 = valibot.object({ readNetwork: valibot.optional(valibot.boolean()) });
+const accountPermissionSchema = valibot.object({
+	type: valibot.literal("account"),
+	resourceId: valibot.string(),
+	clientId: valibot.string(),
+	actions: accountActionsSchema$1
+});
+const walletPermissionSchema = valibot.object({
+	type: valibot.literal("wallet"),
+	resourceId: valibot.string(),
+	clientId: valibot.string(),
+	actions: walletActionsSchema$1
+});
+const permissionSchema = valibot.variant("type", [accountPermissionSchema, walletPermissionSchema]);
+const walletGetCurrentPermissionsResultSchema = valibot.array(permissionSchema);
+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 accountActionsSchema = valibot.object({ read: valibot.optional(valibot.boolean()) });
+const walletActionsSchema = valibot.object({ readNetwork: valibot.optional(valibot.boolean()) });
+const accountPermissionRequestSchema = valibot.object({
+	type: valibot.literal("account"),
+	resourceId: valibot.string(),
+	actions: accountActionsSchema
+});
+const walletPermissionRequestSchema = valibot.object({
+	type: valibot.literal("wallet"),
+	resourceId: valibot.string(),
+	actions: walletActionsSchema
+});
+const permissionRequestParamsSchema$1 = valibot.variant("type", [accountPermissionRequestSchema, walletPermissionRequestSchema]);
+const walletRequestPermissionsParamsSchema = valibot.nullish(valibot.array(permissionRequestParamsSchema$1));
+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/index.ts
+const walletRequestSchema = valibot.variant("method", [
+	walletAddNetworkRequestSchema,
+	walletAddNetworkV2RequestSchema,
+	walletChangeNetworkByIdRequestSchema,
+	walletChangeNetworkRequestSchema,
+	walletConnectRequestSchema,
+	walletConnectV2RequestSchema,
+	walletDisconnectRequestSchema,
+	walletGetAccountRequestSchema,
+	walletGetAccountV2RequestSchema,
+	walletGetCurrentPermissionsRequestSchema,
+	walletGetNetworkRequestSchema,
+	walletGetNetworksRequestSchema,
+	walletGetWalletTypeRequestSchema,
+	walletOpenBridgeRequestSchema,
+	walletOpenBuyRequestSchema,
+	walletOpenReceiveRequestSchema,
+	walletRenouncePermissionsRequestSchema,
+	walletRequestPermissionsRequestSchema
+]);
+const walletSuccessResponseSchema = valibot.variant("~sats-connect-method", [
+	walletAddNetworkSuccessResponseSchema,
+	walletAddNetworkV2SuccessResponseSchema,
+	walletChangeNetworkByIdSuccessResponseSchema,
+	walletChangeNetworkSuccessResponseSchema,
+	walletConnectSuccessResponseSchema,
+	walletConnectV2SuccessResponseSchema,
+	walletDisconnectSuccessResponseSchema,
+	walletGetAccountSuccessResponseSchema,
+	walletGetAccountV2SuccessResponseSchema,
+	walletGetCurrentPermissionsSuccessResponseSchema,
+	walletGetNetworkSuccessResponseSchema,
+	walletGetNetworksSuccessResponseSchema,
+	walletGetWalletTypeSuccessResponseSchema,
+	walletOpenBridgeSuccessResponseSchema,
+	walletOpenBuySuccessResponseSchema,
+	walletOpenReceiveSuccessResponseSchema,
+	walletRenouncePermissionsSuccessResponseSchema,
+	walletRequestPermissionsSuccessResponseSchema
+]);
+
+//#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/getAddressesV2/request.ts
+const stacksGetAddressesV2ParamsSchema = valibot.nullish(valibot.object({ message: valibot.optional(valibot.string()) }));
+const stacksGetAddressesV2RequestSchema = createRequestSchema({
+	paramsSchema: stacksGetAddressesV2ParamsSchema,
+	method: stacksMethods.stacks_getAddressesV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/stacks/methods/getAddressesV2/response.ts
+const stacksGetAddressesV2ResultSchema = valibot.object({
+	addresses: valibot.array(addressSchema),
+	network: valibot.object({
+		type: valibot.union([
+			valibot.literal("Mainnet"),
+			valibot.literal("Testnet"),
+			valibot.literal("Devnet"),
+			valibot.literal("Signet")
+		]),
+		chain: valibot.union([valibot.literal("bitcoin"), valibot.literal("stacks")])
+	})
+});
+const stacksGetAddressesV2SuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: stacksGetAddressesV2ResultSchema,
+	method: stacksMethods.stacks_getAddressesV2
+});
+
+//#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((hex) => {
+		return true;
+	}, "Invalid hex-encoded Stacks transaction."))), valibot.minLength(1)),
+	broadcast: valibot.optional(valibot.boolean())
+});
+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,
+	stacksGetAddressesV2RequestSchema,
+	stacksSignMessageRequestSchema,
+	stacksSignStructuredMessageRequestSchema,
+	stacksSignTransactionRequestSchema,
+	stacksSignTransactionsRequestSchema,
+	stacksTransferStxRequestSchema
+]);
+const stacksSuccessResponseSchema = valibot.variant("~sats-connect-method", [
+	stacksCallContractSuccessResponseSchema,
+	stacksDeployContractSuccessResponseSchema,
+	stacksGetAccountsSuccessResponseSchema,
+	stacksGetAddressesSuccessResponseSchema,
+	stacksGetAddressesV2SuccessResponseSchema,
+	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
@@ -940,182 +3275,6 @@ var XverseAdapter = class extends SatsConnectAdapter {
 	};
 };
 
-//#endregion
-//#region src/adapters/unisat.ts
-function convertSignInputsToInputType(signInputs) {
-	let result = [];
-	if (!signInputs) return result;
-	for (let address in signInputs) {
-		let indexes = signInputs[address];
-		for (let index of indexes) result.push({
-			index,
-			address
-		});
-	}
-	return result;
-}
-var UnisatAdapter = class extends SatsConnectAdapter {
-	id = DefaultAdaptersInfo.unisat.id;
-	async getAccounts(params) {
-		const { purposes } = params;
-		if (purposes.includes(AddressPurpose.Stacks) || purposes.includes(AddressPurpose.Starknet) || purposes.includes(AddressPurpose.Spark)) throw new Error("Only bitcoin addresses are supported");
-		const accounts = await window.unisat.requestAccounts();
-		const publicKey = await window.unisat.getPublicKey();
-		const address = accounts[0];
-		const addressType = (0, bitcoin_address_validation.getAddressInfo)(accounts[0]).type;
-		const pk = addressType === bitcoin_address_validation.AddressType.p2tr ? publicKey.slice(2) : publicKey;
-		const paymentAddress = {
-			address,
-			publicKey: pk,
-			addressType,
-			purpose: AddressPurpose.Payment,
-			walletType: "software"
-		};
-		const ordinalsAddress = {
-			address,
-			publicKey: pk,
-			addressType,
-			purpose: AddressPurpose.Ordinals,
-			walletType: "software"
-		};
-		const response = [];
-		if (purposes.includes(AddressPurpose.Payment)) response.push({
-			...paymentAddress,
-			walletType: "software"
-		});
-		if (purposes.includes(AddressPurpose.Ordinals)) response.push({
-			...ordinalsAddress,
-			walletType: "software"
-		});
-		return response;
-	}
-	async signMessage(params) {
-		const { message, address } = params;
-		const addressType = (0, bitcoin_address_validation.getAddressInfo)(address).type;
-		if ([bitcoin_address_validation.AddressType.p2wpkh, bitcoin_address_validation.AddressType.p2tr].includes(addressType)) return {
-			address,
-			messageHash: "",
-			signature: await window.unisat.signMessage(message, "bip322-simple"),
-			protocol: MessageSigningProtocols.BIP322
-		};
-		return {
-			address,
-			messageHash: "",
-			signature: await window.unisat.signMessage(message, "ecdsa"),
-			protocol: MessageSigningProtocols.ECDSA
-		};
-	}
-	async sendTransfer(params) {
-		const { recipients } = params;
-		if (recipients.length > 1) throw new Error("Only one recipient is supported by this wallet provider");
-		return { txid: await window.unisat.sendBitcoin(recipients[0].address, recipients[0].amount) };
-	}
-	async signPsbt(params) {
-		const { psbt, signInputs, broadcast } = params;
-		const psbtHex = buffer.Buffer.from(psbt, "base64").toString("hex");
-		const signedPsbt = await window.unisat.signPsbt(psbtHex, {
-			autoFinalized: broadcast,
-			toSignInputs: convertSignInputsToInputType(signInputs)
-		});
-		const signedPsbtBase64 = buffer.Buffer.from(signedPsbt, "hex").toString("base64");
-		let txid;
-		if (broadcast) txid = await window.unisat.pushPsbt(signedPsbt);
-		return {
-			psbt: signedPsbtBase64,
-			txid
-		};
-	}
-	requestInternal = async (method, params) => {
-		try {
-			switch (method) {
-				case "getAccounts": return {
-					status: "success",
-					result: await this.getAccounts(params)
-				};
-				case "sendTransfer": return {
-					status: "success",
-					result: await this.sendTransfer(params)
-				};
-				case "signMessage": return {
-					status: "success",
-					result: await this.signMessage(params)
-				};
-				case "signPsbt": return {
-					status: "success",
-					result: await this.signPsbt(params)
-				};
-				default: {
-					const error = {
-						code: RpcErrorCode.METHOD_NOT_SUPPORTED,
-						message: "Method not supported by the selected wallet"
-					};
-					console.error("Error calling the method", error);
-					return {
-						status: "error",
-						error
-					};
-				}
-			}
-		} catch (error) {
-			console.error("Error calling the method", error);
-			return {
-				status: "error",
-				error: {
-					code: error.code === 4001 ? RpcErrorCode.USER_REJECTION : RpcErrorCode.INTERNAL_ERROR,
-					message: error.message ? error.message : "Wallet method call error",
-					data: error
-				}
-			};
-		}
-	};
-	addListener = ({ eventName, cb }) => {
-		switch (eventName) {
-			case "accountChange": {
-				const handler = () => {
-					cb({ type: "accountChange" });
-				};
-				window.unisat.on("accountsChanged", handler);
-				return () => {
-					window.unisat.removeListener("accountsChanged", handler);
-				};
-			}
-			case "networkChange": {
-				const handler = () => {
-					cb({ type: "networkChange" });
-				};
-				window.unisat.on("networkChanged", handler);
-				return () => {
-					window.unisat.removeListener("networkChanged", handler);
-				};
-			}
-			default:
-				console.error("Event not supported by the selected wallet");
-				return () => {};
-		}
-	};
-};
-
-//#endregion
-//#region src/adapters/fordefi.ts
-var FordefiAdapter = class extends SatsConnectAdapter {
-	id = DefaultAdaptersInfo.fordefi.id;
-	requestInternal = async (method, params) => {
-		const provider = getProviderById(this.id);
-		if (!provider) throw new Error("no wallet provider was found");
-		if (!method) throw new Error("A wallet method is required");
-		return await provider.request(method, params);
-	};
-	addListener = ({ eventName, cb }) => {
-		const provider = getProviderById(this.id);
-		if (!provider) throw new Error("no wallet provider was found");
-		if (!provider.addListener) {
-			console.error(`The wallet provider you are using does not support the addListener method. Please update your wallet provider.`);
-			return () => {};
-		}
-		return provider.addListener(eventName, cb);
-	};
-};
-
 //#endregion
 //#region src/adapters/BaseAdapter.ts
 var BaseAdapter = class extends SatsConnectAdapter {
@@ -1301,35 +3460,35 @@ const sendBtcTransaction = async (options) => {
 };
 
 //#endregion
-//#region src/transactions/signTransaction.ts
-const signTransaction = async (options) => {
+//#region src/transactions/signMultipleTransactions.ts
+const signMultipleTransactions = 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");
+	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.signTransaction(request$1);
+		const response = await provider.signMultipleTransactions(request$1);
 		options.onFinish?.(response);
 	} catch (error) {
-		console.error("[Connect] Error during sign transaction request", error);
+		console.error("[Connect] Error during sign Multiple transactions request", error);
 		options.onCancel?.();
 	}
 };
 
 //#endregion
-//#region src/transactions/signMultipleTransactions.ts
-const signMultipleTransactions = async (options) => {
+//#region src/transactions/signTransaction.ts
+const signTransaction = 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");
+	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.signMultipleTransactions(request$1);
+		const response = await provider.signTransaction(request$1);
 		options.onFinish?.(response);
 	} catch (error) {
-		console.error("[Connect] Error during sign Multiple transactions request", error);
+		console.error("[Connect] Error during sign transaction request", error);
 		options.onCancel?.();
 	}
 };
@@ -1337,23 +3496,136 @@ const signMultipleTransactions = async (options) => {
 //#endregion
 exports.AddressPurpose = AddressPurpose;
 exports.AddressType = AddressType;
+Object.defineProperty(exports, 'AllResolvedNetworks', {
+  enumerable: true,
+  get: function () {
+    return AllResolvedNetworks;
+  }
+});
 exports.BaseAdapter = BaseAdapter;
+Object.defineProperty(exports, 'BitcoinNetworkConfigurationOptions', {
+  enumerable: true,
+  get: function () {
+    return BitcoinNetworkConfigurationOptions;
+  }
+});
 exports.BitcoinNetworkType = BitcoinNetworkType;
 exports.DefaultAdaptersInfo = DefaultAdaptersInfo;
 exports.MessageSigningProtocols = MessageSigningProtocols;
+Object.defineProperty(exports, 'NetworkConfigurationOptions', {
+  enumerable: true,
+  get: function () {
+    return NetworkConfigurationOptions;
+  }
+});
+Object.defineProperty(exports, 'PermissionWithoutClientId', {
+  enumerable: true,
+  get: function () {
+    return PermissionWithoutClientId;
+  }
+});
 exports.ProviderPlatform = ProviderPlatform;
 exports.RpcErrorCode = RpcErrorCode;
-exports.RpcIdSchema = RpcIdSchema;
 exports.SatsConnectAdapter = SatsConnectAdapter;
+Object.defineProperty(exports, 'SparkNetworkConfigurationOptions', {
+  enumerable: true,
+  get: function () {
+    return SparkNetworkConfigurationOptions;
+  }
+});
 exports.SparkNetworkType = SparkNetworkType;
+Object.defineProperty(exports, 'StacksNetworkConfigurationOptions', {
+  enumerable: true,
+  get: function () {
+    return StacksNetworkConfigurationOptions;
+  }
+});
 exports.StacksNetworkType = StacksNetworkType;
+Object.defineProperty(exports, 'StarknetNetworkConfigurationOptions', {
+  enumerable: true,
+  get: function () {
+    return StarknetNetworkConfigurationOptions;
+  }
+});
 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.bitcoinGetAccountsV2ParamsSchema = bitcoinGetAccountsV2ParamsSchema;
+exports.bitcoinGetAccountsV2RequestSchema = bitcoinGetAccountsV2RequestSchema;
+exports.bitcoinGetAccountsV2ResultSchema = bitcoinGetAccountsV2ResultSchema;
+exports.bitcoinGetAccountsV2SuccessResponseSchema = bitcoinGetAccountsV2SuccessResponseSchema;
+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.bitcoinGetInfoV2ParamsSchema = bitcoinGetInfoV2ParamsSchema;
+exports.bitcoinGetInfoV2RequestSchema = bitcoinGetInfoV2RequestSchema;
+exports.bitcoinGetInfoV2ResultSchema = bitcoinGetInfoV2ResultSchema;
+exports.bitcoinGetInfoV2SuccessResponseSchema = bitcoinGetInfoV2SuccessResponseSchema;
+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;
@@ -1365,19 +3637,258 @@ exports.getProviderOrThrow = getProviderOrThrow;
 exports.getProviders = getProviders;
 exports.getSupportedWallets = getSupportedWallets;
 exports.isProviderInstalled = isProviderInstalled;
+exports.methodSupport = methodSupport;
 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.rpcErrorResponseMessageSchema = rpcErrorResponseMessageSchema;
-exports.rpcRequestMessageSchema = rpcRequestMessageSchema;
-exports.rpcResponseMessageSchema = rpcResponseMessageSchema;
-exports.rpcSuccessResponseMessageSchema = rpcSuccessResponseMessageSchema;
+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.walletEventSchema = walletEventSchema;
+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.stacksGetAddressesV2ParamsSchema = stacksGetAddressesV2ParamsSchema;
+exports.stacksGetAddressesV2RequestSchema = stacksGetAddressesV2RequestSchema;
+exports.stacksGetAddressesV2ResultSchema = stacksGetAddressesV2ResultSchema;
+exports.stacksGetAddressesV2SuccessResponseSchema = stacksGetAddressesV2SuccessResponseSchema;
+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.walletChangeNetworkByIdParamsSchema = walletChangeNetworkByIdParamsSchema;
+exports.walletChangeNetworkByIdRequestSchema = walletChangeNetworkByIdRequestSchema;
+exports.walletChangeNetworkByIdResultSchema = walletChangeNetworkByIdResultSchema;
+exports.walletChangeNetworkByIdSuccessResponseSchema = walletChangeNetworkByIdSuccessResponseSchema;
+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.walletTypeSchema = walletTypeSchema;
+exports.walletTypes = walletTypes;