@sats-connect/core 0.16.0-072a7fa → 0.16.0-0cb8d67

package/dist/index.mjs

@@ -3,8 +3,108 @@ import { createUnsecuredToken } from "jsontokens";
 import axios from "axios";
 import { AddressType as AddressType$1, getAddressInfo } from "bitcoin-address-validation";
 import { Buffer } from "buffer";
+import { match } from "ts-pattern";
+
+//#region src/request/rpc/objects/namespaces/wallet/shared/networks.ts
+const networkConfigurationChains = {
+	bitcoin: "bitcoin",
+	spark: "spark",
+	stacks: "stacks",
+	starknet: "starknet"
+};
+const networkConfigurationChainSchema = v.enum(networkConfigurationChains);
+const networkConfigurationSources = {
+	builtin: "builtin",
+	custom: "custom"
+};
+const networkConfigurationSourceSchema = v.enum(networkConfigurationSources);
+const commonNetworkConfigurationSchema = v.object({
+	id: v.string(),
+	name: v.string(),
+	mode: v.picklist([]),
+	source: networkConfigurationSourceSchema,
+	blockExplorerUrl: v.optional(v.union([v.pipe(v.literal(""), v.transform(() => void 0)), v.pipe(v.string(), v.url())]))
+});
+const bitcoinChainModeSchema = v.pipe(v.string(), v.enum({
+	mainnet: "mainnet",
+	testnet: "testnet",
+	testnet4: "testnet4",
+	signet: "signet",
+	regtest: "regtest"
+}));
+const bitcoinNetworkConfigurationSchema = v.object({
+	...commonNetworkConfigurationSchema.entries,
+	chain: v.literal(networkConfigurationChains.bitcoin),
+	mode: bitcoinChainModeSchema,
+	xverseApiUrl: v.pipe(v.string(), v.url()),
+	electrsApiUrl: v.pipe(v.string(), v.url())
+});
+const sparkChainMode = {
+	mainnet: "mainnet",
+	regtest: "regtest"
+};
+const sparkChainModeSchema = v.pipe(v.string(), v.enum(sparkChainMode));
+const sparkNetworkConfigurationSchema = v.object({
+	...commonNetworkConfigurationSchema.entries,
+	chain: v.literal(networkConfigurationChains.spark),
+	mode: sparkChainModeSchema,
+	electrsApiUrl: v.pipe(v.string(), v.url())
+});
+const stacksChainMode = {
+	mainnet: "mainnet",
+	testnet: "testnet",
+	devnet: "devnet",
+	mocknet: "mocknet"
+};
+const stacksChainModeSchema = v.pipe(v.string(), v.enum(stacksChainMode));
+const stacksNetworkConfigurationSchema = v.object({
+	...commonNetworkConfigurationSchema.entries,
+	chain: v.literal(networkConfigurationChains.stacks),
+	mode: stacksChainModeSchema,
+	stacksApiUrl: v.pipe(v.string(), v.url()),
+	xverseApiUrl: v.pipe(v.string(), v.url())
+});
+const starknetChainMode = {
+	mainnet: "mainnet",
+	sepolia: "sepolia"
+};
+const starknetChainModeSchema = v.pipe(v.string(), v.enum(starknetChainMode));
+const starknetNetworkConfigurationSchema = v.object({
+	...commonNetworkConfigurationSchema.entries,
+	chain: v.literal(networkConfigurationChains.starknet),
+	mode: starknetChainModeSchema,
+	rpcApiUrl: v.pipe(v.string(), v.url()),
+	xverseApiUrl: v.pipe(v.string(), v.url())
+});
+const networkConfigurationSchema = v.variant("chain", [
+	bitcoinNetworkConfigurationSchema,
+	sparkNetworkConfigurationSchema,
+	stacksNetworkConfigurationSchema,
+	starknetNetworkConfigurationSchema
+]);
+const omitFields = ["id", "source"];
+const bitcoinNetworkConfigurationOptionsSchema = v.omit(bitcoinNetworkConfigurationSchema, omitFields);
+const sparkNetworkConfigurationOptionsSchema = v.omit(sparkNetworkConfigurationSchema, omitFields);
+const stacksNetworkConfigurationOptionsSchema = v.omit(stacksNetworkConfigurationSchema, omitFields);
+const starknetNetworkConfigurationOptionsSchema = v.omit(starknetNetworkConfigurationSchema, omitFields);
+const networkConfigurationOptionsSchema = v.variant("chain", [
+	bitcoinNetworkConfigurationOptionsSchema,
+	sparkNetworkConfigurationOptionsSchema,
+	stacksNetworkConfigurationOptionsSchema,
+	starknetNetworkConfigurationOptionsSchema
+]);
+const allResolvedNetworksSchema = v.object({
+	active: v.object({
+		bitcoin: bitcoinNetworkConfigurationSchema,
+		spark: sparkNetworkConfigurationSchema,
+		stacks: stacksNetworkConfigurationSchema,
+		starknet: starknetNetworkConfigurationSchema
+	}),
+	all: v.array(networkConfigurationSchema)
+});
 
-//#region src/request/types/common.ts
+//#endregion
+//#region src/request/rpc/objects/shared/index.ts
 const walletTypes = [
 	"software",
 	"ledger",
@@ -85,21 +185,6 @@ let SparkNetworkType = /* @__PURE__ */ function(SparkNetworkType$1) {
 	SparkNetworkType$1["Regtest"] = "regtest";
 	return SparkNetworkType$1;
 }({});
-const RpcIdSchema = v.optional(v.union([
-	v.string(),
-	v.number(),
-	v.null()
-]));
-const rpcRequestMessageSchema = v.object({
-	jsonrpc: v.literal("2.0"),
-	method: v.string(),
-	params: v.optional(v.union([
-		v.array(v.unknown()),
-		v.looseObject({}),
-		v.null()
-	])),
-	id: v.unwrap(RpcIdSchema)
-});
 /**
 * @enum {number} RpcErrorCode
 * @description JSON-RPC error codes
@@ -141,83 +226,6 @@ let RpcErrorCode = /* @__PURE__ */ function(RpcErrorCode$1) {
 	RpcErrorCode$1[RpcErrorCode$1["ACCESS_DENIED"] = -32002] = "ACCESS_DENIED";
 	return RpcErrorCode$1;
 }({});
-const rpcSuccessResponseMessageSchema = v.object({
-	jsonrpc: v.literal("2.0"),
-	result: v.nonOptional(v.unknown()),
-	id: RpcIdSchema
-});
-const rpcErrorResponseMessageSchema = v.object({
-	jsonrpc: v.literal("2.0"),
-	error: v.nonOptional(v.unknown()),
-	id: RpcIdSchema
-});
-const rpcResponseMessageSchema = v.union([rpcSuccessResponseMessageSchema, rpcErrorResponseMessageSchema]);
-
-//#endregion
-//#region src/request/types/walletMethods/utils.ts
-const commonNetworkConfigurationSchema = v.object({
-	id: v.string(),
-	name: v.string(),
-	mode: v.picklist([]),
-	blockExplorerUrl: v.optional(v.union([v.pipe(v.literal(""), v.transform(() => void 0)), v.pipe(v.string(), v.url())]))
-});
-const bitcoinChainModeSchema = v.enum({
-	mainnet: "mainnet",
-	testnet: "testnet",
-	testnet4: "testnet4",
-	signet: "signet",
-	regtest: "regtest"
-});
-const bitcoinNetworkConfigurationSchema = v.object({
-	chain: v.literal("bitcoin"),
-	...commonNetworkConfigurationSchema.entries,
-	mode: v.pipe(v.string(), bitcoinChainModeSchema),
-	xverseApiUrl: v.pipe(v.string(), v.url()),
-	electrsApiUrl: v.pipe(v.string(), v.url())
-});
-const sparkChainMode = {
-	mainnet: "mainnet",
-	regtest: "regtest"
-};
-const sparkChainModeSchema = v.enum(sparkChainMode);
-const sparkNetworkConfigurationSchema = v.object({
-	chain: v.literal("spark"),
-	...commonNetworkConfigurationSchema.entries,
-	mode: v.pipe(v.string(), sparkChainModeSchema),
-	electrsApiUrl: v.pipe(v.string(), v.url())
-});
-const stacksChainMode = {
-	mainnet: "mainnet",
-	testnet: "testnet",
-	devnet: "devnet",
-	mocknet: "mocknet"
-};
-const stacksChainModeSchema = v.enum(stacksChainMode);
-const stacksNetworkConfigurationSchema = v.object({
-	chain: v.literal("stacks"),
-	...commonNetworkConfigurationSchema.entries,
-	mode: v.pipe(v.string(), stacksChainModeSchema),
-	stacksApiUrl: v.pipe(v.string(), v.url()),
-	xverseApiUrl: v.pipe(v.string(), v.url())
-});
-const starknetChainMode = {
-	mainnet: "mainnet",
-	sepolia: "sepolia"
-};
-const starknetChainModeSchema = v.enum(starknetChainMode);
-const starknetNetworkConfigurationSchema = v.object({
-	chain: v.literal("starknet"),
-	...commonNetworkConfigurationSchema.entries,
-	mode: v.pipe(v.string(), starknetChainModeSchema),
-	rpcApiUrl: v.pipe(v.string(), v.url()),
-	xverseApiUrl: v.pipe(v.string(), v.url())
-});
-const networkConfigurationSchema = v.variant("chain", [
-	bitcoinNetworkConfigurationSchema,
-	sparkNetworkConfigurationSchema,
-	stacksNetworkConfigurationSchema,
-	starknetNetworkConfigurationSchema
-]);
 
 //#endregion
 //#region src/provider/types.ts
@@ -288,748 +296,1634 @@ 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.create({ baseURL: ORDINALS_API_BASE_URL(network) });
 	}
-	if (method === "getAddresses") {
-		const { purposes, ...rest } = params;
+	parseError = (error) => {
 		return {
-			method,
-			params: {
-				...rest,
-				purposes: filterPurposes(purposes)
-			}
+			code: error.response?.status,
+			message: JSON.stringify(error.response?.data)
 		};
-	}
-	return {
-		method,
-		params
 	};
-};
-
-//#endregion
-//#region src/request/types/bitcoinMethods/common.ts
-let MessageSigningProtocols = /* @__PURE__ */ function(MessageSigningProtocols$1) {
-	MessageSigningProtocols$1["ECDSA"] = "ECDSA";
-	MessageSigningProtocols$1["BIP322"] = "BIP322";
-	return MessageSigningProtocols$1;
-}({});
-
-//#endregion
-//#region src/request/types/bitcoinMethods/getAccounts.ts
-const getAccountsMethodName = "getAccounts";
-const getAccountsParamsSchema = v.object({
-	purposes: v.array(v.enum(AddressPurpose)),
-	message: v.optional(v.string())
-});
-const getAccountsResultSchema = v.array(v.object({
-	...addressSchema.entries,
-	...v.object({ walletType: walletTypeSchema }).entries
-}));
-const getAccountsRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(getAccountsMethodName),
-		params: getAccountsParamsSchema,
-		id: v.string()
-	}).entries
-});
-const bitcoinGetAccountsV2MethodName = "bitcoin_getAccountsV2";
-const bitcoinGetAccountsV2ParamsSchema = v.object({
-	purposes: v.array(v.enum(AddressPurpose)),
-	message: v.optional(v.string())
-});
-const bitcoinGetAccountsV2ResultSchema = v.array(v.object({
-	...addressSchema.entries,
-	...v.object({ walletType: walletTypeSchema }).entries
-}));
-const bitcoinGetAccountsV2RequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(bitcoinGetAccountsV2MethodName),
-		params: bitcoinGetAccountsV2ParamsSchema,
-		id: v.string()
-	}).entries
-});
-
-//#endregion
-//#region src/request/types/walletMethods/addNetwork.ts
-const addNetworkMethodName = "wallet_addNetwork";
-const addNetworkParamsSchema = v.variant("chain", [
-	v.object({
-		chain: v.literal("bitcoin"),
-		type: v.enum(BitcoinNetworkType),
-		name: v.string(),
-		rpcUrl: v.string(),
-		rpcFallbackUrl: v.optional(v.string()),
-		indexerUrl: v.optional(v.string()),
-		blockExplorerUrl: v.optional(v.string()),
-		switch: v.optional(v.boolean())
-	}),
-	v.object({
-		chain: v.literal("stacks"),
-		name: v.string(),
-		type: v.enum(StacksNetworkType),
-		rpcUrl: v.string(),
-		blockExplorerUrl: v.optional(v.string()),
-		switch: v.optional(v.boolean())
-	}),
-	v.object({
-		chain: v.literal("starknet"),
-		name: v.string(),
-		type: v.enum(StarknetNetworkType),
-		rpcUrl: v.string(),
-		blockExplorerUrl: v.optional(v.string()),
-		switch: v.optional(v.boolean())
-	})
-]);
-const addNetworkRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(addNetworkMethodName),
-		params: addNetworkParamsSchema,
-		id: v.string()
-	}).entries
-});
-const addNetworkResultSchema = v.object({ id: v.string() });
-const addNetworkV2MethodName = "wallet_addNetworkV2";
-const bitcoinNetworkConfigurationOptionsSchema = v.omit(bitcoinNetworkConfigurationSchema, ["id"]);
-const sparkNetworkConfigurationOptionsSchema = v.omit(sparkNetworkConfigurationSchema, ["id"]);
-const stacksNetworkConfigurationOptionsSchema = v.omit(stacksNetworkConfigurationSchema, ["id"]);
-const starknetNetworkConfigurationOptionsSchema = v.omit(starknetNetworkConfigurationSchema, ["id"]);
-const networkConfigurationOptionsSchema = v.variant("chain", [
-	bitcoinNetworkConfigurationOptionsSchema,
-	sparkNetworkConfigurationOptionsSchema,
-	stacksNetworkConfigurationOptionsSchema,
-	starknetNetworkConfigurationOptionsSchema
-]);
-const addNetworkV2ParamsSchema = v.object({
-	network: networkConfigurationOptionsSchema,
-	isActive: v.optional(v.boolean())
-});
-const addNetworkV2RequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(addNetworkV2MethodName),
-		params: addNetworkV2ParamsSchema,
-		id: v.string()
-	}).entries
-});
-const addNetworkV2ResultSchema = v.object({ id: v.string() });
-
-//#endregion
-//#region src/request/types/walletMethods/changeNetwork.ts
-const changeNetworkMethodName = "wallet_changeNetwork";
-const changeNetworkParamsSchema = v.object({ name: v.enum(BitcoinNetworkType) });
-const changeNetworkResultSchema = v.nullish(v.null());
-const changeNetworkRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(changeNetworkMethodName),
-		params: changeNetworkParamsSchema,
-		id: v.string()
-	}).entries
-});
-
-//#endregion
-//#region src/request/types/walletMethods/changeNetworkById.ts
-const changeNetworkByIdMethodName = "wallet_changeNetworkById";
-const changeNetworkByIdParamsSchema = v.object({ id: v.string() });
-const changeNetworkByIdResultSchema = v.nullish(v.null());
-const changeNetworkByIdRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(changeNetworkByIdMethodName),
-		params: changeNetworkByIdParamsSchema,
-		id: v.string()
-	}).entries
-});
-
-//#endregion
-//#region src/request/types/walletMethods/common.ts
-const accountActionsSchema = v.object({ read: v.optional(v.boolean()) });
-const walletActionsSchema = v.object({ readNetwork: v.optional(v.boolean()) });
-const accountPermissionSchema = v.object({
-	type: v.literal("account"),
-	resourceId: v.string(),
-	clientId: v.string(),
-	actions: accountActionsSchema
-});
-const walletPermissionSchema = v.object({
-	type: v.literal("wallet"),
-	resourceId: v.string(),
-	clientId: v.string(),
-	actions: walletActionsSchema
-});
-/**
-* Permissions with the clientId field omitted and optional actions. Used for
-* permission requests, since the wallet performs authentication based on the
-* client's tab origin and should not rely on the client authenticating
-* themselves.
-*/
-const PermissionRequestParams = v.variant("type", [v.object({ ...v.omit(accountPermissionSchema, ["clientId"]).entries }), v.object({ ...v.omit(walletPermissionSchema, ["clientId"]).entries })]);
-const permission = v.variant("type", [accountPermissionSchema, walletPermissionSchema]);
-
-//#endregion
-//#region src/request/types/walletMethods/getNetwork.ts
-const getNetworkMethodName = "wallet_getNetwork";
-const getNetworkParamsSchema = v.nullish(v.null());
-const getNetworkResultSchema = v.object({
-	bitcoin: v.object({ name: v.enum(BitcoinNetworkType) }),
-	stacks: v.object({ name: v.enum(StacksNetworkType) }),
-	spark: v.object({ name: v.enum(SparkNetworkType) })
-});
-const getNetworkRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(getNetworkMethodName),
-		params: getNetworkParamsSchema,
-		id: v.string()
-	}).entries
-});
-
-//#endregion
-//#region src/request/types/walletMethods/getNetworks.ts
-const getNetworksMethodName = "wallet_getNetworks";
-const getNetworksParamsSchema = v.nullish(v.null());
-const getNetworksResultSchema = v.object({
-	active: v.object({
-		bitcoin: bitcoinNetworkConfigurationSchema,
-		stacks: stacksNetworkConfigurationSchema,
-		spark: sparkNetworkConfigurationSchema,
-		starknet: starknetNetworkConfigurationSchema
-	}),
-	builtin: v.object({
-		bitcoin: v.array(bitcoinNetworkConfigurationSchema),
-		stacks: v.array(stacksNetworkConfigurationSchema),
-		spark: v.array(sparkNetworkConfigurationSchema),
-		starknet: v.array(starknetNetworkConfigurationSchema)
-	}),
-	custom: v.object({
-		bitcoin: v.array(bitcoinNetworkConfigurationSchema),
-		stacks: v.array(stacksNetworkConfigurationSchema),
-		spark: v.array(sparkNetworkConfigurationSchema),
-		starknet: v.array(starknetNetworkConfigurationSchema)
-	})
-});
-const getNetworksRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(getNetworksMethodName),
-		params: getNetworksParamsSchema,
-		id: v.string()
-	}).entries
-});
-
-//#endregion
-//#region src/request/types/walletMethods/connect.ts
-const connectMethodName = "wallet_connect";
-const connectParamsSchema = v.nullish(v.object({
-	permissions: v.optional(v.array(PermissionRequestParams)),
-	addresses: v.optional(v.array(v.enum(AddressPurpose))),
-	message: v.optional(v.pipe(v.string(), v.maxLength(80, "The message must not exceed 80 characters."))),
-	network: v.optional(v.enum(BitcoinNetworkType))
-}));
-const connectResultSchema = v.object({
-	id: v.string(),
-	addresses: v.array(addressSchema),
-	walletType: walletTypeSchema,
-	network: getNetworkResultSchema
-});
-const connectRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(connectMethodName),
-		params: connectParamsSchema,
-		id: v.string()
-	}).entries
-});
-const connectV2MethodName = "wallet_connectV2";
-const connectV2ParamsSchema = v.nullish(v.object({
-	permissions: v.optional(v.array(PermissionRequestParams)),
-	addresses: v.optional(v.array(v.enum(AddressPurpose))),
-	message: v.optional(v.pipe(v.string(), v.maxLength(80, "The message must not exceed 80 characters."))),
-	networkId: v.optional(v.string())
-}));
-const connectV2ResultSchema = v.object({
-	id: v.string(),
-	addresses: v.array(addressSchema),
-	walletType: walletTypeSchema,
-	networks: getNetworksResultSchema
-});
-const connectV2RequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(connectV2MethodName),
-		params: connectV2ParamsSchema,
-		id: v.string()
-	}).entries
-});
-
-//#endregion
-//#region src/request/types/walletMethods/disconnect.ts
-const disconnectMethodName = "wallet_disconnect";
-const disconnectParamsSchema = v.nullish(v.null());
-const disconnectResultSchema = v.nullish(v.null());
-const disconnectRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(disconnectMethodName),
-		params: disconnectParamsSchema,
-		id: v.string()
-	}).entries
-});
-
-//#endregion
-//#region src/request/types/walletMethods/getAccount.ts
-const getAccountMethodName = "wallet_getAccount";
-const getAccountParamsSchema = v.nullish(v.null());
-const getAccountResultSchema = v.object({
-	id: v.string(),
-	addresses: v.array(addressSchema),
-	walletType: walletTypeSchema,
-	network: getNetworkResultSchema
-});
-const getAccountRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(getAccountMethodName),
-		params: getAccountParamsSchema,
-		id: v.string()
-	}).entries
-});
-const getAccountV2MethodName = "wallet_getAccountV2";
-const getAccountV2ParamsSchema = v.nullish(v.null());
-const getAccountV2ResultSchema = v.object({
-	id: v.string(),
-	addresses: v.array(addressSchema),
-	walletType: walletTypeSchema,
-	networks: getNetworksResultSchema
-});
-const getAccountV2RequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(getAccountV2MethodName),
-		params: getAccountV2ParamsSchema,
-		id: v.string()
-	}).entries
-});
-
-//#endregion
-//#region src/request/types/walletMethods/getCurrentPermissions.ts
-const getCurrentPermissionsMethodName = "wallet_getCurrentPermissions";
-const getCurrentPermissionsParamsSchema = v.nullish(v.null());
-const getCurrentPermissionsResultSchema = v.array(permission);
-const getCurrentPermissionsRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(getCurrentPermissionsMethodName),
-		params: getCurrentPermissionsParamsSchema,
-		id: v.string()
-	}).entries
-});
-
-//#endregion
-//#region src/request/types/walletMethods/getWalletType.ts
-const getWalletTypeMethodName = "wallet_getWalletType";
-const getWalletTypeParamsSchema = v.nullish(v.null());
-const getWalletTypeResultSchema = walletTypeSchema;
-const getWalletTypeRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(getWalletTypeMethodName),
-		params: getWalletTypeParamsSchema,
-		id: v.string()
-	}).entries
-});
-
-//#endregion
-//#region src/request/types/walletMethods/openBridge.ts
-const openBridgeMethodName = "wallet_openBridge";
-const openBridgeParamsSchema = v.object({
-	fromAsset: v.string(),
-	toAsset: v.string()
-});
-const openBridgeResultSchema = v.nullish(v.null());
-const openBridgeRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(openBridgeMethodName),
-		params: openBridgeParamsSchema,
-		id: v.string()
-	}).entries
-});
-
-//#endregion
-//#region src/request/types/walletMethods/openBuy.ts
-const openBuyMethodName = "wallet_openBuy";
-const openBuyParamsSchema = v.object({ asset: v.string() });
-const openBuyResultSchema = v.nullish(v.null());
-const openBuyRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(openBuyMethodName),
-		params: openBuyParamsSchema,
-		id: v.string()
-	}).entries
-});
-
-//#endregion
-//#region src/request/types/walletMethods/openReceive.ts
-const openReceiveMethodName = "wallet_openReceive";
-const openReceiveParamsSchema = v.object({ address: v.string() });
-const openReceiveResultSchema = addressSchema;
-const openReceiveRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(openReceiveMethodName),
-		params: openReceiveParamsSchema,
-		id: v.string()
-	}).entries
-});
-
-//#endregion
-//#region src/request/types/walletMethods/renouncePermissions.ts
-const renouncePermissionsMethodName = "wallet_renouncePermissions";
-const renouncePermissionsParamsSchema = v.nullish(v.null());
-const renouncePermissionsResultSchema = v.nullish(v.null());
-const renouncePermissionsRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(renouncePermissionsMethodName),
-		params: renouncePermissionsParamsSchema,
-		id: v.string()
-	}).entries
-});
-
-//#endregion
-//#region src/request/types/walletMethods/requestPermissions.ts
-const requestPermissionsMethodName = "wallet_requestPermissions";
-const requestPermissionsParamsSchema = v.nullish(v.array(PermissionRequestParams));
-const requestPermissionsResultSchema = v.literal(true);
-const requestPermissionsRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(requestPermissionsMethodName),
-		params: requestPermissionsParamsSchema,
-		id: v.string()
-	}).entries
-});
-
-//#endregion
-//#region src/request/types/bitcoinMethods/getAddresses.ts
-const getAddressesMethodName = "getAddresses";
-const getAddressesParamsSchema = v.object({
-	purposes: v.array(v.enum(AddressPurpose)),
-	message: v.optional(v.string())
-});
-const getAddressesResultSchema = v.object({
-	addresses: v.array(addressSchema),
-	network: getNetworkResultSchema
-});
-const getAddressesRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(getAddressesMethodName),
-		params: getAddressesParamsSchema,
-		id: v.string()
-	}).entries
-});
-const bitcoinGetAddressesV2MethodName = "bitcoin_getAddressesV2";
-const bitcoinGetAddressesV2ParamsSchema = v.object({
-	purposes: v.array(v.enum(AddressPurpose)),
-	message: v.optional(v.string())
-});
-const bitcoinGetAddressesResultSchema = v.object({
-	addresses: v.array(addressSchema),
-	networks: getNetworksResultSchema
-});
-const bitcoinGetAddressesRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(bitcoinGetAddressesV2MethodName),
-		params: bitcoinGetAddressesV2ParamsSchema,
-		id: v.string()
-	}).entries
-});
-
-//#endregion
-//#region src/request/types/bitcoinMethods/getBalance.ts
-const getBalanceMethodName = "getBalance";
-const getBalanceParamsSchema = v.nullish(v.null());
-const getBalanceResultSchema = v.object({
-	confirmed: v.string(),
-	unconfirmed: v.string(),
-	total: v.string()
-});
-const getBalanceRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(getBalanceMethodName),
-		id: v.string()
-	}).entries
-});
-const bitcoinGetBalanceV2MethodName = "bitcoin_getBalanceV2";
-const bitcoinGetBalanceV2ParamsSchema = v.nullish(v.null());
-const bitcoinGetBalanceV2ResultSchema = v.object({
-	confirmed: v.string(),
-	unconfirmed: v.string(),
-	total: v.string()
-});
-const bitcoinGetBalanceV2RequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(bitcoinGetBalanceV2MethodName),
-		id: v.string()
-	}).entries
-});
-
-//#endregion
-//#region src/request/types/bitcoinMethods/getInfo.ts
-let ProviderPlatform = /* @__PURE__ */ function(ProviderPlatform$1) {
-	ProviderPlatform$1["Web"] = "web";
-	ProviderPlatform$1["Mobile"] = "mobile";
-	return ProviderPlatform$1;
-}({});
-const getInfoMethodName = "getInfo";
-const getInfoParamsSchema = v.nullish(v.null());
-const getInfoResultSchema = v.object({
-	version: v.string(),
-	platform: v.optional(v.enum(ProviderPlatform)),
-	methods: v.optional(v.array(v.string())),
-	supports: v.array(v.string())
-});
-const getInfoRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(getInfoMethodName),
-		params: getInfoParamsSchema,
-		id: v.string()
-	}).entries
-});
-const bitcoinGetInfoV2MethodName = "bitcoin_getInfoV2";
-const bitcoinGetInfoV2ParamsSchema = v.nullish(v.null());
-const bitcoinGetInfoV2ResultSchema = v.object({
-	version: v.string(),
-	platform: v.optional(v.enum(ProviderPlatform)),
-	methods: v.optional(v.array(v.string())),
-	supports: v.array(v.string())
-});
-const bitcoinGetInfoV2RequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(bitcoinGetInfoV2MethodName),
-		params: bitcoinGetInfoV2ParamsSchema,
-		id: v.string()
-	}).entries
-});
-
-//#endregion
-//#region src/request/types/bitcoinMethods/sendTransfer.ts
-const sendTransferMethodName = "sendTransfer";
-const sendTransferParamsSchema = v.object({ recipients: v.array(v.object({
-	address: v.string(),
-	amount: v.number()
-})) });
-const sendTransferResultSchema = v.object({ txid: v.string() });
-const sendTransferRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(sendTransferMethodName),
-		params: sendTransferParamsSchema,
-		id: v.string()
-	}).entries
-});
-const bitcoinSendTransferV2MethodName = "bitcoin_sendTransferV2";
-const bitcoinSendTransferV2ParamsSchema = v.object({ recipients: v.array(v.object({
-	address: v.string(),
-	amount: v.number()
-})) });
-const bitcoinSendTransferV2ResultSchema = v.object({ txid: v.string() });
-const bitcoinSendTransferV2RequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(bitcoinSendTransferV2MethodName),
-		params: bitcoinSendTransferV2ParamsSchema,
-		id: v.string()
-	}).entries
-});
-
-//#endregion
-//#region src/request/types/bitcoinMethods/signMessage.ts
-const signMessageMethodName = "signMessage";
-const signMessageParamsSchema = v.object({
-	address: v.string(),
-	message: v.string(),
-	protocol: v.optional(v.enum(MessageSigningProtocols))
-});
-const signMessageResultSchema = v.object({
-	signature: v.string(),
-	messageHash: v.string(),
-	address: v.string(),
-	protocol: v.enum(MessageSigningProtocols)
-});
-const signMessageRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(signMessageMethodName),
-		params: signMessageParamsSchema,
-		id: v.string()
-	}).entries
-});
-const bitcoinSignMessageV2MethodName = "bitcoin_signMessageV2";
-const bitcoinSignMessageV2ParamsSchema = v.object({
-	address: v.string(),
-	message: v.string(),
-	protocol: v.optional(v.enum(MessageSigningProtocols))
-});
-const bitcoinSignMessageV2ResultSchema = v.object({
-	signature: v.string(),
-	messageHash: v.string(),
-	address: v.string(),
-	protocol: v.enum(MessageSigningProtocols)
-});
-const bitcoinSignMessageV2RequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(bitcoinSignMessageV2MethodName),
-		params: bitcoinSignMessageV2ParamsSchema,
-		id: v.string()
-	}).entries
-});
+	estimateMintCost = async (mintParams) => {
+		try {
+			return { data: (await this.client.post("/runes/mint/estimate", { ...mintParams })).data };
+		} catch (error) {
+			const err = error;
+			return { error: this.parseError(err) };
+		}
+	};
+	estimateEtchCost = async (etchParams) => {
+		try {
+			return { data: (await this.client.post("/runes/etch/estimate", { ...etchParams })).data };
+		} catch (error) {
+			const err = error;
+			return { error: this.parseError(err) };
+		}
+	};
+	createMintOrder = async (mintOrderParams) => {
+		try {
+			return { data: (await this.client.post("/runes/mint/orders", { ...mintOrderParams })).data };
+		} catch (error) {
+			const err = error;
+			return { error: this.parseError(err) };
+		}
+	};
+	createEtchOrder = async (etchOrderParams) => {
+		try {
+			return { data: (await this.client.post("/runes/etch/orders", { ...etchOrderParams })).data };
+		} catch (error) {
+			const err = error;
+			return { error: this.parseError(err) };
+		}
+	};
+	executeMint = async (orderId, fundTransactionId) => {
+		try {
+			return { data: (await this.client.post(`/runes/mint/orders/${orderId}/execute`, { fundTransactionId })).data };
+		} catch (error) {
+			const err = error;
+			return { error: this.parseError(err) };
+		}
+	};
+	executeEtch = async (orderId, fundTransactionId) => {
+		try {
+			return { data: (await this.client.post(`/runes/etch/orders/${orderId}/execute`, { fundTransactionId })).data };
+		} catch (error) {
+			const err = error;
+			return { error: this.parseError(err) };
+		}
+	};
+	getOrder = async (orderId) => {
+		try {
+			return { data: (await this.client.get(`/orders/${orderId}`)).data };
+		} catch (error) {
+			const err = error;
+			return { error: this.parseError(err) };
+		}
+	};
+	rbfOrder = async (rbfRequest) => {
+		const { orderId, newFeeRate } = rbfRequest;
+		try {
+			return { data: (await this.client.post(`/orders/${orderId}/rbf-estimate`, { newFeeRate })).data };
+		} catch (error) {
+			const err = error;
+			return { error: this.parseError(err) };
+		}
+	};
+};
+const clients = {};
+const getRunesApiClient = (network = BitcoinNetworkType.Mainnet) => {
+	if (!clients[network]) clients[network] = new RunesApi(network);
+	return clients[network];
+};
 
 //#endregion
-//#region src/request/types/bitcoinMethods/signMultipleMessages.ts
-const signMultipleMessagesMethodName = "signMultipleMessages";
-const signMultipleMessagesParamsSchema = v.array(v.object({
-	address: v.string(),
+//#region src/adapters/satsConnectAdapter.ts
+var SatsConnectAdapter = class {
+	async mintRunes(params) {
+		try {
+			const walletInfo = await this.requestInternal("getInfo", null).catch(() => null);
+			if (walletInfo && walletInfo.status === "success") {
+				if (walletInfo.result.methods?.includes("runes_mint")) {
+					const response = await this.requestInternal("runes_mint", params);
+					if (response) {
+						if (response.status === "success") return response;
+						if (response.status === "error" && response.error.code !== RpcErrorCode.METHOD_NOT_FOUND) return response;
+					}
+				}
+			}
+			const mintRequest = {
+				destinationAddress: params.destinationAddress,
+				feeRate: params.feeRate,
+				refundAddress: params.refundAddress,
+				repeats: params.repeats,
+				runeName: params.runeName,
+				appServiceFee: params.appServiceFee,
+				appServiceFeeAddress: params.appServiceFeeAddress
+			};
+			const orderResponse = await new RunesApi(params.network).createMintOrder(mintRequest);
+			if (!orderResponse.data) return {
+				status: "error",
+				error: {
+					code: orderResponse.error.code === 400 ? RpcErrorCode.INVALID_REQUEST : RpcErrorCode.INTERNAL_ERROR,
+					message: orderResponse.error.message
+				}
+			};
+			const paymentResponse = await this.requestInternal("sendTransfer", { recipients: [{
+				address: orderResponse.data.fundAddress,
+				amount: orderResponse.data.fundAmount
+			}] });
+			if (paymentResponse.status !== "success") return paymentResponse;
+			await new RunesApi(params.network).executeMint(orderResponse.data.orderId, paymentResponse.result.txid);
+			return {
+				status: "success",
+				result: {
+					orderId: orderResponse.data.orderId,
+					fundTransactionId: paymentResponse.result.txid,
+					fundingAddress: orderResponse.data.fundAddress
+				}
+			};
+		} catch (error) {
+			return {
+				status: "error",
+				error: {
+					code: RpcErrorCode.INTERNAL_ERROR,
+					message: error.message
+				}
+			};
+		}
+	}
+	async etchRunes(params) {
+		const etchRequest = {
+			destinationAddress: params.destinationAddress,
+			refundAddress: params.refundAddress,
+			feeRate: params.feeRate,
+			runeName: params.runeName,
+			divisibility: params.divisibility,
+			symbol: params.symbol,
+			premine: params.premine,
+			isMintable: params.isMintable,
+			terms: params.terms,
+			inscriptionDetails: params.inscriptionDetails,
+			delegateInscriptionId: params.delegateInscriptionId,
+			appServiceFee: params.appServiceFee,
+			appServiceFeeAddress: params.appServiceFeeAddress
+		};
+		try {
+			const walletInfo = await this.requestInternal("getInfo", null).catch(() => null);
+			if (walletInfo && walletInfo.status === "success") {
+				if (walletInfo.result.methods?.includes("runes_etch")) {
+					const response = await this.requestInternal("runes_etch", params);
+					if (response) {
+						if (response.status === "success") return response;
+						if (response.status === "error" && response.error.code !== RpcErrorCode.METHOD_NOT_FOUND) return response;
+					}
+				}
+			}
+			const orderResponse = await new RunesApi(params.network).createEtchOrder(etchRequest);
+			if (!orderResponse.data) return {
+				status: "error",
+				error: {
+					code: orderResponse.error.code === 400 ? RpcErrorCode.INVALID_REQUEST : RpcErrorCode.INTERNAL_ERROR,
+					message: orderResponse.error.message
+				}
+			};
+			const paymentResponse = await this.requestInternal("sendTransfer", { recipients: [{
+				address: orderResponse.data.fundAddress,
+				amount: orderResponse.data.fundAmount
+			}] });
+			if (paymentResponse.status !== "success") return paymentResponse;
+			await new RunesApi(params.network).executeEtch(orderResponse.data.orderId, paymentResponse.result.txid);
+			return {
+				status: "success",
+				result: {
+					orderId: orderResponse.data.orderId,
+					fundTransactionId: paymentResponse.result.txid,
+					fundingAddress: orderResponse.data.fundAddress
+				}
+			};
+		} catch (error) {
+			return {
+				status: "error",
+				error: {
+					code: RpcErrorCode.INTERNAL_ERROR,
+					message: error.message
+				}
+			};
+		}
+	}
+	async estimateMint(params) {
+		const estimateMintRequest = {
+			destinationAddress: params.destinationAddress,
+			feeRate: params.feeRate,
+			repeats: params.repeats,
+			runeName: params.runeName,
+			appServiceFee: params.appServiceFee,
+			appServiceFeeAddress: params.appServiceFeeAddress
+		};
+		const response = await getRunesApiClient(params.network).estimateMintCost(estimateMintRequest);
+		if (response.data) return {
+			status: "success",
+			result: response.data
+		};
+		return {
+			status: "error",
+			error: {
+				code: response.error.code === 400 ? RpcErrorCode.INVALID_REQUEST : RpcErrorCode.INTERNAL_ERROR,
+				message: response.error.message
+			}
+		};
+	}
+	async estimateEtch(params) {
+		const estimateEtchRequest = {
+			destinationAddress: params.destinationAddress,
+			feeRate: params.feeRate,
+			runeName: params.runeName,
+			divisibility: params.divisibility,
+			symbol: params.symbol,
+			premine: params.premine,
+			isMintable: params.isMintable,
+			terms: params.terms,
+			inscriptionDetails: params.inscriptionDetails,
+			delegateInscriptionId: params.delegateInscriptionId,
+			appServiceFee: params.appServiceFee,
+			appServiceFeeAddress: params.appServiceFeeAddress
+		};
+		const response = await getRunesApiClient(params.network).estimateEtchCost(estimateEtchRequest);
+		if (response.data) return {
+			status: "success",
+			result: response.data
+		};
+		return {
+			status: "error",
+			error: {
+				code: response.error.code === 400 ? RpcErrorCode.INVALID_REQUEST : RpcErrorCode.INTERNAL_ERROR,
+				message: response.error.message
+			}
+		};
+	}
+	async getOrder(params) {
+		const response = await getRunesApiClient(params.network).getOrder(params.id);
+		if (response.data) return {
+			status: "success",
+			result: response.data
+		};
+		return {
+			status: "error",
+			error: {
+				code: response.error.code === 400 || response.error.code === 404 ? RpcErrorCode.INVALID_REQUEST : RpcErrorCode.INTERNAL_ERROR,
+				message: response.error.message
+			}
+		};
+	}
+	async estimateRbfOrder(params) {
+		const rbfOrderRequest = {
+			newFeeRate: params.newFeeRate,
+			orderId: params.orderId
+		};
+		const response = await getRunesApiClient(params.network).rbfOrder(rbfOrderRequest);
+		if (response.data) return {
+			status: "success",
+			result: {
+				fundingAddress: response.data.fundingAddress,
+				rbfCost: response.data.rbfCost
+			}
+		};
+		return {
+			status: "error",
+			error: {
+				code: response.error.code === 400 || response.error.code === 404 ? RpcErrorCode.INVALID_REQUEST : RpcErrorCode.INTERNAL_ERROR,
+				message: response.error.message
+			}
+		};
+	}
+	async rbfOrder(params) {
+		try {
+			const rbfOrderRequest = {
+				newFeeRate: params.newFeeRate,
+				orderId: params.orderId
+			};
+			const orderResponse = await getRunesApiClient(params.network).rbfOrder(rbfOrderRequest);
+			if (!orderResponse.data) return {
+				status: "error",
+				error: {
+					code: orderResponse.error.code === 400 || orderResponse.error.code === 404 ? RpcErrorCode.INVALID_REQUEST : RpcErrorCode.INTERNAL_ERROR,
+					message: orderResponse.error.message
+				}
+			};
+			const paymentResponse = await this.requestInternal("sendTransfer", { recipients: [{
+				address: orderResponse.data.fundingAddress,
+				amount: orderResponse.data.rbfCost
+			}] });
+			if (paymentResponse.status !== "success") return paymentResponse;
+			return {
+				status: "success",
+				result: {
+					fundingAddress: orderResponse.data.fundingAddress,
+					orderId: rbfOrderRequest.orderId,
+					fundRBFTransactionId: paymentResponse.result.txid
+				}
+			};
+		} catch (error) {
+			return {
+				status: "error",
+				error: {
+					code: RpcErrorCode.INTERNAL_ERROR,
+					message: error.message
+				}
+			};
+		}
+	}
+	async request(method, params) {
+		switch (method) {
+			case "runes_mint": return this.mintRunes(params);
+			case "runes_etch": return this.etchRunes(params);
+			case "runes_estimateMint": return this.estimateMint(params);
+			case "runes_estimateEtch": return this.estimateEtch(params);
+			case "runes_getOrder": return this.getOrder(params);
+			case "runes_estimateRbfOrder": return this.estimateRbfOrder(params);
+			case "runes_rbfOrder": return this.rbfOrder(params);
+			default: return this.requestInternal(method, params);
+		}
+	}
+};
+
+//#endregion
+//#region src/adapters/fordefi.ts
+var FordefiAdapter = class extends SatsConnectAdapter {
+	id = DefaultAdaptersInfo.fordefi.id;
+	requestInternal = async (method, params) => {
+		const provider = getProviderById(this.id);
+		if (!provider) throw new Error("no wallet provider was found");
+		if (!method) throw new Error("A wallet method is required");
+		return await provider.request(method, params);
+	};
+	addListener = ({ eventName, cb }) => {
+		const provider = getProviderById(this.id);
+		if (!provider) throw new Error("no wallet provider was found");
+		if (!provider.addListener) {
+			console.error(`The wallet provider you are using does not support the addListener method. Please update your wallet provider.`);
+			return () => {};
+		}
+		return provider.addListener(eventName, cb);
+	};
+};
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/shared/index.ts
+let MessageSigningProtocols = /* @__PURE__ */ function(MessageSigningProtocols$1) {
+	MessageSigningProtocols$1["ECDSA"] = "ECDSA";
+	MessageSigningProtocols$1["BIP322"] = "BIP322";
+	return MessageSigningProtocols$1;
+}({});
+let ProviderPlatform = /* @__PURE__ */ function(ProviderPlatform$1) {
+	ProviderPlatform$1["Web"] = "web";
+	ProviderPlatform$1["Mobile"] = "mobile";
+	return ProviderPlatform$1;
+}({});
+
+//#endregion
+//#region src/adapters/unisat.ts
+function convertSignInputsToInputType(signInputs) {
+	const result = [];
+	if (!signInputs) return result;
+	for (const address in signInputs) {
+		const indexes = signInputs[address];
+		for (const index of indexes) result.push({
+			index,
+			address
+		});
+	}
+	return result;
+}
+var UnisatAdapter = class extends SatsConnectAdapter {
+	id = DefaultAdaptersInfo.unisat.id;
+	async getAccounts(params) {
+		const { purposes } = params;
+		if (purposes.includes(AddressPurpose.Stacks) || purposes.includes(AddressPurpose.Starknet) || purposes.includes(AddressPurpose.Spark)) throw new Error("Only bitcoin addresses are supported");
+		const accounts = await window.unisat.requestAccounts();
+		const publicKey = await window.unisat.getPublicKey();
+		const address = accounts[0];
+		const addressType = getAddressInfo(accounts[0]).type;
+		const pk = addressType === AddressType$1.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 = getAddressInfo(address).type;
+		if ([AddressType$1.p2wpkh, AddressType$1.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.from(psbt, "base64").toString("hex");
+		const signedPsbt = await window.unisat.signPsbt(psbtHex, {
+			autoFinalized: broadcast,
+			toSignInputs: convertSignInputsToInputType(signInputs)
+		});
+		const signedPsbtBase64 = 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 = v.union([
+	v.string(),
+	v.number(),
+	v.null()
+]);
+const specRequestSchema = v.object({
+	jsonrpc: v.literal("2.0"),
+	method: v.string(),
+	params: v.optional(v.union([
+		v.array(v.unknown()),
+		v.looseObject({}),
+		v.null()
+	])),
+	id: v.optional(specIdSchema)
+});
+const specSuccessResponseSchema = v.object({
+	jsonrpc: v.literal("2.0"),
+	result: v.unknown(),
+	id: specIdSchema
+});
+const warningSchema = v.variant("code", [v.object({
+	code: v.literal("DEPRECATION_NOTICE"),
 	message: v.string(),
-	protocol: v.optional(v.enum(MessageSigningProtocols))
+	sunsetDate: v.pipe(v.string(), v.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 = v.object({
+	...specSuccessResponseSchema.entries,
+	extensions: v.optional(v.object({ warnings: v.array(warningSchema) }))
+});
+const specErrorObjectSchema = v.object({
+	code: v.number(),
+	message: v.string(),
+	data: v.optional(v.unknown())
+});
+const specErrorResponseSchema = v.object({
+	jsonrpc: v.literal("2.0"),
+	error: specErrorObjectSchema,
+	id: specIdSchema
+});
+const specResponseSchema = v.union([specSuccessWithExtensionsResponseSchema, specErrorResponseSchema]);
+
+//#endregion
+//#region src/request/sanitizeRequest.ts
+const sanitizeRequest = (method, params, providerInfo) => {
+	try {
+		const [major, minor] = providerInfo.version.split(".").map((part) => parseInt(part, 10));
+		const platform = providerInfo.platform;
+		if (!platform || platform === ProviderPlatform.Web && major <= 1 && minor <= 4 || platform === ProviderPlatform.Mobile && major <= 1 && minor <= 54) {
+			const v1Sanitized = sanitizeAddressPurposeRequest(method, params);
+			method = v1Sanitized.method;
+			params = v1Sanitized.params;
+		}
+	} catch {}
+	return {
+		method,
+		params
+	};
+};
+const sanitizeAddressPurposeRequest = (method, params) => {
+	const filterPurposes = (purposes) => purposes?.filter((purpose) => purpose !== AddressPurpose.Spark && purpose !== AddressPurpose.Starknet);
+	if (method === "wallet_connect") {
+		const typedParams = params;
+		if (!typedParams) return {
+			method,
+			params
+		};
+		const { addresses, ...rest } = typedParams;
+		return {
+			method,
+			params: {
+				...rest,
+				addresses: filterPurposes(addresses)
+			}
+		};
+	}
+	if (method === "getAccounts") {
+		const { purposes, ...rest } = params;
+		return {
+			method,
+			params: {
+				...rest,
+				purposes: filterPurposes(purposes)
+			}
+		};
+	}
+	if (method === "getAddresses") {
+		const { purposes, ...rest } = params;
+		return {
+			method,
+			params: {
+				...rest,
+				purposes: filterPurposes(purposes)
+			}
+		};
+	}
+	return {
+		method,
+		params
+	};
+};
+
+//#endregion
+//#region src/request/methods.ts
+const bitcoinMethods = {
+	getAccounts: "getAccounts",
+	getAddresses: "getAddresses",
+	bitcoin_getAddressesV2: "bitcoin_getAddressesV2",
+	getBalance: "getBalance",
+	bitcoin_getBalanceV2: "bitcoin_getBalanceV2",
+	getInfo: "getInfo",
+	sendTransfer: "sendTransfer",
+	bitcoin_sendTransferV2: "bitcoin_sendTransferV2",
+	signMessage: "signMessage",
+	bitcoin_signMessageV2: "bitcoin_signMessageV2",
+	signMultipleMessages: "signMultipleMessages",
+	bitcoin_signMultipleMessagesV2: "bitcoin_signMultipleMessagesV2",
+	signPsbt: "signPsbt",
+	bitcoin_signPsbtV2: "bitcoin_signPsbtV2"
+};
+const stacksMethods = {
+	stx_callContract: "stx_callContract",
+	stx_deployContract: "stx_deployContract",
+	stx_getAccounts: "stx_getAccounts",
+	stx_getAddresses: "stx_getAddresses",
+	stx_signMessage: "stx_signMessage",
+	stx_signStructuredMessage: "stx_signStructuredMessage",
+	stx_signTransaction: "stx_signTransaction",
+	stx_signTransactions: "stx_signTransactions",
+	stx_transferStx: "stx_transferStx"
+};
+const sparkMethods = {
+	spark_getAddresses: "spark_getAddresses",
+	spark_getAddressesV2: "spark_getAddressesV2",
+	spark_getBalance: "spark_getBalance",
+	spark_transfer: "spark_transfer",
+	spark_transferToken: "spark_transferToken",
+	spark_signMessage: "spark_signMessage",
+	spark_flashnet_getJwt: "spark_flashnet_getJwt",
+	spark_flashnet_signIntent: "spark_flashnet_signIntent",
+	spark_flashnet_signStructuredMessage: "spark_flashnet_signStructuredMessage",
+	spark_flashnet_executeSwap: "spark_flashnet_executeSwap",
+	spark_flashnet_executeRouteSwap: "spark_flashnet_executeRouteSwap",
+	spark_flashnet_clawbackFunds: "spark_flashnet_clawbackFunds",
+	spark_flashnet_getClawbackEligibleTransfers: "spark_flashnet_getClawbackEligibleTransfers"
+};
+const runesMethods = {
+	runes_estimateEtch: "runes_estimateEtch",
+	runes_estimateMint: "runes_estimateMint",
+	runes_estimateRbfOrder: "runes_estimateRbfOrder",
+	runes_etch: "runes_etch",
+	runes_getBalance: "runes_getBalance",
+	runes_getOrder: "runes_getOrder",
+	runes_mint: "runes_mint",
+	runes_rbfOrder: "runes_rbfOrder",
+	runes_transfer: "runes_transfer"
+};
+const ordinalsMethods = {
+	ord_getInscriptions: "ord_getInscriptions",
+	ord_sendInscriptions: "ord_sendInscriptions"
+};
+const walletMethods = {
+	wallet_addNetwork: "wallet_addNetwork",
+	wallet_addNetworkV2: "wallet_addNetworkV2",
+	wallet_changeNetwork: "wallet_changeNetwork",
+	wallet_connect: "wallet_connect",
+	wallet_connectV2: "wallet_connectV2",
+	wallet_disconnect: "wallet_disconnect",
+	wallet_getAccount: "wallet_getAccount",
+	wallet_getAccountV2: "wallet_getAccountV2",
+	wallet_getCurrentPermissions: "wallet_getCurrentPermissions",
+	wallet_getNetwork: "wallet_getNetwork",
+	wallet_getNetworks: "wallet_getNetworks",
+	wallet_getWalletType: "wallet_getWalletType",
+	wallet_openBridge: "wallet_openBridge",
+	wallet_openBuy: "wallet_openBuy",
+	wallet_openReceive: "wallet_openReceive",
+	wallet_renouncePermissions: "wallet_renouncePermissions",
+	wallet_requestPermissions: "wallet_requestPermissions",
+	wallet_switchNetworkById: "wallet_switchNetworkById"
+};
+const methods = {
+	...bitcoinMethods,
+	...stacksMethods,
+	...sparkMethods,
+	...runesMethods,
+	...ordinalsMethods,
+	...walletMethods
+};
+
+//#endregion
+//#region src/request/rpc/compat.ts
+function bitcoinModeToLegacyBitcoinNetworkType(mode) {
+	return 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 match(mode).with("mainnet", () => StacksNetworkType.Mainnet).with("testnet", () => StacksNetworkType.Testnet).otherwise(() => StacksNetworkType.Testnet);
+}
+function sparkModeToLegacySparkNetworkType(mode) {
+	return match(mode).with("mainnet", () => SparkNetworkType.Mainnet).with("regtest", () => SparkNetworkType.Regtest).exhaustive();
+}
+
+//#endregion
+//#region src/request/rpc/methodSupport.ts
+const { active } = {
+	active: "active",
+	deprecated: "deprecated",
+	removed: "removed"
+};
+const methodSupport = {
+	[bitcoinMethods.getAccounts]: active,
+	[bitcoinMethods.getAddresses]: active,
+	[bitcoinMethods.bitcoin_getAddressesV2]: active,
+	[bitcoinMethods.getBalance]: active,
+	[bitcoinMethods.bitcoin_getBalanceV2]: active,
+	[bitcoinMethods.getInfo]: active,
+	[bitcoinMethods.sendTransfer]: active,
+	[bitcoinMethods.bitcoin_sendTransferV2]: active,
+	[bitcoinMethods.signMessage]: active,
+	[bitcoinMethods.bitcoin_signMessageV2]: active,
+	[bitcoinMethods.signMultipleMessages]: active,
+	[bitcoinMethods.bitcoin_signMultipleMessagesV2]: active,
+	[bitcoinMethods.signPsbt]: active,
+	[bitcoinMethods.bitcoin_signPsbtV2]: active,
+	[stacksMethods.stx_callContract]: active,
+	[stacksMethods.stx_deployContract]: active,
+	[stacksMethods.stx_getAccounts]: active,
+	[stacksMethods.stx_getAddresses]: active,
+	[stacksMethods.stx_signMessage]: active,
+	[stacksMethods.stx_signStructuredMessage]: active,
+	[stacksMethods.stx_signTransaction]: active,
+	[stacksMethods.stx_signTransactions]: active,
+	[stacksMethods.stx_transferStx]: active,
+	[sparkMethods.spark_getAddresses]: active,
+	[sparkMethods.spark_getAddressesV2]: active,
+	[sparkMethods.spark_getBalance]: active,
+	[sparkMethods.spark_transfer]: active,
+	[sparkMethods.spark_transferToken]: active,
+	[sparkMethods.spark_signMessage]: active,
+	[sparkMethods.spark_flashnet_getJwt]: active,
+	[sparkMethods.spark_flashnet_signIntent]: active,
+	[sparkMethods.spark_flashnet_signStructuredMessage]: active,
+	[sparkMethods.spark_flashnet_executeSwap]: active,
+	[sparkMethods.spark_flashnet_executeRouteSwap]: active,
+	[sparkMethods.spark_flashnet_clawbackFunds]: active,
+	[sparkMethods.spark_flashnet_getClawbackEligibleTransfers]: active,
+	[runesMethods.runes_estimateEtch]: active,
+	[runesMethods.runes_estimateMint]: active,
+	[runesMethods.runes_estimateRbfOrder]: active,
+	[runesMethods.runes_etch]: active,
+	[runesMethods.runes_getBalance]: active,
+	[runesMethods.runes_getOrder]: active,
+	[runesMethods.runes_mint]: active,
+	[runesMethods.runes_rbfOrder]: active,
+	[runesMethods.runes_transfer]: active,
+	[ordinalsMethods.ord_getInscriptions]: active,
+	[ordinalsMethods.ord_sendInscriptions]: active,
+	[walletMethods.wallet_addNetwork]: active,
+	[walletMethods.wallet_addNetworkV2]: active,
+	[walletMethods.wallet_changeNetwork]: active,
+	[walletMethods.wallet_connect]: active,
+	[walletMethods.wallet_connectV2]: active,
+	[walletMethods.wallet_disconnect]: active,
+	[walletMethods.wallet_getAccount]: active,
+	[walletMethods.wallet_getAccountV2]: active,
+	[walletMethods.wallet_getCurrentPermissions]: active,
+	[walletMethods.wallet_getNetwork]: active,
+	[walletMethods.wallet_getNetworks]: active,
+	[walletMethods.wallet_getWalletType]: active,
+	[walletMethods.wallet_openBridge]: active,
+	[walletMethods.wallet_openBuy]: active,
+	[walletMethods.wallet_openReceive]: active,
+	[walletMethods.wallet_renouncePermissions]: active,
+	[walletMethods.wallet_requestPermissions]: active,
+	[walletMethods.wallet_switchNetworkById]: active
+};
+
+//#endregion
+//#region src/request/shared.ts
+const rpcIdSchema = v.string();
+
+//#endregion
+//#region src/request/createRequestSchema.ts
+function createRequestSchema({ paramsSchema, method }) {
+	return v.object({
+		...specRequestSchema.entries,
+		id: rpcIdSchema,
+		method: v.literal(method),
+		params: paramsSchema
+	});
+}
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/getAccounts/request.ts
+const bitcoinGetAccountsParamsSchema = v.object({
+	purposes: v.array(v.enum(AddressPurpose)),
+	message: v.optional(v.string())
+});
+const bitcoinGetAccountsRequestSchema = createRequestSchema({
+	paramsSchema: bitcoinGetAccountsParamsSchema,
+	method: bitcoinMethods.getAccounts
+});
+
+//#endregion
+//#region src/request/createSuccessResponseSchema.ts
+function createSuccessResponseSchema({ method, resultSchema }) {
+	return v.object({
+		...specSuccessWithExtensionsResponseSchema.entries,
+		id: rpcIdSchema,
+		result: resultSchema,
+		"~sats-connect-method": v.literal(method)
+	});
+}
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/getAccounts/response.ts
+const bitcoinGetAccountsResultSchema = v.array(v.object({
+	...addressSchema.entries,
+	...v.object({ walletType: walletTypeSchema }).entries
 }));
-const signMultipleMessagesResultSchema = v.array(v.object({
-	signature: v.string(),
-	message: v.string(),
-	messageHash: v.string(),
+const bitcoinGetAccountsSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: bitcoinGetAccountsResultSchema,
+	method: bitcoinMethods.getAccounts
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/getAddresses/request.ts
+const bitcoinGetAddressesParamsSchema = v.object({
+	purposes: v.array(v.enum(AddressPurpose)),
+	message: v.optional(v.string())
+});
+const bitcoinGetAddressesRequestSchema = createRequestSchema({
+	paramsSchema: bitcoinGetAddressesParamsSchema,
+	method: bitcoinMethods.getAddresses
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/getAddresses/response.ts
+const getNetworkResultSchema = v.object({
+	bitcoin: v.object({ name: v.string() }),
+	stacks: v.object({ name: v.string() }),
+	spark: v.object({ name: v.string() })
+});
+const bitcoinGetAddressesResultSchema = v.object({
+	addresses: v.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 = v.object({
+	purposes: v.array(v.enum(AddressPurpose)),
+	message: v.optional(v.string())
+});
+const bitcoinGetAddressesV2RequestSchema = createRequestSchema({
+	paramsSchema: bitcoinGetAddressesV2ParamsSchema,
+	method: bitcoinMethods.bitcoin_getAddressesV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/addNetwork/request.ts
+const walletAddNetworkParamsSchema = v.variant("chain", [
+	v.object({
+		chain: v.literal("bitcoin"),
+		type: v.enum(BitcoinNetworkType),
+		name: v.string(),
+		rpcUrl: v.string(),
+		rpcFallbackUrl: v.optional(v.string()),
+		indexerUrl: v.optional(v.string()),
+		blockExplorerUrl: v.optional(v.string()),
+		switch: v.optional(v.boolean())
+	}),
+	v.object({
+		chain: v.literal("stacks"),
+		name: v.string(),
+		type: v.enum(StacksNetworkType),
+		rpcUrl: v.string(),
+		blockExplorerUrl: v.optional(v.string()),
+		switch: v.optional(v.boolean())
+	}),
+	v.object({
+		chain: v.literal("starknet"),
+		name: v.string(),
+		type: v.enum(StarknetNetworkType),
+		rpcUrl: v.string(),
+		blockExplorerUrl: v.optional(v.string()),
+		switch: v.optional(v.boolean())
+	})
+]);
+const walletAddNetworkRequestSchema = createRequestSchema({
+	paramsSchema: walletAddNetworkParamsSchema,
+	method: walletMethods.wallet_addNetwork
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/addNetwork/response.ts
+const walletAddNetworkResultSchema = v.object({ id: v.string() });
+const walletAddNetworkSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: walletAddNetworkResultSchema,
+	method: walletMethods.wallet_addNetwork
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/shared/permissions.ts
+const accountActionsSchema = v.object({ read: v.optional(v.boolean()) });
+const walletActionsSchema = v.object({ readNetwork: v.optional(v.boolean()) });
+const accountPermissionSchema = v.object({
+	type: v.literal("account"),
+	resourceId: v.string(),
+	clientId: v.string(),
+	actions: accountActionsSchema
+});
+const walletPermissionSchema = v.object({
+	type: v.literal("wallet"),
+	resourceId: v.string(),
+	clientId: v.string(),
+	actions: walletActionsSchema
+});
+const permissionSchema = v.variant("type", [accountPermissionSchema, walletPermissionSchema]);
+const permission = v.variant("type", [accountPermissionSchema, walletPermissionSchema]);
+/**
+* Permissions with the clientId field omitted and optional actions. Used for
+* permission requests, since the wallet performs authentication based on the
+* client's tab origin and should not rely on the client authenticating
+* themselves.
+*/
+const permissionRequestParamsSchema = v.variant("type", [v.object({ ...v.omit(accountPermissionSchema, ["clientId"]).entries }), v.object({ ...v.omit(walletPermissionSchema, ["clientId"]).entries })]);
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/addNetworkV2/request.ts
+const walletAddNetworkV2ParamsSchema = v.object({
+	network: networkConfigurationOptionsSchema,
+	switch: v.optional(v.boolean(), false)
+});
+const walletAddNetworkV2RequestSchema = createRequestSchema({
+	paramsSchema: walletAddNetworkV2ParamsSchema,
+	method: walletMethods.wallet_addNetworkV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/addNetworkV2/response.ts
+const walletAddNetworkV2ResultSchema = networkConfigurationSchema;
+const walletAddNetworkV2SuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: walletAddNetworkV2ResultSchema,
+	method: walletMethods.wallet_addNetworkV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/changeNetwork/request.ts
+const walletChangeNetworkParamsSchema = v.object({ name: v.enum(BitcoinNetworkType) });
+const walletChangeNetworkRequestSchema = createRequestSchema({
+	paramsSchema: walletChangeNetworkParamsSchema,
+	method: walletMethods.wallet_changeNetwork
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/changeNetwork/response.ts
+const walletChangeNetworkResultSchema = v.nullish(v.null());
+const walletChangeNetworkSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: walletChangeNetworkResultSchema,
+	method: walletMethods.wallet_changeNetwork
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/connect/request.ts
+const walletConnectParamsSchema = v.nullish(v.object({
+	permissions: v.optional(v.array(permissionRequestParamsSchema)),
+	addresses: v.optional(v.array(v.enum(AddressPurpose))),
+	message: v.optional(v.pipe(v.string(), v.maxLength(80, "The message must not exceed 80 characters."))),
+	network: v.optional(v.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 = v.nullish(v.null());
+const walletGetNetworkRequestSchema = createRequestSchema({
+	paramsSchema: walletGetNetworkParamsSchema,
+	method: walletMethods.wallet_getNetwork
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/getNetwork/response.ts
+const walletGetNetworkResultSchema = v.object({
+	bitcoin: v.object({ name: v.enum(BitcoinNetworkType) }),
+	stacks: v.object({ name: v.enum(StacksNetworkType) }),
+	spark: v.object({ name: v.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 = v.object({
+	id: v.string(),
+	addresses: v.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 = v.nullish(v.object({
+	permissions: permissionRequestParamsSchema,
+	addressPurposes: v.optional(v.array(v.enum(AddressPurpose))),
+	message: v.optional(v.pipe(v.string(), v.maxLength(80, "The message must not exceed 80 characters."))),
+	networkId: v.optional(v.string())
+}));
+const walletConnectV2RequestSchema = createRequestSchema({
+	paramsSchema: walletConnectV2ParamsSchema,
+	method: walletMethods.wallet_connectV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/getNetworks/request.ts
+const walletGetNetworksParamsSchema = v.nullish(v.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 = v.object({
+	accountId: v.string(),
+	addresses: v.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 = v.nullish(v.null());
+const walletDisconnectRequestSchema = createRequestSchema({
+	paramsSchema: walletDisconnectParamsSchema,
+	method: walletMethods.wallet_disconnect
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/disconnect/response.ts
+const walletDisconnectResultSchema = v.nullish(v.null());
+const walletDisconnectSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: walletDisconnectResultSchema,
+	method: walletMethods.wallet_disconnect
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/getAccount/request.ts
+const walletGetAccountParamsSchema = v.nullish(v.null());
+const walletGetAccountRequestSchema = createRequestSchema({
+	paramsSchema: walletGetAccountParamsSchema,
+	method: walletMethods.wallet_getAccount
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/getAccount/response.ts
+const walletGetAccountResultSchema = v.object({
+	id: v.string(),
+	addresses: v.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 = v.nullish(v.null());
+const walletGetAccountV2RequestSchema = createRequestSchema({
+	paramsSchema: walletGetAccountV2ParamsSchema,
+	method: walletMethods.wallet_getAccountV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/getAccountV2/response.ts
+const walletGetAccountV2ResultSchema = v.object({
+	id: v.string(),
+	addresses: v.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 = v.nullish(v.null());
+const walletGetCurrentPermissionsRequestSchema = createRequestSchema({
+	paramsSchema: walletGetCurrentPermissionsParamsSchema,
+	method: walletMethods.wallet_getCurrentPermissions
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/getCurrentPermissions/response.ts
+const walletGetCurrentPermissionsResultSchema = permission;
+const walletGetCurrentPermissionsSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: walletGetCurrentPermissionsResultSchema,
+	method: walletMethods.wallet_getCurrentPermissions
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/getWalletType/request.ts
+const walletGetWalletTypeParamsSchema = v.nullish(v.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 = v.object({
+	fromAsset: v.string(),
+	toAsset: v.string()
+});
+const walletOpenBridgeRequestSchema = createRequestSchema({
+	paramsSchema: walletOpenBridgeParamsSchema,
+	method: walletMethods.wallet_openBridge
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/openBridge/response.ts
+const walletOpenBridgeResultSchema = v.nullish(v.null());
+const walletOpenBridgeSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: walletOpenBridgeResultSchema,
+	method: walletMethods.wallet_openBridge
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/openBuy/request.ts
+const walletOpenBuyParamsSchema = v.object({ asset: v.string() });
+const walletOpenBuyRequestSchema = createRequestSchema({
+	paramsSchema: walletOpenBuyParamsSchema,
+	method: walletMethods.wallet_openBuy
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/openBuy/response.ts
+const walletOpenBuyResultSchema = v.nullish(v.null());
+const walletOpenBuySuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: walletOpenBuyResultSchema,
+	method: walletMethods.wallet_openBuy
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/openReceive/request.ts
+const walletOpenReceiveParamsSchema = v.object({ address: v.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 = v.nullish(v.null());
+const walletRenouncePermissionsRequestSchema = createRequestSchema({
+	paramsSchema: walletRenouncePermissionsParamsSchema,
+	method: walletMethods.wallet_renouncePermissions
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/renouncePermissions/response.ts
+const walletRenouncePermissionsResultSchema = v.nullish(v.null());
+const walletRenouncePermissionsSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: walletRenouncePermissionsResultSchema,
+	method: walletMethods.wallet_renouncePermissions
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/requestPermissions/request.ts
+const walletRequestPermissionsParamsSchema = v.array(permissionRequestParamsSchema);
+const walletRequestPermissionsRequestSchema = createRequestSchema({
+	paramsSchema: walletRequestPermissionsParamsSchema,
+	method: walletMethods.wallet_requestPermissions
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/requestPermissions/response.ts
+const walletRequestPermissionsResultSchema = v.literal(true);
+const walletRequestPermissionsSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: walletRequestPermissionsResultSchema,
+	method: walletMethods.wallet_requestPermissions
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/switchNetworkById/request.ts
+const walletSwitchNetworkByIdParamsSchema = v.object({ id: v.string() });
+const walletSwitchNetworkByIdRequestSchema = createRequestSchema({
+	paramsSchema: walletSwitchNetworkByIdParamsSchema,
+	method: walletMethods.wallet_switchNetworkById
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/methods/switchNetworkById/response.ts
+const walletChangeNetworkByIdResultSchema = v.nullish(v.null());
+const walletChangeNetworkByIdSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: walletChangeNetworkByIdResultSchema,
+	method: walletMethods.wallet_switchNetworkById
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/wallet/index.ts
+const walletRequestSchema = v.variant("method", [
+	walletAddNetworkRequestSchema,
+	walletAddNetworkV2RequestSchema,
+	walletSwitchNetworkByIdRequestSchema,
+	walletChangeNetworkRequestSchema,
+	walletConnectRequestSchema,
+	walletConnectV2RequestSchema,
+	walletDisconnectRequestSchema,
+	walletGetAccountRequestSchema,
+	walletGetAccountV2RequestSchema,
+	walletGetCurrentPermissionsRequestSchema,
+	walletGetNetworkRequestSchema,
+	walletGetNetworksRequestSchema,
+	walletGetWalletTypeRequestSchema,
+	walletOpenBridgeRequestSchema,
+	walletOpenBuyRequestSchema,
+	walletOpenReceiveRequestSchema,
+	walletRenouncePermissionsRequestSchema,
+	walletRequestPermissionsRequestSchema
+]);
+const walletSuccessResponseSchema = v.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/bitcoin/methods/getAddressesV2/response.ts
+const bitcoinGetAddressesV2ResultSchema = v.object({
+	addresses: v.array(addressSchema),
+	networks: allResolvedNetworksSchema
+});
+const bitcoinGetAddressesV2SuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: bitcoinGetAddressesV2ResultSchema,
+	method: bitcoinMethods.bitcoin_getAddressesV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/getBalance/request.ts
+const bitcoinGetBalanceParamsSchema = v.nullish(v.null());
+const bitcoinGetBalanceRequestSchema = createRequestSchema({
+	paramsSchema: bitcoinGetBalanceParamsSchema,
+	method: bitcoinMethods.getBalance
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/shared/balanceResultSchema.ts
+const balanceResultSchema = v.object({
+	confirmed: v.string(),
+	unconfirmed: v.string(),
+	total: v.string()
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/getBalance/response.ts
+const bitcoinGetBalanceResultSchema = balanceResultSchema;
+const bitcoinGetBalanceSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: bitcoinGetBalanceResultSchema,
+	method: bitcoinMethods.getBalance
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/getBalanceV2/request.ts
+const bitcoinGetBalanceV2ParamsSchema = v.nullish(v.null());
+const bitcoinGetBalanceV2RequestSchema = createRequestSchema({
+	paramsSchema: bitcoinGetBalanceV2ParamsSchema,
+	method: bitcoinMethods.bitcoin_getBalanceV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/getBalanceV2/response.ts
+const bitcoinGetBalanceV2ResultSchema = balanceResultSchema;
+const bitcoinGetBalanceV2SuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: bitcoinGetBalanceV2ResultSchema,
+	method: bitcoinMethods.bitcoin_getBalanceV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/getInfo/request.ts
+const bitcoinGetInfoParamsSchema = v.nullish(v.null());
+const bitcoinGetInfoRequestSchema = createRequestSchema({
+	paramsSchema: bitcoinGetInfoParamsSchema,
+	method: bitcoinMethods.getInfo
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/getInfo/response.ts
+const bitcoinGetInfoResultSchema = v.object({
+	version: v.string(),
+	platform: v.optional(v.enum(ProviderPlatform)),
+	methods: v.optional(v.array(v.string())),
+	supports: v.array(v.string())
+});
+const bitcoinGetInfoSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: bitcoinGetInfoResultSchema,
+	method: bitcoinMethods.getInfo
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/shared/sendTransfer.ts
+const sendTransferParamsSchema = v.object({ recipients: v.array(v.object({
 	address: v.string(),
-	protocol: v.enum(MessageSigningProtocols)
-}));
-const signMultipleMessagesRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(signMultipleMessagesMethodName),
-		params: signMultipleMessagesParamsSchema,
-		id: v.string()
-	}).entries
-});
-const bitcoinSignMultipleMessagesV2MethodName = "bitcoin_signMultipleMessagesV2";
-const bitcoinSignMultipleMessagesV2ParamsSchema = v.array(v.object({
+	amount: v.number()
+})) });
+const sendTransferResultSchema = v.object({ txid: v.string() });
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/sendTransfer/request.ts
+const bitcoinSendTransferParamsSchema = sendTransferParamsSchema;
+const bitcoinSendTransferRequestSchema = createRequestSchema({
+	paramsSchema: bitcoinSendTransferParamsSchema,
+	method: bitcoinMethods.sendTransfer
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/sendTransfer/response.ts
+const bitcoinSendTransferResultSchema = sendTransferResultSchema;
+const bitcoinSendTransferSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: bitcoinSendTransferResultSchema,
+	method: bitcoinMethods.sendTransfer
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/sendTransferV2/request.ts
+const bitcoinSendTransferV2ParamsSchema = sendTransferParamsSchema;
+const bitcoinSendTransferV2RequestSchema = createRequestSchema({
+	paramsSchema: bitcoinSendTransferV2ParamsSchema,
+	method: bitcoinMethods.bitcoin_sendTransferV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/sendTransferV2/response.ts
+const bitcoinSendTransferV2ResultSchema = sendTransferResultSchema;
+const bitcoinSendTransferV2SuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: bitcoinSendTransferV2ResultSchema,
+	method: bitcoinMethods.bitcoin_sendTransferV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/shared/signMessage.ts
+const signMessageParamsSchema = v.object({
 	address: v.string(),
 	message: v.string(),
 	protocol: v.optional(v.enum(MessageSigningProtocols))
-}));
-const bitcoinSignMultipleMessagesV2ResultSchema = v.array(v.object({
+});
+const signMessageResultSchema = v.object({
 	signature: v.string(),
-	message: v.string(),
 	messageHash: v.string(),
 	address: v.string(),
 	protocol: v.enum(MessageSigningProtocols)
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/signMessage/request.ts
+const bitcoinSignMessageParamsSchema = signMessageParamsSchema;
+const bitcoinSignMessageRequestSchema = createRequestSchema({
+	paramsSchema: bitcoinSignMessageParamsSchema,
+	method: bitcoinMethods.signMessage
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/signMessage/response.ts
+const bitcoinSignMessageResultSchema = signMessageResultSchema;
+const bitcoinSignMessageSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: bitcoinSignMessageResultSchema,
+	method: bitcoinMethods.signMessage
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/signMessageV2/request.ts
+const bitcoinSignMessageV2ParamsSchema = signMessageParamsSchema;
+const bitcoinSignMessageV2RequestSchema = createRequestSchema({
+	paramsSchema: bitcoinSignMessageV2ParamsSchema,
+	method: bitcoinMethods.bitcoin_signMessageV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/signMessageV2/response.ts
+const bitcoinSignMessageV2ResultSchema = signMessageResultSchema;
+const bitcoinSignMessageV2SuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: bitcoinSignMessageV2ResultSchema,
+	method: bitcoinMethods.bitcoin_signMessageV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/shared/signMultipleMessages.ts
+const signMultipleMessagesParamsSchema = v.array(signMessageParamsSchema);
+const signMultipleMessagesResultSchema = v.array(v.object({
+	...signMessageResultSchema.entries,
+	message: v.string()
 }));
-const bitcoinSignMultipleMessagesV2RequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(bitcoinSignMultipleMessagesV2MethodName),
-		params: bitcoinSignMultipleMessagesV2ParamsSchema,
-		id: v.string()
-	}).entries
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/signMultipleMessages/request.ts
+const bitcoinSignMultipleMessagesParamsSchema = signMultipleMessagesParamsSchema;
+const bitcoinSignMultipleMessagesRequestSchema = createRequestSchema({
+	paramsSchema: bitcoinSignMultipleMessagesParamsSchema,
+	method: bitcoinMethods.signMultipleMessages
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/signMultipleMessages/response.ts
+const bitcoinSignMultipleMessagesResultSchema = signMultipleMessagesResultSchema;
+const bitcoinSignMultipleMessagesSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: bitcoinSignMultipleMessagesResultSchema,
+	method: bitcoinMethods.signMultipleMessages
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/signMultipleMessagesV2/request.ts
+const bitcoinSignMultipleMessagesV2ParamsSchema = signMultipleMessagesParamsSchema;
+const bitcoinSignMultipleMessagesV2RequestSchema = createRequestSchema({
+	paramsSchema: bitcoinSignMultipleMessagesV2ParamsSchema,
+	method: bitcoinMethods.bitcoin_signMultipleMessagesV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/signMultipleMessagesV2/response.ts
+const bitcoinSignMultipleMessagesV2ResultSchema = signMultipleMessagesResultSchema;
+const bitcoinSignMultipleMessagesV2SuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: bitcoinSignMultipleMessagesV2ResultSchema,
+	method: bitcoinMethods.bitcoin_signMultipleMessagesV2
 });
 
 //#endregion
-//#region src/request/types/bitcoinMethods/signPSBT.ts
-const signPsbtMethodName = "signPsbt";
+//#region src/request/rpc/objects/namespaces/bitcoin/shared/signPsbt.ts
 const signPsbtParamsSchema = v.object({
 	psbt: v.string(),
 	signInputs: v.optional(v.record(v.string(), v.array(v.number()))),
-	broadcast: v.optional(v.boolean())
+	broadcast: v.optional(v.boolean(), false)
 });
 const signPsbtResultSchema = v.object({
 	psbt: v.string(),
 	txid: v.optional(v.string())
 });
-const signPsbtRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(signPsbtMethodName),
-		params: signPsbtParamsSchema,
-		id: v.string()
-	}).entries
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/signPsbt/request.ts
+const bitcoinSignPsbtParamsSchema = signPsbtParamsSchema;
+const bitcoinSignPsbtRequestSchema = createRequestSchema({
+	paramsSchema: bitcoinSignPsbtParamsSchema,
+	method: bitcoinMethods.signPsbt
 });
-const bitcoinSignPsbtV2MethodName = "bitcoin_signPsbtV2";
-const bitcoinSignPsbtV2ParamsSchema = v.object({
-	psbt: v.string(),
-	signInputs: v.optional(v.record(v.string(), v.array(v.number()))),
-	broadcast: v.optional(v.boolean())
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/signPsbt/response.ts
+const bitcoinSignPsbtResultSchema = signPsbtResultSchema;
+const bitcoinSignPsbtSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: bitcoinSignPsbtResultSchema,
+	method: bitcoinMethods.signPsbt
 });
-const bitcoinSignPsbtV2ResultSchema = v.object({
-	psbt: v.string(),
-	txid: v.optional(v.string())
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/signPsbtV2/request.ts
+const bitcoinSignPsbtV2ParamsSchema = signPsbtParamsSchema;
+const bitcoinSignPsbtV2RequestSchema = createRequestSchema({
+	paramsSchema: bitcoinSignPsbtV2ParamsSchema,
+	method: bitcoinMethods.bitcoin_signPsbtV2
 });
-const bitcoinSignPsbtV2RequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(bitcoinSignPsbtV2MethodName),
-		params: bitcoinSignPsbtV2ParamsSchema,
-		id: v.string()
-	}).entries
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/bitcoin/methods/signPsbtV2/response.ts
+const bitcoinSignPsbtV2ResultSchema = signPsbtResultSchema;
+const bitcoinSignPsbtV2SuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: bitcoinSignPsbtV2ResultSchema,
+	method: bitcoinMethods.bitcoin_signPsbtV2
 });
 
 //#endregion
-//#region src/request/types/ordinalsMethods.ts
-const getInscriptionsMethodName = "ord_getInscriptions";
-const getInscriptionsParamsSchema = v.object({
+//#region src/request/rpc/objects/namespaces/bitcoin/index.ts
+const bitcoinRequestSchema = v.variant("method", [
+	bitcoinGetAccountsRequestSchema,
+	bitcoinGetAddressesRequestSchema,
+	bitcoinGetAddressesV2RequestSchema,
+	bitcoinGetBalanceRequestSchema,
+	bitcoinGetBalanceV2RequestSchema,
+	bitcoinGetInfoRequestSchema,
+	bitcoinSendTransferRequestSchema,
+	bitcoinSendTransferV2RequestSchema,
+	bitcoinSignMessageRequestSchema,
+	bitcoinSignMessageV2RequestSchema,
+	bitcoinSignMultipleMessagesRequestSchema,
+	bitcoinSignMultipleMessagesV2RequestSchema,
+	bitcoinSignPsbtRequestSchema,
+	bitcoinSignPsbtV2RequestSchema
+]);
+const bitcoinSuccessResponseSchema = v.variant("~sats-connect-method", [
+	bitcoinGetAccountsSuccessResponseSchema,
+	bitcoinGetAddressesSuccessResponseSchema,
+	bitcoinGetAddressesV2SuccessResponseSchema,
+	bitcoinGetBalanceSuccessResponseSchema,
+	bitcoinGetBalanceV2SuccessResponseSchema,
+	bitcoinGetInfoSuccessResponseSchema,
+	bitcoinSendTransferSuccessResponseSchema,
+	bitcoinSendTransferV2SuccessResponseSchema,
+	bitcoinSignMessageSuccessResponseSchema,
+	bitcoinSignMessageV2SuccessResponseSchema,
+	bitcoinSignMultipleMessagesSuccessResponseSchema,
+	bitcoinSignMultipleMessagesV2SuccessResponseSchema,
+	bitcoinSignPsbtSuccessResponseSchema,
+	bitcoinSignPsbtV2SuccessResponseSchema
+]);
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/ordinals/methods/getInscriptions/request.ts
+const ordinalsGetInscriptionsParamsSchema = v.object({
 	offset: v.number(),
 	limit: v.number()
 });
-const getInscriptionsResultSchema = v.object({
+const ordinalsGetInscriptionsRequestSchema = createRequestSchema({
+	paramsSchema: ordinalsGetInscriptionsParamsSchema,
+	method: ordinalsMethods.ord_getInscriptions
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/ordinals/methods/getInscriptions/response.ts
+const ordinalsGetInscriptionsResultSchema = v.object({
 	total: v.number(),
 	limit: v.number(),
 	offset: v.number(),
@@ -1047,47 +1941,147 @@ const getInscriptionsResultSchema = v.object({
 		output: v.string()
 	}))
 });
-const getInscriptionsRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(getInscriptionsMethodName),
-		params: getInscriptionsParamsSchema,
-		id: v.string()
-	}).entries
+const ordinalsGetInscriptionsSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: ordinalsGetInscriptionsResultSchema,
+	method: ordinalsMethods.ord_getInscriptions
 });
-const sendInscriptionsMethodName = "ord_sendInscriptions";
-const sendInscriptionsParamsSchema = v.object({ transfers: v.array(v.object({
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/ordinals/methods/sendInscriptions/request.ts
+const ordinalsSendInscriptionsParamsSchema = v.object({ transfers: v.array(v.object({
 	address: v.string(),
 	inscriptionId: v.string()
 })) });
-const sendInscriptionsResultSchema = v.object({ txid: v.string() });
-const sendInscriptionsRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(sendInscriptionsMethodName),
-		params: sendInscriptionsParamsSchema,
-		id: v.string()
-	}).entries
+const ordinalsSendInscriptionsRequestSchema = createRequestSchema({
+	paramsSchema: ordinalsSendInscriptionsParamsSchema,
+	method: ordinalsMethods.ord_sendInscriptions
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/ordinals/methods/sendInscriptions/response.ts
+const ordinalsSendInscriptionsResultSchema = v.object({ txid: v.string() });
+const ordinalsSendInscriptionsSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: ordinalsSendInscriptionsResultSchema,
+	method: ordinalsMethods.ord_sendInscriptions
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/ordinals/index.ts
+const ordinalsRequestSchema = v.variant("method", [ordinalsGetInscriptionsRequestSchema, ordinalsSendInscriptionsRequestSchema]);
+const ordinalsSuccessResponseSchema = v.variant("~sats-connect-method", [ordinalsGetInscriptionsSuccessResponseSchema, ordinalsSendInscriptionsSuccessResponseSchema]);
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/runes/methods/estimateEtch/request.ts
+const etchTermsSchema$1 = v.object({
+	amount: v.optional(v.string()),
+	cap: v.optional(v.string()),
+	heightStart: v.optional(v.string()),
+	heightEnd: v.optional(v.string()),
+	offsetStart: v.optional(v.string()),
+	offsetEnd: v.optional(v.string())
+});
+const inscriptionDetailsSchema$1 = v.object({
+	contentType: v.string(),
+	contentBase64: v.string()
+});
+const runesEstimateEtchParamsSchema = v.object({
+	runeName: v.string(),
+	divisibility: v.optional(v.number()),
+	symbol: v.optional(v.string()),
+	premine: v.optional(v.string()),
+	isMintable: v.boolean(),
+	terms: v.optional(etchTermsSchema$1),
+	inscriptionDetails: v.optional(inscriptionDetailsSchema$1),
+	delegateInscriptionId: v.optional(v.string()),
+	destinationAddress: v.string(),
+	feeRate: v.number(),
+	appServiceFee: v.optional(v.number()),
+	appServiceFeeAddress: v.optional(v.string()),
+	network: v.optional(v.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 = v.object({
+	totalSize: v.number(),
+	totalCost: v.number(),
+	costBreakdown: v.object({
+		postage: v.number(),
+		networkFee: v.number(),
+		serviceFee: v.number(),
+		appServiceFee: v.number()
+	})
+});
+const runesEstimateEtchSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: runesEstimateEtchResultSchema,
+	method: runesMethods.runes_estimateEtch
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/runes/methods/estimateMint/request.ts
+const runesEstimateMintParamsSchema = v.object({
+	runeName: v.string(),
+	repeats: v.number(),
+	destinationAddress: v.string(),
+	feeRate: v.number(),
+	appServiceFee: v.optional(v.number()),
+	appServiceFeeAddress: v.optional(v.string()),
+	network: v.optional(v.enum(BitcoinNetworkType))
+});
+const runesEstimateMintRequestSchema = createRequestSchema({
+	paramsSchema: runesEstimateMintParamsSchema,
+	method: runesMethods.runes_estimateMint
 });
 
 //#endregion
-//#region src/request/types/runesMethods/estimateEtch.ts
-const runesEstimateEtchMethodName = "runes_estimateEtch";
+//#region src/request/rpc/objects/namespaces/runes/methods/estimateMint/response.ts
+const runesEstimateMintResultSchema = v.object({
+	totalSize: v.number(),
+	totalCost: v.number(),
+	costBreakdown: v.object({
+		postage: v.number(),
+		networkFee: v.number(),
+		serviceFee: v.number(),
+		appServiceFee: v.number()
+	})
+});
+const runesEstimateMintSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: runesEstimateMintResultSchema,
+	method: runesMethods.runes_estimateMint
+});
 
 //#endregion
-//#region src/request/types/runesMethods/estimateMint.ts
-const runesEstimateMintMethodName = "runes_estimateMint";
+//#region src/request/rpc/objects/namespaces/runes/methods/estimateRbfOrder/request.ts
+const runesEstimateRbfOrderParamsSchema = v.object({
+	orderId: v.string(),
+	newFeeRate: v.number(),
+	network: v.optional(v.enum(BitcoinNetworkType))
+});
+const runesEstimateRbfOrderRequestSchema = createRequestSchema({
+	paramsSchema: runesEstimateRbfOrderParamsSchema,
+	method: runesMethods.runes_estimateRbfOrder
+});
 
 //#endregion
-//#region src/request/types/runesMethods/estimateRbfOrder.ts
-const runesEstimateRbfOrderMethodName = "runes_estimateRbfOrder";
+//#region src/request/rpc/objects/namespaces/runes/methods/estimateRbfOrder/response.ts
+const runesEstimateRbfOrderResultSchema = v.object({
+	rbfCost: v.number(),
+	fundingAddress: v.string()
+});
+const runesEstimateRbfOrderSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: runesEstimateRbfOrderResultSchema,
+	method: runesMethods.runes_estimateRbfOrder
+});
 
 //#endregion
-//#region src/request/types/runesMethods/etch.ts
-const runesEtchMethodName = "runes_etch";
+//#region src/request/rpc/objects/namespaces/runes/methods/etch/request.ts
 const etchTermsSchema = v.object({
-	amount: v.string(),
-	cap: v.string(),
+	amount: v.optional(v.string()),
+	cap: v.optional(v.string()),
 	heightStart: v.optional(v.string()),
 	heightEnd: v.optional(v.string()),
 	offsetStart: v.optional(v.string()),
@@ -1103,34 +2097,43 @@ const runesEtchParamsSchema = v.object({
 	symbol: v.optional(v.string()),
 	premine: v.optional(v.string()),
 	isMintable: v.boolean(),
+	terms: v.optional(etchTermsSchema),
+	inscriptionDetails: v.optional(inscriptionDetailsSchema),
 	delegateInscriptionId: v.optional(v.string()),
 	destinationAddress: v.string(),
 	refundAddress: v.string(),
 	feeRate: v.number(),
 	appServiceFee: v.optional(v.number()),
 	appServiceFeeAddress: v.optional(v.string()),
-	terms: v.optional(etchTermsSchema),
-	inscriptionDetails: v.optional(inscriptionDetailsSchema),
 	network: v.optional(v.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 = v.object({
 	orderId: v.string(),
 	fundTransactionId: v.string(),
 	fundingAddress: v.string()
 });
-const runesEtchRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(runesEtchMethodName),
-		params: runesEtchParamsSchema,
-		id: v.string()
-	}).entries
+const runesEtchSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: runesEtchResultSchema,
+	method: runesMethods.runes_etch
 });
 
 //#endregion
-//#region src/request/types/runesMethods/getBalance.ts
-const runesGetBalanceMethodName = "runes_getBalance";
+//#region src/request/rpc/objects/namespaces/runes/methods/getBalance/request.ts
 const runesGetBalanceParamsSchema = v.nullish(v.null());
+const runesGetBalanceRequestSchema = createRequestSchema({
+	paramsSchema: runesGetBalanceParamsSchema,
+	method: runesMethods.runes_getBalance
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/runes/methods/getBalance/response.ts
 const runesGetBalanceResultSchema = v.object({ balances: v.array(v.object({
 	runeName: v.string(),
 	amount: v.string(),
@@ -1139,22 +2142,47 @@ const runesGetBalanceResultSchema = v.object({ balances: v.array(v.object({
 	inscriptionId: v.nullish(v.string()),
 	spendableBalance: v.string()
 })) });
-const runesGetBalanceRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(runesGetBalanceMethodName),
-		params: runesGetBalanceParamsSchema,
-		id: v.string()
-	}).entries
+const runesGetBalanceSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: runesGetBalanceResultSchema,
+	method: runesMethods.runes_getBalance
 });
 
 //#endregion
-//#region src/request/types/runesMethods/getOrder.ts
-const runesGetOrderMethodName = "runes_getOrder";
+//#region src/request/rpc/objects/namespaces/runes/methods/getOrder/request.ts
+const runesGetOrderParamsSchema = v.object({
+	id: v.string(),
+	network: v.optional(v.enum(BitcoinNetworkType))
+});
+const runesGetOrderRequestSchema = createRequestSchema({
+	paramsSchema: runesGetOrderParamsSchema,
+	method: runesMethods.runes_getOrder
+});
 
 //#endregion
-//#region src/request/types/runesMethods/mint.ts
-const runesMintMethodName = "runes_mint";
+//#region src/request/rpc/objects/namespaces/runes/methods/getOrder/response.ts
+const runesGetOrderResultSchema = v.object({
+	id: v.string(),
+	orderType: v.union([v.literal("rune_mint"), v.literal("rune_etch")]),
+	state: v.union([
+		v.literal("new"),
+		v.literal("pending"),
+		v.literal("executing"),
+		v.literal("complete"),
+		v.literal("failed"),
+		v.literal("refunded"),
+		v.literal("stale")
+	]),
+	fundingAddress: v.string(),
+	reason: v.optional(v.string()),
+	createdAt: v.string()
+});
+const runesGetOrderSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: runesGetOrderResultSchema,
+	method: runesMethods.runes_getOrder
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/runes/methods/mint/request.ts
 const runesMintParamsSchema = v.object({
 	appServiceFee: v.optional(v.number()),
 	appServiceFeeAddress: v.optional(v.string()),
@@ -1165,49 +2193,108 @@ const runesMintParamsSchema = v.object({
 	runeName: v.string(),
 	network: v.optional(v.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 = v.object({
 	orderId: v.string(),
 	fundTransactionId: v.string(),
 	fundingAddress: v.string()
 });
-const runesMintRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(runesMintMethodName),
-		params: runesMintParamsSchema,
-		id: v.string()
-	}).entries
+const runesMintSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: runesMintResultSchema,
+	method: runesMethods.runes_mint
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/runes/methods/rbfOrder/request.ts
+const runesRbfOrderParamsSchema = v.object({
+	orderId: v.string(),
+	newFeeRate: v.number(),
+	network: v.optional(v.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 = v.object({
+	orderId: v.string(),
+	fundRBFTransactionId: v.string(),
+	fundingAddress: v.string()
+});
+const runesRbfOrderSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: runesRbfOrderResultSchema,
+	method: runesMethods.runes_rbfOrder
 });
 
 //#endregion
-//#region src/request/types/runesMethods/rbfOrder.ts
-const runesRbfOrderMethodName = "runes_rbfOrder";
+//#region src/request/rpc/objects/namespaces/runes/methods/transfer/request.ts
+const runesTransferParamsSchema = v.object({
+	recipients: v.array(v.object({
+		runeName: v.string(),
+		amount: v.string(),
+		address: v.string()
+	})),
+	network: v.optional(v.enum(BitcoinNetworkType))
+});
+const runesTransferRequestSchema = createRequestSchema({
+	paramsSchema: runesTransferParamsSchema,
+	method: runesMethods.runes_transfer
+});
 
 //#endregion
-//#region src/request/types/runesMethods/transfer.ts
-const runesTransferMethodName = "runes_transfer";
-const runesTransferParamsSchema = v.object({ recipients: v.array(v.object({
-	runeName: v.string(),
-	amount: v.string(),
-	address: v.string()
-})) });
+//#region src/request/rpc/objects/namespaces/runes/methods/transfer/response.ts
 const runesTransferResultSchema = v.object({ txid: v.string() });
-const runesTransferRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(runesTransferMethodName),
-		params: runesTransferParamsSchema,
-		id: v.string()
-	}).entries
-});
+const runesTransferSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: runesTransferResultSchema,
+	method: runesMethods.runes_transfer
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/runes/index.ts
+const runesRequestSchema = v.variant("method", [
+	runesEstimateEtchRequestSchema,
+	runesEstimateMintRequestSchema,
+	runesEstimateRbfOrderRequestSchema,
+	runesEtchRequestSchema,
+	runesGetBalanceRequestSchema,
+	runesGetOrderRequestSchema,
+	runesMintRequestSchema,
+	runesRbfOrderRequestSchema,
+	runesTransferRequestSchema
+]);
+const runesSuccessResponseSchema = v.variant("~sats-connect-method", [
+	runesEstimateEtchSuccessResponseSchema,
+	runesEstimateMintSuccessResponseSchema,
+	runesEstimateRbfOrderSuccessResponseSchema,
+	runesEtchSuccessResponseSchema,
+	runesGetBalanceSuccessResponseSchema,
+	runesGetOrderSuccessResponseSchema,
+	runesMintSuccessResponseSchema,
+	runesRbfOrderSuccessResponseSchema,
+	runesTransferSuccessResponseSchema
+]);
 
 //#endregion
-//#region src/request/types/sparkMethods/flashnetMethods/clawbackFunds.ts
-const sparkFlashnetClawbackFundsMethodName = "spark_flashnet_clawbackFunds";
+//#region src/request/rpc/objects/namespaces/spark/methods/flashnetClawbackFunds/request.ts
 const sparkFlashnetClawbackFundsParamsSchema = v.object({
 	sparkTransferId: v.string(),
 	lpIdentityPublicKey: v.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 = v.object({
 	requestId: v.string(),
 	accepted: v.boolean(),
@@ -1215,18 +2302,13 @@ const sparkFlashnetClawbackFundsResultSchema = v.object({
 	sparkStatusTrackingId: v.optional(v.string()),
 	error: v.optional(v.string())
 });
-const sparkFlashnetClawbackFundsRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(sparkFlashnetClawbackFundsMethodName),
-		params: sparkFlashnetClawbackFundsParamsSchema,
-		id: v.string()
-	}).entries
+const sparkFlashnetClawbackFundsSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: sparkFlashnetClawbackFundsResultSchema,
+	method: sparkMethods.spark_flashnet_clawbackFunds
 });
 
 //#endregion
-//#region src/request/types/sparkMethods/flashnetMethods/executeRouteSwap.ts
-const sparkFlashnetExecuteRouteSwapMethodName = "spark_flashnet_executeRouteSwap";
+//#region src/request/rpc/objects/namespaces/spark/methods/flashnetExecuteRouteSwap/request.ts
 const sparkFlashnetExecuteRouteSwapParamsSchema = v.object({
 	hops: v.array(v.object({
 		poolId: v.string(),
@@ -1241,6 +2323,13 @@ const sparkFlashnetExecuteRouteSwapParamsSchema = v.object({
 	integratorFeeRateBps: v.optional(v.number()),
 	integratorPublicKey: v.optional(v.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 = v.object({
 	requestId: v.string(),
 	accepted: v.boolean(),
@@ -1249,18 +2338,13 @@ const sparkFlashnetExecuteRouteSwapResultSchema = v.object({
 	finalOutboundTransferId: v.string(),
 	error: v.optional(v.string())
 });
-const sparkFlashnetExecuteRouteSwapRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(sparkFlashnetExecuteRouteSwapMethodName),
-		params: sparkFlashnetExecuteRouteSwapParamsSchema,
-		id: v.string()
-	}).entries
+const sparkFlashnetExecuteRouteSwapSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: sparkFlashnetExecuteRouteSwapResultSchema,
+	method: sparkMethods.spark_flashnet_executeRouteSwap
 });
 
 //#endregion
-//#region src/request/types/sparkMethods/flashnetMethods/executeSwap.ts
-const sparkFlashnetExecuteSwapMethodName = "spark_flashnet_executeSwap";
+//#region src/request/rpc/objects/namespaces/spark/methods/flashnetExecuteSwap/request.ts
 const sparkFlashnetExecuteSwapParamsSchema = v.object({
 	poolId: v.string(),
 	assetInAddress: v.string(),
@@ -1271,6 +2355,13 @@ const sparkFlashnetExecuteSwapParamsSchema = v.object({
 	integratorFeeRateBps: v.optional(v.number()),
 	integratorPublicKey: v.optional(v.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 = v.object({
 	requestId: v.string(),
 	accepted: v.boolean(),
@@ -1282,49 +2373,49 @@ const sparkFlashnetExecuteSwapResultSchema = v.object({
 	outboundTransferId: v.optional(v.string()),
 	error: v.optional(v.string())
 });
-const sparkFlashnetExecuteSwapRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(sparkFlashnetExecuteSwapMethodName),
-		params: sparkFlashnetExecuteSwapParamsSchema,
-		id: v.string()
-	}).entries
+const sparkFlashnetExecuteSwapSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: sparkFlashnetExecuteSwapResultSchema,
+	method: sparkMethods.spark_flashnet_executeSwap
 });
 
 //#endregion
-//#region src/request/types/sparkMethods/flashnetMethods/getClawbackEligibleTransfers.ts
-const sparkGetClawbackEligibleTransfersMethodName = "spark_flashnet_getClawbackEligibleTransfers";
+//#region src/request/rpc/objects/namespaces/spark/methods/flashnetGetClawbackEligibleTransfers/request.ts
 const sparkGetClawbackEligibleTransfersParamsSchema = v.nullish(v.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 = v.object({ eligibleTransfers: v.array(v.object({
 	txId: v.string(),
 	createdAt: v.string(),
 	lpIdentityPublicKey: v.string()
 })) });
-const sparkGetClawbackEligibleTransfersRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(sparkGetClawbackEligibleTransfersMethodName),
-		params: sparkGetClawbackEligibleTransfersParamsSchema,
-		id: v.string()
-	}).entries
+const sparkGetClawbackEligibleTransfersSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: sparkGetClawbackEligibleTransfersResultSchema,
+	method: sparkMethods.spark_flashnet_getClawbackEligibleTransfers
 });
 
 //#endregion
-//#region src/request/types/sparkMethods/flashnetMethods/getJwt.ts
-const sparkFlashnetGetJwtMethodName = "spark_flashnet_getJwt";
+//#region src/request/rpc/objects/namespaces/spark/methods/flashnetGetJwt/request.ts
 const sparkFlashnetGetJwtParamsSchema = v.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 = v.object({ jwt: v.string() });
-const sparkFlashnetGetJwtRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(sparkFlashnetGetJwtMethodName),
-		params: sparkFlashnetGetJwtParamsSchema,
-		id: v.string()
-	}).entries
+const sparkFlashnetGetJwtSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: sparkFlashnetGetJwtResultSchema,
+	method: sparkMethods.spark_flashnet_getJwt
 });
 
 //#endregion
-//#region src/request/types/sparkMethods/flashnetMethods/intents/addLiquidity.ts
+//#region src/request/rpc/objects/namespaces/spark/methods/flashnetSignIntent/intents/addLiquidity.ts
 const sparkFlashnetAddLiquidityIntentSchema = v.object({
 	type: v.literal("addLiquidity"),
 	data: v.object({
@@ -1341,7 +2432,7 @@ const sparkFlashnetAddLiquidityIntentSchema = v.object({
 });
 
 //#endregion
-//#region src/request/types/sparkMethods/flashnetMethods/intents/clawback.ts
+//#region src/request/rpc/objects/namespaces/spark/methods/flashnetSignIntent/intents/clawback.ts
 const sparkFlashnetClawbackIntentSchema = v.object({
 	type: v.literal("clawback"),
 	data: v.object({
@@ -1353,867 +2444,640 @@ const sparkFlashnetClawbackIntentSchema = v.object({
 });
 
 //#endregion
-//#region src/request/types/sparkMethods/flashnetMethods/intents/confirmInitialDeposit.ts
+//#region src/request/rpc/objects/namespaces/spark/methods/flashnetSignIntent/intents/confirmInitialDeposit.ts
 const sparkFlashnetConfirmInitialDepositIntentSchema = v.object({
 	type: v.literal("confirmInitialDeposit"),
-	data: v.object({
-		poolId: v.string(),
-		assetASparkTransferId: v.string(),
-		poolOwnerPublicKey: v.string(),
-		nonce: v.string()
-	})
-});
-
-//#endregion
-//#region src/request/types/sparkMethods/flashnetMethods/intents/createConstantProductPool.ts
-const sparkFlashnetCreateConstantProductPoolIntentSchema = v.object({
-	type: v.literal("createConstantProductPool"),
-	data: v.object({
-		poolOwnerPublicKey: v.string(),
-		assetAAddress: v.string(),
-		assetBAddress: v.string(),
-		lpFeeRateBps: v.union([v.number(), v.string()]),
-		totalHostFeeRateBps: v.union([v.number(), v.string()]),
-		nonce: v.string()
-	})
-});
-
-//#endregion
-//#region src/request/types/sparkMethods/flashnetMethods/intents/createSingleSidedPool.ts
-const sparkFlashnetCreateSingleSidedPoolIntentSchema = v.object({
-	type: v.literal("createSingleSidedPool"),
-	data: v.object({
-		assetAAddress: v.string(),
-		assetBAddress: v.string(),
-		assetAInitialReserve: v.string(),
-		virtualReserveA: v.union([v.number(), v.string()]),
-		virtualReserveB: v.union([v.number(), v.string()]),
-		threshold: v.union([v.number(), v.string()]),
-		lpFeeRateBps: v.union([v.number(), v.string()]),
-		totalHostFeeRateBps: v.union([v.number(), v.string()]),
-		poolOwnerPublicKey: v.string(),
-		nonce: v.string()
-	})
-});
-
-//#endregion
-//#region src/request/types/sparkMethods/flashnetMethods/intents/removeLiquidity.ts
-const sparkFlashnetRemoveLiquidityIntentSchema = v.object({
-	type: v.literal("removeLiquidity"),
-	data: v.object({
-		userPublicKey: v.string(),
-		poolId: v.string(),
-		lpTokensToRemove: v.string(),
-		nonce: v.string()
-	})
-});
-
-//#endregion
-//#region src/request/types/sparkMethods/flashnetMethods/intents/routeSwap.ts
-const sparkFlashnetRouteSwapIntentSchema = v.object({
-	type: v.literal("executeRouteSwap"),
-	data: v.object({
-		userPublicKey: v.string(),
-		initialSparkTransferId: v.string(),
-		hops: v.array(v.object({
-			poolId: v.string(),
-			inputAssetAddress: v.string(),
-			outputAssetAddress: v.string(),
-			hopIntegratorFeeRateBps: v.optional(v.union([v.number(), v.string()]))
-		})),
-		inputAmount: v.string(),
-		maxRouteSlippageBps: v.union([v.number(), v.string()]),
-		minAmountOut: v.string(),
-		defaultIntegratorFeeRateBps: v.optional(v.union([v.number(), v.string()])),
-		nonce: v.string()
-	})
-});
-
-//#endregion
-//#region src/request/types/sparkMethods/flashnetMethods/intents/swap.ts
-const sparkFlashnetSwapIntentSchema = v.object({
-	type: v.literal("executeSwap"),
-	data: v.object({
-		userPublicKey: v.string(),
-		poolId: v.string(),
-		transferId: v.string(),
-		assetInAddress: v.string(),
-		assetOutAddress: v.string(),
-		amountIn: v.string(),
-		maxSlippageBps: v.union([v.number(), v.string()]),
-		minAmountOut: v.string(),
-		totalIntegratorFeeRateBps: v.optional(v.union([v.number(), v.string()])),
-		nonce: v.string()
-	})
-});
-
-//#endregion
-//#region src/request/types/sparkMethods/flashnetMethods/signIntent.ts
-const sparkFlashnetSignIntentMethodName = "spark_flashnet_signIntent";
-const sparkFlashnetSignIntentParamsSchema = v.union([
-	sparkFlashnetSwapIntentSchema,
-	sparkFlashnetRouteSwapIntentSchema,
-	sparkFlashnetAddLiquidityIntentSchema,
-	sparkFlashnetClawbackIntentSchema,
-	sparkFlashnetConfirmInitialDepositIntentSchema,
-	sparkFlashnetCreateConstantProductPoolIntentSchema,
-	sparkFlashnetCreateSingleSidedPoolIntentSchema,
-	sparkFlashnetRemoveLiquidityIntentSchema
-]);
-const sparkFlashnetSignIntentResultSchema = v.object({ signature: v.string() });
-const sparkFlashnetSignIntentRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(sparkFlashnetSignIntentMethodName),
-		params: sparkFlashnetSignIntentParamsSchema,
-		id: v.string()
-	}).entries
-});
-
-//#endregion
-//#region src/request/types/sparkMethods/flashnetMethods/signStructuredMessage.ts
-const sparkFlashnetSignStructuredMessageMethodName = "spark_flashnet_signStructuredMessage";
-const sparkFlashnetSignStructuredMessageParamsSchema = v.object({ message: v.string() });
-const sparkFlashnetSignStructuredMessageResultSchema = v.object({
-	message: v.string(),
-	signature: v.string()
-});
-const sparkFlashnetSignStructuredMessageRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(sparkFlashnetSignStructuredMessageMethodName),
-		params: sparkFlashnetSignStructuredMessageParamsSchema,
-		id: v.string()
-	}).entries
-});
-
-//#endregion
-//#region src/request/types/sparkMethods/getAddresses.ts
-const sparkGetAddressesMethodName = "spark_getAddresses";
-const sparkGetAddressesParamsSchema = v.nullish(v.object({ message: v.optional(v.string()) }));
-const sparkGetAddressesResultSchema = v.object({
-	addresses: v.array(addressSchema),
-	network: getNetworkResultSchema
-});
-const sparkGetAddressesRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(sparkGetAddressesMethodName),
-		params: sparkGetAddressesParamsSchema,
-		id: v.string()
-	}).entries
-});
-const sparkGetAddressesV2MethodName = "spark_getAddressesV2";
-const sparkGetAddressesV2ParamsSchema = v.nullish(v.object({ message: v.optional(v.string()) }));
-const sparkGetAddressesV2ResultSchema = v.object({
-	addresses: v.array(addressSchema),
-	network: sparkNetworkConfigurationSchema
-});
-const sparkGetAddressesV2RequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(sparkGetAddressesV2MethodName),
-		params: sparkGetAddressesV2ParamsSchema,
-		id: v.string()
-	}).entries
-});
-
-//#endregion
-//#region src/request/types/sparkMethods/getBalance.ts
-const sparkGetBalanceMethodName = "spark_getBalance";
-const sparkGetBalanceParamsSchema = v.nullish(v.null());
-const sparkGetBalanceResultSchema = v.object({
-	balance: v.string(),
-	tokenBalances: v.array(v.object({
-		balance: v.string(),
-		tokenMetadata: v.object({
-			tokenIdentifier: v.string(),
-			tokenName: v.string(),
-			tokenTicker: v.string(),
-			decimals: v.number(),
-			maxSupply: v.string()
-		})
-	}))
-});
-const sparkGetBalanceRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(sparkGetBalanceMethodName),
-		params: sparkGetBalanceParamsSchema,
-		id: v.string()
-	}).entries
-});
-
-//#endregion
-//#region src/request/types/sparkMethods/signMessage.ts
-const sparkSignMessageMethodName = "spark_signMessage";
-const sparkSignMessageParamsSchema = v.object({ message: v.string() });
-const sparkSignMessageResultSchema = v.object({ signature: v.string() });
-const sparkSignMessageRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(sparkSignMessageMethodName),
-		params: sparkSignMessageParamsSchema,
-		id: v.string()
-	}).entries
-});
-
-//#endregion
-//#region src/request/types/sparkMethods/transfer.ts
-const sparkTransferMethodName = "spark_transfer";
-const sparkTransferParamsSchema = v.object({
-	amountSats: v.union([v.number(), v.string()]),
-	receiverSparkAddress: v.string()
-});
-const sparkTransferResultSchema = v.object({ id: v.string() });
-const sparkTransferRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(sparkTransferMethodName),
-		params: sparkTransferParamsSchema,
-		id: v.string()
-	}).entries
-});
-
-//#endregion
-//#region src/request/types/sparkMethods/transferToken.ts
-const sparkTransferTokenMethodName = "spark_transferToken";
-const sparkTransferTokenParamsSchema = v.object({
-	tokenAmount: v.union([v.number(), v.string()]),
-	tokenIdentifier: v.string(),
-	receiverSparkAddress: v.string()
-});
-const sparkTransferTokenResultSchema = v.object({ id: v.string() });
-const sparkTransferTokenRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(sparkTransferTokenMethodName),
-		params: sparkTransferTokenParamsSchema,
-		id: v.string()
-	}).entries
-});
-
-//#endregion
-//#region src/request/types/stacksMethods/callContract.ts
-const stacksCallContractMethodName = "stx_callContract";
-const stacksCallContractParamsSchema = v.object({
-	contract: v.string(),
-	functionName: v.string(),
-	arguments: v.optional(v.array(v.string())),
-	functionArgs: v.optional(v.array(v.string())),
-	postConditions: v.optional(v.array(v.string())),
-	postConditionMode: v.optional(v.union([v.literal("allow"), v.literal("deny")]))
-});
-const stacksCallContractResultSchema = v.object({
-	txid: v.string(),
-	transaction: v.string()
-});
-const stacksCallContractRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(stacksCallContractMethodName),
-		params: stacksCallContractParamsSchema,
-		id: v.string()
-	}).entries
-});
-
-//#endregion
-//#region src/request/types/stacksMethods/deployContract.ts
-const stacksDeployContractMethodName = "stx_deployContract";
-const stacksDeployContractParamsSchema = v.object({
-	name: v.string(),
-	clarityCode: v.string(),
-	clarityVersion: v.optional(v.number()),
-	postConditions: v.optional(v.array(v.string())),
-	postConditionMode: v.optional(v.union([v.literal("allow"), v.literal("deny")]))
-});
-const stacksDeployContractResultSchema = v.object({
-	txid: v.string(),
-	transaction: v.string()
-});
-const stacksDeployContractRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(stacksDeployContractMethodName),
-		params: stacksDeployContractParamsSchema,
-		id: v.string()
-	}).entries
-});
-
-//#endregion
-//#region src/request/types/stacksMethods/getAccounts.ts
-const stacksGetAccountsMethodName = "stx_getAccounts";
-const stacksGetAccountsParamsSchema = v.nullish(v.null());
-const stacksGetAccountsResultSchema = v.object({
-	addresses: v.array(v.object({
-		address: v.string(),
-		publicKey: v.string(),
-		gaiaHubUrl: v.string(),
-		gaiaAppKey: v.string()
-	})),
-	network: getNetworkResultSchema
-});
-const stacksGetAccountsRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(stacksGetAccountsMethodName),
-		params: stacksGetAccountsParamsSchema,
-		id: v.string()
-	}).entries
-});
-
-//#endregion
-//#region src/request/types/stacksMethods/getAddresses.ts
-const stacksGetAddressesMethodName = "stx_getAddresses";
-const stacksGetAddressesParamsSchema = v.nullish(v.object({ message: v.optional(v.string()) }));
-const stacksGetAddressesResultSchema = v.object({
-	addresses: v.array(addressSchema),
-	network: getNetworkResultSchema
-});
-const stacksGetAddressesRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(stacksGetAddressesMethodName),
-		params: stacksGetAddressesParamsSchema,
-		id: v.string()
-	}).entries
-});
-const stacksGetAddressesV2MethodName = "stacks_getAddressesV2";
-const stacksGetAddressesV2ParamsSchema = v.nullish(v.object({ message: v.optional(v.string()) }));
-const stacksGetAddressesV2ResultSchema = v.object({
-	addresses: v.array(addressSchema),
-	network: stacksNetworkConfigurationSchema
-});
-const stacksGetAddressesV2RequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(stacksGetAddressesV2MethodName),
-		params: stacksGetAddressesV2ParamsSchema,
-		id: v.string()
-	}).entries
-});
-
-//#endregion
-//#region src/request/types/stacksMethods/signMessage.ts
-const stacksSignMessageMethodName = "stx_signMessage";
-const stacksSignMessageParamsSchema = v.object({ message: v.string() });
-const stacksSignMessageResultSchema = v.object({
-	signature: v.string(),
-	publicKey: v.string()
-});
-const stacksSignMessageRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(stacksSignMessageMethodName),
-		params: stacksSignMessageParamsSchema,
-		id: v.string()
-	}).entries
-});
-
-//#endregion
-//#region src/request/types/stacksMethods/signStructuredMessage.ts
-const stacksSignStructuredMessageMethodName = "stx_signStructuredMessage";
-const stacksSignStructuredMessageParamsSchema = v.object({
-	domain: v.string(),
-	message: v.string(),
-	publicKey: v.optional(v.string())
-});
-const stacksSignStructuredMessageResultSchema = v.object({
-	signature: v.string(),
-	publicKey: v.string()
-});
-const stacksSignStructuredMessageRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(stacksSignStructuredMessageMethodName),
-		params: stacksSignStructuredMessageParamsSchema,
-		id: v.string()
-	}).entries
+	data: v.object({
+		poolId: v.string(),
+		assetASparkTransferId: v.string(),
+		poolOwnerPublicKey: v.string(),
+		nonce: v.string()
+	})
 });
 
 //#endregion
-//#region src/request/types/stacksMethods/signTransaction.ts
-const stacksSignTransactionMethodName = "stx_signTransaction";
-const stacksSignTransactionParamsSchema = v.object({
-	transaction: v.string(),
-	pubkey: v.optional(v.string()),
-	broadcast: v.optional(v.boolean())
-});
-const stacksSignTransactionResultSchema = v.object({ transaction: v.string() });
-const stacksSignTransactionRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(stacksSignTransactionMethodName),
-		params: stacksSignTransactionParamsSchema,
-		id: v.string()
-	}).entries
+//#region src/request/rpc/objects/namespaces/spark/methods/flashnetSignIntent/intents/createConstantProductPool.ts
+const sparkFlashnetCreateConstantProductPoolIntentSchema = v.object({
+	type: v.literal("createConstantProductPool"),
+	data: v.object({
+		poolOwnerPublicKey: v.string(),
+		assetAAddress: v.string(),
+		assetBAddress: v.string(),
+		lpFeeRateBps: v.union([v.number(), v.string()]),
+		totalHostFeeRateBps: v.union([v.number(), v.string()]),
+		nonce: v.string()
+	})
 });
 
 //#endregion
-//#region src/request/types/stacksMethods/signTransactions.ts
-const stacksSignTransactionsMethodName = "stx_signTransactions";
-const stacksSignTransactionsParamsSchema = v.object({
-	transactions: v.pipe(v.array(v.pipe(v.string(), v.check((hex) => {
-		return true;
-	}, "Invalid hex-encoded Stacks transaction."))), v.minLength(1)),
-	broadcast: v.optional(v.boolean())
-});
-const stacksSignTransactionsResultSchema = v.object({ transactions: v.array(v.string()) });
-const stacksSignTransactionsRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(stacksSignTransactionsMethodName),
-		params: stacksSignTransactionsParamsSchema,
-		id: v.string()
-	}).entries
+//#region src/request/rpc/objects/namespaces/spark/methods/flashnetSignIntent/intents/createSingleSidedPool.ts
+const sparkFlashnetCreateSingleSidedPoolIntentSchema = v.object({
+	type: v.literal("createSingleSidedPool"),
+	data: v.object({
+		assetAAddress: v.string(),
+		assetBAddress: v.string(),
+		assetAInitialReserve: v.string(),
+		virtualReserveA: v.union([v.number(), v.string()]),
+		virtualReserveB: v.union([v.number(), v.string()]),
+		threshold: v.union([v.number(), v.string()]),
+		lpFeeRateBps: v.union([v.number(), v.string()]),
+		totalHostFeeRateBps: v.union([v.number(), v.string()]),
+		poolOwnerPublicKey: v.string(),
+		nonce: v.string()
+	})
 });
 
 //#endregion
-//#region src/request/types/stacksMethods/transferStx.ts
-const stacksTransferStxMethodName = "stx_transferStx";
-const stacksTransferStxParamsSchema = v.object({
-	amount: v.union([v.number(), v.string()]),
-	recipient: v.string(),
-	memo: v.optional(v.string()),
-	version: v.optional(v.string()),
-	postConditionMode: v.optional(v.number()),
-	postConditions: v.optional(v.array(v.string())),
-	pubkey: v.optional(v.string())
-});
-const stacksTransferStxResultSchema = v.object({
-	txid: v.string(),
-	transaction: v.string()
-});
-const stacksTransferStxRequestMessageSchema = v.object({
-	...rpcRequestMessageSchema.entries,
-	...v.object({
-		method: v.literal(stacksTransferStxMethodName),
-		params: stacksTransferStxParamsSchema,
-		id: v.string()
-	}).entries
+//#region src/request/rpc/objects/namespaces/spark/methods/flashnetSignIntent/intents/removeLiquidity.ts
+const sparkFlashnetRemoveLiquidityIntentSchema = v.object({
+	type: v.literal("removeLiquidity"),
+	data: v.object({
+		userPublicKey: v.string(),
+		poolId: v.string(),
+		lpTokensToRemove: v.string(),
+		nonce: v.string()
+	})
 });
 
 //#endregion
-//#region src/request/index.ts
-const cache = {};
-const requestInternal = async (provider, method, params) => {
-	const response = await provider.request(method, params);
-	if (v.is(rpcErrorResponseMessageSchema, response)) return {
-		status: "error",
-		error: response.error
-	};
-	if (v.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);
-};
+//#region src/request/rpc/objects/namespaces/spark/methods/flashnetSignIntent/intents/routeSwap.ts
+const sparkFlashnetRouteSwapIntentSchema = v.object({
+	type: v.literal("executeRouteSwap"),
+	data: v.object({
+		userPublicKey: v.string(),
+		initialSparkTransferId: v.string(),
+		hops: v.array(v.object({
+			poolId: v.string(),
+			inputAssetAddress: v.string(),
+			outputAssetAddress: v.string(),
+			hopIntegratorFeeRateBps: v.optional(v.union([v.number(), v.string()]))
+		})),
+		inputAmount: v.string(),
+		maxRouteSlippageBps: v.union([v.number(), v.string()]),
+		minAmountOut: v.string(),
+		defaultIntegratorFeeRateBps: v.optional(v.union([v.number(), v.string()])),
+		nonce: v.string()
+	})
+});
 
 //#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.create({ baseURL: ORDINALS_API_BASE_URL(network) });
-	}
-	parseError = (error) => {
-		return {
-			code: error.response?.status,
-			message: JSON.stringify(error.response?.data)
-		};
-	};
-	estimateMintCost = async (mintParams) => {
-		try {
-			return { data: (await this.client.post("/runes/mint/estimate", { ...mintParams })).data };
-		} catch (error) {
-			const err = error;
-			return { error: this.parseError(err) };
-		}
-	};
-	estimateEtchCost = async (etchParams) => {
-		try {
-			return { data: (await this.client.post("/runes/etch/estimate", { ...etchParams })).data };
-		} catch (error) {
-			const err = error;
-			return { error: this.parseError(err) };
-		}
-	};
-	createMintOrder = async (mintOrderParams) => {
-		try {
-			return { data: (await this.client.post("/runes/mint/orders", { ...mintOrderParams })).data };
-		} catch (error) {
-			const err = error;
-			return { error: this.parseError(err) };
-		}
-	};
-	createEtchOrder = async (etchOrderParams) => {
-		try {
-			return { data: (await this.client.post("/runes/etch/orders", { ...etchOrderParams })).data };
-		} catch (error) {
-			const err = error;
-			return { error: this.parseError(err) };
-		}
-	};
-	executeMint = async (orderId, fundTransactionId) => {
-		try {
-			return { data: (await this.client.post(`/runes/mint/orders/${orderId}/execute`, { fundTransactionId })).data };
-		} catch (error) {
-			const err = error;
-			return { error: this.parseError(err) };
-		}
-	};
-	executeEtch = async (orderId, fundTransactionId) => {
-		try {
-			return { data: (await this.client.post(`/runes/etch/orders/${orderId}/execute`, { fundTransactionId })).data };
-		} catch (error) {
-			const err = error;
-			return { error: this.parseError(err) };
-		}
-	};
-	getOrder = async (orderId) => {
-		try {
-			return { data: (await this.client.get(`/orders/${orderId}`)).data };
-		} catch (error) {
-			const err = error;
-			return { error: this.parseError(err) };
-		}
-	};
-	rbfOrder = async (rbfRequest) => {
-		const { orderId, newFeeRate } = rbfRequest;
-		try {
-			return { data: (await this.client.post(`/orders/${orderId}/rbf-estimate`, { newFeeRate })).data };
-		} catch (error) {
-			const err = error;
-			return { error: this.parseError(err) };
-		}
-	};
-};
-const clients = {};
-const getRunesApiClient = (network = BitcoinNetworkType.Mainnet) => {
-	if (!clients[network]) clients[network] = new RunesApi(network);
-	return clients[network];
-};
+//#region src/request/rpc/objects/namespaces/spark/methods/flashnetSignIntent/intents/swap.ts
+const sparkFlashnetSwapIntentSchema = v.object({
+	type: v.literal("executeSwap"),
+	data: v.object({
+		userPublicKey: v.string(),
+		poolId: v.string(),
+		transferId: v.string(),
+		assetInAddress: v.string(),
+		assetOutAddress: v.string(),
+		amountIn: v.string(),
+		maxSlippageBps: v.union([v.number(), v.string()]),
+		minAmountOut: v.string(),
+		totalIntegratorFeeRateBps: v.optional(v.union([v.number(), v.string()])),
+		nonce: v.string()
+	})
+});
 
 //#endregion
-//#region src/adapters/satsConnectAdapter.ts
-var SatsConnectAdapter = class {
-	async mintRunes(params) {
-		try {
-			const walletInfo = await this.requestInternal("getInfo", null).catch(() => null);
-			if (walletInfo && walletInfo.status === "success") {
-				if (walletInfo.result.methods?.includes("runes_mint")) {
-					const response = await this.requestInternal("runes_mint", params);
-					if (response) {
-						if (response.status === "success") return response;
-						if (response.status === "error" && response.error.code !== RpcErrorCode.METHOD_NOT_FOUND) return response;
-					}
-				}
-			}
-			const mintRequest = {
-				destinationAddress: params.destinationAddress,
-				feeRate: params.feeRate,
-				refundAddress: params.refundAddress,
-				repeats: params.repeats,
-				runeName: params.runeName,
-				appServiceFee: params.appServiceFee,
-				appServiceFeeAddress: params.appServiceFeeAddress
-			};
-			const orderResponse = await new RunesApi(params.network).createMintOrder(mintRequest);
-			if (!orderResponse.data) return {
-				status: "error",
-				error: {
-					code: orderResponse.error.code === 400 ? RpcErrorCode.INVALID_REQUEST : RpcErrorCode.INTERNAL_ERROR,
-					message: orderResponse.error.message
-				}
-			};
-			const paymentResponse = await this.requestInternal("sendTransfer", { recipients: [{
-				address: orderResponse.data.fundAddress,
-				amount: orderResponse.data.fundAmount
-			}] });
-			if (paymentResponse.status !== "success") return paymentResponse;
-			await new RunesApi(params.network).executeMint(orderResponse.data.orderId, paymentResponse.result.txid);
-			return {
-				status: "success",
-				result: {
-					orderId: orderResponse.data.orderId,
-					fundTransactionId: paymentResponse.result.txid,
-					fundingAddress: orderResponse.data.fundAddress
-				}
-			};
-		} catch (error) {
-			return {
-				status: "error",
-				error: {
-					code: RpcErrorCode.INTERNAL_ERROR,
-					message: error.message
-				}
-			};
-		}
-	}
-	async etchRunes(params) {
-		const etchRequest = {
-			destinationAddress: params.destinationAddress,
-			refundAddress: params.refundAddress,
-			feeRate: params.feeRate,
-			runeName: params.runeName,
-			divisibility: params.divisibility,
-			symbol: params.symbol,
-			premine: params.premine,
-			isMintable: params.isMintable,
-			terms: params.terms,
-			inscriptionDetails: params.inscriptionDetails,
-			delegateInscriptionId: params.delegateInscriptionId,
-			appServiceFee: params.appServiceFee,
-			appServiceFeeAddress: params.appServiceFeeAddress
-		};
-		try {
-			const walletInfo = await this.requestInternal("getInfo", null).catch(() => null);
-			if (walletInfo && walletInfo.status === "success") {
-				if (walletInfo.result.methods?.includes("runes_etch")) {
-					const response = await this.requestInternal("runes_etch", params);
-					if (response) {
-						if (response.status === "success") return response;
-						if (response.status === "error" && response.error.code !== RpcErrorCode.METHOD_NOT_FOUND) return response;
-					}
-				}
-			}
-			const orderResponse = await new RunesApi(params.network).createEtchOrder(etchRequest);
-			if (!orderResponse.data) return {
-				status: "error",
-				error: {
-					code: orderResponse.error.code === 400 ? RpcErrorCode.INVALID_REQUEST : RpcErrorCode.INTERNAL_ERROR,
-					message: orderResponse.error.message
-				}
-			};
-			const paymentResponse = await this.requestInternal("sendTransfer", { recipients: [{
-				address: orderResponse.data.fundAddress,
-				amount: orderResponse.data.fundAmount
-			}] });
-			if (paymentResponse.status !== "success") return paymentResponse;
-			await new RunesApi(params.network).executeEtch(orderResponse.data.orderId, paymentResponse.result.txid);
-			return {
-				status: "success",
-				result: {
-					orderId: orderResponse.data.orderId,
-					fundTransactionId: paymentResponse.result.txid,
-					fundingAddress: orderResponse.data.fundAddress
-				}
-			};
-		} catch (error) {
-			return {
-				status: "error",
-				error: {
-					code: RpcErrorCode.INTERNAL_ERROR,
-					message: error.message
-				}
-			};
-		}
-	}
-	async estimateMint(params) {
-		const estimateMintRequest = {
-			destinationAddress: params.destinationAddress,
-			feeRate: params.feeRate,
-			repeats: params.repeats,
-			runeName: params.runeName,
-			appServiceFee: params.appServiceFee,
-			appServiceFeeAddress: params.appServiceFeeAddress
-		};
-		const response = await getRunesApiClient(params.network).estimateMintCost(estimateMintRequest);
-		if (response.data) return {
-			status: "success",
-			result: response.data
-		};
-		return {
-			status: "error",
-			error: {
-				code: response.error.code === 400 ? RpcErrorCode.INVALID_REQUEST : RpcErrorCode.INTERNAL_ERROR,
-				message: response.error.message
-			}
-		};
-	}
-	async estimateEtch(params) {
-		const estimateEtchRequest = {
-			destinationAddress: params.destinationAddress,
-			feeRate: params.feeRate,
-			runeName: params.runeName,
-			divisibility: params.divisibility,
-			symbol: params.symbol,
-			premine: params.premine,
-			isMintable: params.isMintable,
-			terms: params.terms,
-			inscriptionDetails: params.inscriptionDetails,
-			delegateInscriptionId: params.delegateInscriptionId,
-			appServiceFee: params.appServiceFee,
-			appServiceFeeAddress: params.appServiceFeeAddress
-		};
-		const response = await getRunesApiClient(params.network).estimateEtchCost(estimateEtchRequest);
-		if (response.data) return {
-			status: "success",
-			result: response.data
-		};
-		return {
-			status: "error",
-			error: {
-				code: response.error.code === 400 ? RpcErrorCode.INVALID_REQUEST : RpcErrorCode.INTERNAL_ERROR,
-				message: response.error.message
-			}
-		};
-	}
-	async getOrder(params) {
-		const response = await getRunesApiClient(params.network).getOrder(params.id);
-		if (response.data) return {
-			status: "success",
-			result: response.data
-		};
-		return {
-			status: "error",
-			error: {
-				code: response.error.code === 400 || response.error.code === 404 ? RpcErrorCode.INVALID_REQUEST : RpcErrorCode.INTERNAL_ERROR,
-				message: response.error.message
-			}
-		};
-	}
-	async estimateRbfOrder(params) {
-		const rbfOrderRequest = {
-			newFeeRate: params.newFeeRate,
-			orderId: params.orderId
-		};
-		const response = await getRunesApiClient(params.network).rbfOrder(rbfOrderRequest);
-		if (response.data) return {
-			status: "success",
-			result: {
-				fundingAddress: response.data.fundingAddress,
-				rbfCost: response.data.rbfCost
-			}
-		};
-		return {
-			status: "error",
-			error: {
-				code: response.error.code === 400 || response.error.code === 404 ? RpcErrorCode.INVALID_REQUEST : RpcErrorCode.INTERNAL_ERROR,
-				message: response.error.message
-			}
-		};
-	}
-	async rbfOrder(params) {
-		try {
-			const rbfOrderRequest = {
-				newFeeRate: params.newFeeRate,
-				orderId: params.orderId
-			};
-			const orderResponse = await getRunesApiClient(params.network).rbfOrder(rbfOrderRequest);
-			if (!orderResponse.data) return {
-				status: "error",
-				error: {
-					code: orderResponse.error.code === 400 || orderResponse.error.code === 404 ? RpcErrorCode.INVALID_REQUEST : RpcErrorCode.INTERNAL_ERROR,
-					message: orderResponse.error.message
-				}
-			};
-			const paymentResponse = await this.requestInternal("sendTransfer", { recipients: [{
-				address: orderResponse.data.fundingAddress,
-				amount: orderResponse.data.rbfCost
-			}] });
-			if (paymentResponse.status !== "success") return paymentResponse;
-			return {
-				status: "success",
-				result: {
-					fundingAddress: orderResponse.data.fundingAddress,
-					orderId: rbfOrderRequest.orderId,
-					fundRBFTransactionId: paymentResponse.result.txid
-				}
-			};
-		} catch (error) {
-			return {
-				status: "error",
-				error: {
-					code: RpcErrorCode.INTERNAL_ERROR,
-					message: error.message
-				}
-			};
-		}
-	}
-	async request(method, params) {
-		switch (method) {
-			case "runes_mint": return this.mintRunes(params);
-			case "runes_etch": return this.etchRunes(params);
-			case "runes_estimateMint": return this.estimateMint(params);
-			case "runes_estimateEtch": return this.estimateEtch(params);
-			case "runes_getOrder": return this.getOrder(params);
-			case "runes_estimateRbfOrder": return this.estimateRbfOrder(params);
-			case "runes_rbfOrder": return this.rbfOrder(params);
-			default: return this.requestInternal(method, params);
+//#region src/request/rpc/objects/namespaces/spark/methods/flashnetSignIntent/request.ts
+const sparkFlashnetSignIntentParamsSchema = v.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 = v.object({ signature: v.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 = v.object({ message: v.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 = v.object({
+	message: v.string(),
+	signature: v.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 = v.nullish(v.object({ message: v.optional(v.string()) }));
+const sparkGetAddressesRequestSchema = createRequestSchema({
+	paramsSchema: sparkGetAddressesParamsSchema,
+	method: sparkMethods.spark_getAddresses
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/spark/methods/getAddresses/response.ts
+const sparkGetAddressesResultSchema = v.object({
+	addresses: v.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 = v.nullish(v.object({ message: v.optional(v.string()) }));
+const sparkGetAddressesV2RequestSchema = createRequestSchema({
+	paramsSchema: sparkGetAddressesV2ParamsSchema,
+	method: sparkMethods.spark_getAddressesV2
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/spark/methods/getAddressesV2/response.ts
+const sparkGetAddressesV2ResultSchema = v.object({
+	addresses: v.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 = v.nullish(v.null());
+const sparkGetBalanceRequestSchema = createRequestSchema({
+	paramsSchema: sparkGetBalanceParamsSchema,
+	method: sparkMethods.spark_getBalance
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/spark/methods/getBalance/response.ts
+const sparkGetBalanceResultSchema = v.object({
+	balance: v.string(),
+	tokenBalances: v.array(v.object({
+		balance: v.string(),
+		tokenMetadata: v.object({
+			tokenIdentifier: v.string(),
+			tokenName: v.string(),
+			tokenTicker: v.string(),
+			decimals: v.number(),
+			maxSupply: v.string()
+		})
+	}))
+});
+const sparkGetBalanceSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: sparkGetBalanceResultSchema,
+	method: sparkMethods.spark_getBalance
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/spark/methods/signMessage/request.ts
+const sparkSignMessageParamsSchema = v.object({ message: v.string() });
+const sparkSignMessageRequestSchema = createRequestSchema({
+	paramsSchema: sparkSignMessageParamsSchema,
+	method: sparkMethods.spark_signMessage
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/spark/methods/signMessage/response.ts
+const sparkSignMessageResultSchema = v.object({ signature: v.string() });
+const sparkSignMessageSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: sparkSignMessageResultSchema,
+	method: sparkMethods.spark_signMessage
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/spark/methods/transfer/request.ts
+const sparkTransferParamsSchema = v.object({
+	amountSats: v.union([v.number(), v.string()]),
+	receiverSparkAddress: v.string()
+});
+const sparkTransferRequestSchema = createRequestSchema({
+	paramsSchema: sparkTransferParamsSchema,
+	method: sparkMethods.spark_transfer
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/spark/methods/transfer/response.ts
+const sparkTransferResultSchema = v.object({ id: v.string() });
+const sparkTransferSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: sparkTransferResultSchema,
+	method: sparkMethods.spark_transfer
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/spark/methods/transferToken/request.ts
+const sparkTransferTokenParamsSchema = v.object({
+	tokenAmount: v.union([v.number(), v.string()]),
+	tokenIdentifier: v.string(),
+	receiverSparkAddress: v.string()
+});
+const sparkTransferTokenRequestSchema = createRequestSchema({
+	paramsSchema: sparkTransferTokenParamsSchema,
+	method: sparkMethods.spark_transferToken
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/spark/methods/transferToken/response.ts
+const sparkTransferTokenResultSchema = v.object({ id: v.string() });
+const sparkTransferTokenSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: sparkTransferTokenResultSchema,
+	method: sparkMethods.spark_transferToken
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/spark/index.ts
+const sparkRequestSchema = v.variant("method", [
+	sparkGetAddressesRequestSchema,
+	sparkGetAddressesV2RequestSchema,
+	sparkGetBalanceRequestSchema,
+	sparkTransferRequestSchema,
+	sparkTransferTokenRequestSchema,
+	sparkSignMessageRequestSchema,
+	sparkFlashnetGetJwtRequestSchema,
+	sparkFlashnetSignIntentRequestSchema,
+	sparkFlashnetSignStructuredMessageRequestSchema,
+	sparkFlashnetExecuteSwapRequestSchema,
+	sparkFlashnetExecuteRouteSwapRequestSchema,
+	sparkFlashnetClawbackFundsRequestSchema,
+	sparkGetClawbackEligibleTransfersRequestSchema
+]);
+const sparkSuccessResponseSchema = v.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 = v.object({
+	contract: v.string(),
+	functionName: v.string(),
+	arguments: v.optional(v.array(v.string())),
+	functionArgs: v.optional(v.array(v.string())),
+	postConditions: v.optional(v.array(v.string())),
+	postConditionMode: v.optional(v.union([v.literal("allow"), v.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 = v.object({
+	txid: v.string(),
+	transaction: v.string()
+});
+const stacksCallContractSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: stacksCallContractResultSchema,
+	method: stacksMethods.stx_callContract
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/stacks/methods/deployContract/request.ts
+const stacksDeployContractParamsSchema = v.object({
+	name: v.string(),
+	clarityCode: v.string(),
+	clarityVersion: v.optional(v.number()),
+	postConditions: v.optional(v.array(v.string())),
+	postConditionMode: v.optional(v.union([v.literal("allow"), v.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 = v.object({
+	txid: v.string(),
+	transaction: v.string()
+});
+const stacksDeployContractSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: stacksDeployContractResultSchema,
+	method: stacksMethods.stx_deployContract
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/stacks/methods/getAccounts/request.ts
+const stacksGetAccountsParamsSchema = v.nullish(v.null());
+const stacksGetAccountsRequestSchema = createRequestSchema({
+	paramsSchema: stacksGetAccountsParamsSchema,
+	method: stacksMethods.stx_getAccounts
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/stacks/methods/getAccounts/response.ts
+const stacksGetAccountsResultSchema = v.object({
+	addresses: v.array(v.object({
+		address: v.string(),
+		publicKey: v.string(),
+		gaiaHubUrl: v.string(),
+		gaiaAppKey: v.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 = v.nullish(v.object({ message: v.optional(v.string()) }));
+const stacksGetAddressesRequestSchema = createRequestSchema({
+	paramsSchema: stacksGetAddressesParamsSchema,
+	method: stacksMethods.stx_getAddresses
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/stacks/methods/getAddresses/response.ts
+const stacksGetAddressesResultSchema = v.object({
+	addresses: v.array(addressSchema),
+	network: walletGetNetworkResultSchema
+});
+const stacksGetAddressesSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: stacksGetAddressesResultSchema,
+	method: stacksMethods.stx_getAddresses
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/stacks/methods/signMessage/request.ts
+const stacksSignMessageParamsSchema = v.object({ message: v.string() });
+const stacksSignMessageRequestSchema = createRequestSchema({
+	paramsSchema: stacksSignMessageParamsSchema,
+	method: stacksMethods.stx_signMessage
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/stacks/methods/signMessage/response.ts
+const stacksSignMessageResultSchema = v.object({
+	signature: v.string(),
+	publicKey: v.string()
+});
+const stacksSignMessageSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: stacksSignMessageResultSchema,
+	method: stacksMethods.stx_signMessage
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/stacks/methods/signStructuredMessage/request.ts
+const stacksSignStructuredMessageParamsSchema = v.object({
+	domain: v.string(),
+	message: v.string(),
+	publicKey: v.optional(v.string())
+});
+const stacksSignStructuredMessageRequestSchema = createRequestSchema({
+	paramsSchema: stacksSignStructuredMessageParamsSchema,
+	method: stacksMethods.stx_signStructuredMessage
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/stacks/methods/signStructuredMessage/response.ts
+const stacksSignStructuredMessageResultSchema = v.object({
+	signature: v.string(),
+	publicKey: v.string()
+});
+const stacksSignStructuredMessageSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: stacksSignStructuredMessageResultSchema,
+	method: stacksMethods.stx_signStructuredMessage
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/stacks/methods/signTransaction/request.ts
+const stacksSignTransactionParamsSchema = v.object({
+	transaction: v.string(),
+	pubkey: v.optional(v.string()),
+	broadcast: v.optional(v.boolean())
+});
+const stacksSignTransactionRequestSchema = createRequestSchema({
+	paramsSchema: stacksSignTransactionParamsSchema,
+	method: stacksMethods.stx_signTransaction
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/stacks/methods/signTransaction/response.ts
+const stacksSignTransactionResultSchema = v.object({ transaction: v.string() });
+const stacksSignTransactionSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: stacksSignTransactionResultSchema,
+	method: stacksMethods.stx_signTransaction
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/stacks/methods/signTransactions/request.ts
+const stacksSignTransactionsParamsSchema = v.object({
+	transactions: v.pipe(v.array(v.pipe(v.string(), v.check(() => {
+		return true;
+	}, "Invalid hex-encoded Stacks transaction."))), v.minLength(1)),
+	broadcast: v.optional(v.boolean(), true)
+});
+const stacksSignTransactionsRequestSchema = createRequestSchema({
+	paramsSchema: stacksSignTransactionsParamsSchema,
+	method: stacksMethods.stx_signTransactions
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/stacks/methods/signTransactions/response.ts
+const stacksSignTransactionsResultSchema = v.object({ transactions: v.array(v.string()) });
+const stacksSignTransactionsSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: stacksSignTransactionsResultSchema,
+	method: stacksMethods.stx_signTransactions
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/stacks/methods/transferStx/request.ts
+const stacksTransferStxParamsSchema = v.object({
+	amount: v.union([v.number(), v.string()]),
+	recipient: v.string(),
+	memo: v.optional(v.string()),
+	version: v.optional(v.string()),
+	postConditionMode: v.optional(v.number()),
+	postConditions: v.optional(v.array(v.string())),
+	pubkey: v.optional(v.string())
+});
+const stacksTransferStxRequestSchema = createRequestSchema({
+	paramsSchema: stacksTransferStxParamsSchema,
+	method: stacksMethods.stx_transferStx
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/stacks/methods/transferStx/response.ts
+const stacksTransferStxResultSchema = v.object({
+	txid: v.string(),
+	transaction: v.string()
+});
+const stacksTransferStxSuccessResponseSchema = createSuccessResponseSchema({
+	resultSchema: stacksTransferStxResultSchema,
+	method: stacksMethods.stx_transferStx
+});
+
+//#endregion
+//#region src/request/rpc/objects/namespaces/stacks/index.ts
+const stacksRequestSchema = v.variant("method", [
+	stacksCallContractRequestSchema,
+	stacksDeployContractRequestSchema,
+	stacksGetAccountsRequestSchema,
+	stacksGetAddressesRequestSchema,
+	stacksSignMessageRequestSchema,
+	stacksSignStructuredMessageRequestSchema,
+	stacksSignTransactionRequestSchema,
+	stacksSignTransactionsRequestSchema,
+	stacksTransferStxRequestSchema
+]);
+const stacksSuccessResponseSchema = v.variant("~sats-connect-method", [
+	stacksCallContractSuccessResponseSchema,
+	stacksDeployContractSuccessResponseSchema,
+	stacksGetAccountsSuccessResponseSchema,
+	stacksGetAddressesSuccessResponseSchema,
+	stacksSignMessageSuccessResponseSchema,
+	stacksSignStructuredMessageSuccessResponseSchema,
+	stacksSignTransactionSuccessResponseSchema,
+	stacksSignTransactionsSuccessResponseSchema,
+	stacksTransferStxSuccessResponseSchema
+]);
+
+//#endregion
+//#region src/request/rpc/requests.ts
+const rpcRequestSchema = v.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 = v.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 (v.is(specErrorResponseSchema, response)) return {
+		status: "error",
+		error: response.error
+	};
+	if (v.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
@@ -2228,182 +3092,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 = getAddressInfo(accounts[0]).type;
-		const pk = addressType === AddressType$1.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 = getAddressInfo(address).type;
-		if ([AddressType$1.p2wpkh, AddressType$1.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.from(psbt, "base64").toString("hex");
-		const signedPsbt = await window.unisat.signPsbt(psbtHex, {
-			autoFinalized: broadcast,
-			toSignInputs: convertSignInputsToInputType(signInputs)
-		});
-		const signedPsbtBase64 = 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 {
@@ -2500,7 +3188,7 @@ const MAX_CONTENT_LENGTH_MAINNET = 4e5;
 const MAX_CONTENT_LENGTH_TESTNET = 6e4;
 const validateInscriptionPayload = (payload) => {
 	const { contentType, content, payloadType, network, appFeeAddress, appFee } = payload;
-	if (!/^[a-z]+\/[a-z0-9\-\.\+]+(?=;.*|$)/.test(contentType)) throw new Error("Invalid content type detected");
+	if (!/^[a-z]+\/[a-z0-9\-.+]+(?=;.*|$)/.test(contentType)) throw new Error("Invalid content type detected");
 	if (!content || content.length === 0) throw new Error("Empty content not allowed");
 	if (!payloadType || payloadType !== "BASE_64" && payloadType !== "PLAIN_TEXT") throw new Error("Empty invalid payloadType specified");
 	if (content.length > (network.type === "Mainnet" ? MAX_CONTENT_LENGTH_MAINNET : MAX_CONTENT_LENGTH_TESTNET)) throw new Error("Content too large");
@@ -2589,38 +3277,38 @@ 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 = 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 = 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?.();
 	}
 };
 
 //#endregion
-export { AddressPurpose, AddressType, BaseAdapter, BitcoinNetworkType, DefaultAdaptersInfo, MessageSigningProtocols, PermissionRequestParams, ProviderPlatform, RpcErrorCode, RpcIdSchema, SatsConnectAdapter, SparkNetworkType, StacksNetworkType, StarknetNetworkType, accountActionsSchema, accountChangeEventName, accountChangeSchema, accountPermissionSchema, addListener, addNetworkMethodName, addNetworkParamsSchema, addNetworkRequestMessageSchema, addNetworkResultSchema, addNetworkV2MethodName, addNetworkV2ParamsSchema, addNetworkV2RequestMessageSchema, addNetworkV2ResultSchema, addressSchema, bitcoinGetAccountsV2MethodName, bitcoinGetAccountsV2ParamsSchema, bitcoinGetAccountsV2RequestMessageSchema, bitcoinGetAccountsV2ResultSchema, bitcoinGetAddressesRequestMessageSchema, bitcoinGetAddressesResultSchema, bitcoinGetAddressesV2MethodName, bitcoinGetAddressesV2ParamsSchema, bitcoinGetBalanceV2MethodName, bitcoinGetBalanceV2ParamsSchema, bitcoinGetBalanceV2RequestMessageSchema, bitcoinGetBalanceV2ResultSchema, bitcoinGetInfoV2MethodName, bitcoinGetInfoV2ParamsSchema, bitcoinGetInfoV2RequestMessageSchema, bitcoinGetInfoV2ResultSchema, bitcoinNetworkConfigurationOptionsSchema, bitcoinSendTransferV2MethodName, bitcoinSendTransferV2ParamsSchema, bitcoinSendTransferV2RequestMessageSchema, bitcoinSendTransferV2ResultSchema, bitcoinSignMessageV2MethodName, bitcoinSignMessageV2ParamsSchema, bitcoinSignMessageV2RequestMessageSchema, bitcoinSignMessageV2ResultSchema, bitcoinSignMultipleMessagesV2MethodName, bitcoinSignMultipleMessagesV2ParamsSchema, bitcoinSignMultipleMessagesV2RequestMessageSchema, bitcoinSignMultipleMessagesV2ResultSchema, bitcoinSignPsbtV2MethodName, bitcoinSignPsbtV2ParamsSchema, bitcoinSignPsbtV2RequestMessageSchema, bitcoinSignPsbtV2ResultSchema, changeNetworkByIdMethodName, changeNetworkByIdParamsSchema, changeNetworkByIdRequestMessageSchema, changeNetworkByIdResultSchema, changeNetworkMethodName, changeNetworkParamsSchema, changeNetworkRequestMessageSchema, changeNetworkResultSchema, connectMethodName, connectParamsSchema, connectRequestMessageSchema, connectResultSchema, connectV2MethodName, connectV2ParamsSchema, connectV2RequestMessageSchema, connectV2ResultSchema, createInscription, createRepeatInscriptions, defaultAdapters, disconnectEventName, disconnectMethodName, disconnectParamsSchema, disconnectRequestMessageSchema, disconnectResultSchema, disconnectSchema, getAccountMethodName, getAccountParamsSchema, getAccountRequestMessageSchema, getAccountResultSchema, getAccountV2MethodName, getAccountV2ParamsSchema, getAccountV2RequestMessageSchema, getAccountV2ResultSchema, getAccountsMethodName, getAccountsParamsSchema, getAccountsRequestMessageSchema, getAccountsResultSchema, getAddress, getAddressesMethodName, getAddressesParamsSchema, getAddressesRequestMessageSchema, getAddressesResultSchema, getBalanceMethodName, getBalanceParamsSchema, getBalanceRequestMessageSchema, getBalanceResultSchema, getCapabilities, getCurrentPermissionsMethodName, getCurrentPermissionsParamsSchema, getCurrentPermissionsRequestMessageSchema, getCurrentPermissionsResultSchema, getDefaultProvider, getInfoMethodName, getInfoParamsSchema, getInfoRequestMessageSchema, getInfoResultSchema, getInscriptionsMethodName, getInscriptionsParamsSchema, getInscriptionsRequestMessageSchema, getInscriptionsResultSchema, getNetworkMethodName, getNetworkParamsSchema, getNetworkRequestMessageSchema, getNetworkResultSchema, getNetworksMethodName, getNetworksParamsSchema, getNetworksRequestMessageSchema, getNetworksResultSchema, getProviderById, getProviderOrThrow, getProviders, getSupportedWallets, getWalletTypeMethodName, getWalletTypeParamsSchema, getWalletTypeRequestMessageSchema, getWalletTypeResultSchema, isProviderInstalled, networkChangeEventName, networkChangeEventNameV2, networkChangeSchema, networkChangeV2Schema, networkConfigurationOptionsSchema, openBridgeMethodName, openBridgeParamsSchema, openBridgeRequestMessageSchema, openBridgeResultSchema, openBuyMethodName, openBuyParamsSchema, openBuyRequestMessageSchema, openBuyResultSchema, openReceiveMethodName, openReceiveParamsSchema, openReceiveRequestMessageSchema, openReceiveResultSchema, permission, removeDefaultProvider, renouncePermissionsMethodName, renouncePermissionsParamsSchema, renouncePermissionsRequestMessageSchema, renouncePermissionsResultSchema, request, requestPermissionsMethodName, requestPermissionsParamsSchema, requestPermissionsRequestMessageSchema, requestPermissionsResultSchema, rpcErrorResponseMessageSchema, rpcRequestMessageSchema, rpcResponseMessageSchema, rpcSuccessResponseMessageSchema, runesEstimateEtchMethodName, runesEstimateMintMethodName, runesEstimateRbfOrderMethodName, runesEtchMethodName, runesEtchParamsSchema, runesEtchRequestMessageSchema, runesEtchResultSchema, runesGetBalanceMethodName, runesGetBalanceParamsSchema, runesGetBalanceRequestMessageSchema, runesGetBalanceResultSchema, runesGetOrderMethodName, runesMintMethodName, runesMintParamsSchema, runesMintRequestMessageSchema, runesMintResultSchema, runesRbfOrderMethodName, runesTransferMethodName, runesTransferParamsSchema, runesTransferRequestMessageSchema, runesTransferResultSchema, sendBtcTransaction, sendInscriptionsMethodName, sendInscriptionsParamsSchema, sendInscriptionsRequestMessageSchema, sendInscriptionsResultSchema, sendTransferMethodName, sendTransferParamsSchema, sendTransferRequestMessageSchema, sendTransferResultSchema, setDefaultProvider, signMessage, signMessageMethodName, signMessageParamsSchema, signMessageRequestMessageSchema, signMessageResultSchema, signMultipleMessagesMethodName, signMultipleMessagesParamsSchema, signMultipleMessagesRequestMessageSchema, signMultipleMessagesResultSchema, signMultipleTransactions, signPsbtMethodName, signPsbtParamsSchema, signPsbtRequestMessageSchema, signPsbtResultSchema, signTransaction, sparkFlashnetAddLiquidityIntentSchema, sparkFlashnetClawbackFundsMethodName, sparkFlashnetClawbackFundsParamsSchema, sparkFlashnetClawbackFundsRequestMessageSchema, sparkFlashnetClawbackFundsResultSchema, sparkFlashnetClawbackIntentSchema, sparkFlashnetConfirmInitialDepositIntentSchema, sparkFlashnetCreateConstantProductPoolIntentSchema, sparkFlashnetCreateSingleSidedPoolIntentSchema, sparkFlashnetExecuteRouteSwapMethodName, sparkFlashnetExecuteRouteSwapParamsSchema, sparkFlashnetExecuteRouteSwapRequestMessageSchema, sparkFlashnetExecuteRouteSwapResultSchema, sparkFlashnetExecuteSwapMethodName, sparkFlashnetExecuteSwapParamsSchema, sparkFlashnetExecuteSwapRequestMessageSchema, sparkFlashnetExecuteSwapResultSchema, sparkFlashnetGetJwtMethodName, sparkFlashnetGetJwtParamsSchema, sparkFlashnetGetJwtRequestMessageSchema, sparkFlashnetGetJwtResultSchema, sparkFlashnetRemoveLiquidityIntentSchema, sparkFlashnetRouteSwapIntentSchema, sparkFlashnetSignIntentMethodName, sparkFlashnetSignIntentParamsSchema, sparkFlashnetSignIntentRequestMessageSchema, sparkFlashnetSignIntentResultSchema, sparkFlashnetSignStructuredMessageMethodName, sparkFlashnetSignStructuredMessageParamsSchema, sparkFlashnetSignStructuredMessageRequestMessageSchema, sparkFlashnetSignStructuredMessageResultSchema, sparkFlashnetSwapIntentSchema, sparkGetAddressesMethodName, sparkGetAddressesParamsSchema, sparkGetAddressesRequestMessageSchema, sparkGetAddressesResultSchema, sparkGetAddressesV2MethodName, sparkGetAddressesV2ParamsSchema, sparkGetAddressesV2RequestMessageSchema, sparkGetAddressesV2ResultSchema, sparkGetBalanceMethodName, sparkGetBalanceParamsSchema, sparkGetBalanceRequestMessageSchema, sparkGetBalanceResultSchema, sparkGetClawbackEligibleTransfersMethodName, sparkGetClawbackEligibleTransfersParamsSchema, sparkGetClawbackEligibleTransfersRequestMessageSchema, sparkGetClawbackEligibleTransfersResultSchema, sparkNetworkConfigurationOptionsSchema, sparkSignMessageMethodName, sparkSignMessageParamsSchema, sparkSignMessageRequestMessageSchema, sparkSignMessageResultSchema, sparkTransferMethodName, sparkTransferParamsSchema, sparkTransferRequestMessageSchema, sparkTransferResultSchema, sparkTransferTokenMethodName, sparkTransferTokenParamsSchema, sparkTransferTokenRequestMessageSchema, sparkTransferTokenResultSchema, stacksCallContractMethodName, stacksCallContractParamsSchema, stacksCallContractRequestMessageSchema, stacksCallContractResultSchema, stacksDeployContractMethodName, stacksDeployContractParamsSchema, stacksDeployContractRequestMessageSchema, stacksDeployContractResultSchema, stacksGetAccountsMethodName, stacksGetAccountsParamsSchema, stacksGetAccountsRequestMessageSchema, stacksGetAccountsResultSchema, stacksGetAddressesMethodName, stacksGetAddressesParamsSchema, stacksGetAddressesRequestMessageSchema, stacksGetAddressesResultSchema, stacksGetAddressesV2MethodName, stacksGetAddressesV2ParamsSchema, stacksGetAddressesV2RequestMessageSchema, stacksGetAddressesV2ResultSchema, stacksNetworkConfigurationOptionsSchema, stacksSignMessageMethodName, stacksSignMessageParamsSchema, stacksSignMessageRequestMessageSchema, stacksSignMessageResultSchema, stacksSignStructuredMessageMethodName, stacksSignStructuredMessageParamsSchema, stacksSignStructuredMessageRequestMessageSchema, stacksSignStructuredMessageResultSchema, stacksSignTransactionMethodName, stacksSignTransactionParamsSchema, stacksSignTransactionRequestMessageSchema, stacksSignTransactionResultSchema, stacksSignTransactionsMethodName, stacksSignTransactionsParamsSchema, stacksSignTransactionsRequestMessageSchema, stacksSignTransactionsResultSchema, stacksTransferStxMethodName, stacksTransferStxParamsSchema, stacksTransferStxRequestMessageSchema, stacksTransferStxResultSchema, starknetNetworkConfigurationOptionsSchema, walletActionsSchema, walletEventSchema, walletPermissionSchema, walletTypeSchema, walletTypes };
+export { AddressPurpose, AddressType, BaseAdapter, BitcoinNetworkType, DefaultAdaptersInfo, MessageSigningProtocols, ProviderPlatform, RpcErrorCode, SatsConnectAdapter, SparkNetworkType, StacksNetworkType, StarknetNetworkType, accountChangeEventName, accountChangeSchema, addListener, addressSchema, allResolvedNetworksSchema, bitcoinGetAccountsParamsSchema, bitcoinGetAccountsRequestSchema, bitcoinGetAccountsResultSchema, bitcoinGetAccountsSuccessResponseSchema, bitcoinGetAddressesParamsSchema, bitcoinGetAddressesRequestSchema, bitcoinGetAddressesResultSchema, bitcoinGetAddressesSuccessResponseSchema, bitcoinGetAddressesV2ParamsSchema, bitcoinGetAddressesV2RequestSchema, bitcoinGetAddressesV2ResultSchema, bitcoinGetAddressesV2SuccessResponseSchema, bitcoinGetBalanceParamsSchema, bitcoinGetBalanceRequestSchema, bitcoinGetBalanceResultSchema, bitcoinGetBalanceSuccessResponseSchema, bitcoinGetBalanceV2ParamsSchema, bitcoinGetBalanceV2RequestSchema, bitcoinGetBalanceV2ResultSchema, bitcoinGetBalanceV2SuccessResponseSchema, bitcoinGetInfoParamsSchema, bitcoinGetInfoRequestSchema, bitcoinGetInfoResultSchema, bitcoinGetInfoSuccessResponseSchema, bitcoinMethods, bitcoinModeToLegacyBitcoinNetworkType, bitcoinNetworkConfigurationOptionsSchema, bitcoinRequestSchema, bitcoinSendTransferParamsSchema, bitcoinSendTransferRequestSchema, bitcoinSendTransferResultSchema, bitcoinSendTransferSuccessResponseSchema, bitcoinSendTransferV2ParamsSchema, bitcoinSendTransferV2RequestSchema, bitcoinSendTransferV2ResultSchema, bitcoinSendTransferV2SuccessResponseSchema, bitcoinSignMessageParamsSchema, bitcoinSignMessageRequestSchema, bitcoinSignMessageResultSchema, bitcoinSignMessageSuccessResponseSchema, bitcoinSignMessageV2ParamsSchema, bitcoinSignMessageV2RequestSchema, bitcoinSignMessageV2ResultSchema, bitcoinSignMessageV2SuccessResponseSchema, bitcoinSignMultipleMessagesParamsSchema, bitcoinSignMultipleMessagesRequestSchema, bitcoinSignMultipleMessagesResultSchema, bitcoinSignMultipleMessagesSuccessResponseSchema, bitcoinSignMultipleMessagesV2ParamsSchema, bitcoinSignMultipleMessagesV2RequestSchema, bitcoinSignMultipleMessagesV2ResultSchema, bitcoinSignMultipleMessagesV2SuccessResponseSchema, bitcoinSignPsbtParamsSchema, bitcoinSignPsbtRequestSchema, bitcoinSignPsbtResultSchema, bitcoinSignPsbtSuccessResponseSchema, bitcoinSignPsbtV2ParamsSchema, bitcoinSignPsbtV2RequestSchema, bitcoinSignPsbtV2ResultSchema, bitcoinSignPsbtV2SuccessResponseSchema, bitcoinSuccessResponseSchema, createInscription, createRepeatInscriptions, createRpcRequest, createRpcSuccessResponse, defaultAdapters, disconnectEventName, disconnectSchema, getAddress, getCapabilities, getDefaultProvider, getProviderById, getProviderOrThrow, getProviders, getSupportedWallets, isProviderInstalled, methodSupport, methods, networkChangeEventName, networkChangeEventNameV2, networkChangeSchema, networkChangeV2Schema, networkConfigurationOptionsSchema, ordinalsGetInscriptionsParamsSchema, ordinalsGetInscriptionsRequestSchema, ordinalsGetInscriptionsResultSchema, ordinalsGetInscriptionsSuccessResponseSchema, ordinalsMethods, ordinalsRequestSchema, ordinalsSendInscriptionsParamsSchema, ordinalsSendInscriptionsRequestSchema, ordinalsSendInscriptionsResultSchema, ordinalsSendInscriptionsSuccessResponseSchema, ordinalsSuccessResponseSchema, permissionRequestParamsSchema, removeDefaultProvider, request, rpcIdSchema, rpcRequestSchema, rpcSuccessResponseSchema, runesEstimateEtchParamsSchema, runesEstimateEtchRequestSchema, runesEstimateEtchResultSchema, runesEstimateEtchSuccessResponseSchema, runesEstimateMintParamsSchema, runesEstimateMintRequestSchema, runesEstimateMintResultSchema, runesEstimateMintSuccessResponseSchema, runesEstimateRbfOrderParamsSchema, runesEstimateRbfOrderRequestSchema, runesEstimateRbfOrderResultSchema, runesEstimateRbfOrderSuccessResponseSchema, runesEtchParamsSchema, runesEtchRequestSchema, runesEtchResultSchema, runesEtchSuccessResponseSchema, runesGetBalanceParamsSchema, runesGetBalanceRequestSchema, runesGetBalanceResultSchema, runesGetBalanceSuccessResponseSchema, runesGetOrderParamsSchema, runesGetOrderRequestSchema, runesGetOrderResultSchema, runesGetOrderSuccessResponseSchema, runesMethods, runesMintParamsSchema, runesMintRequestSchema, runesMintResultSchema, runesMintSuccessResponseSchema, runesRbfOrderParamsSchema, runesRbfOrderRequestSchema, runesRbfOrderResultSchema, runesRbfOrderSuccessResponseSchema, runesRequestSchema, runesSuccessResponseSchema, runesTransferParamsSchema, runesTransferRequestSchema, runesTransferResultSchema, runesTransferSuccessResponseSchema, sendBtcTransaction, setDefaultProvider, signMessage, signMultipleTransactions, signTransaction, sparkFlashnetClawbackFundsParamsSchema, sparkFlashnetClawbackFundsRequestSchema, sparkFlashnetClawbackFundsResultSchema, sparkFlashnetClawbackFundsSuccessResponseSchema, sparkFlashnetExecuteRouteSwapParamsSchema, sparkFlashnetExecuteRouteSwapRequestSchema, sparkFlashnetExecuteRouteSwapResultSchema, sparkFlashnetExecuteRouteSwapSuccessResponseSchema, sparkFlashnetExecuteSwapParamsSchema, sparkFlashnetExecuteSwapRequestSchema, sparkFlashnetExecuteSwapResultSchema, sparkFlashnetExecuteSwapSuccessResponseSchema, sparkFlashnetGetJwtParamsSchema, sparkFlashnetGetJwtRequestSchema, sparkFlashnetGetJwtResultSchema, sparkFlashnetGetJwtSuccessResponseSchema, sparkFlashnetSignIntentParamsSchema, sparkFlashnetSignIntentRequestSchema, sparkFlashnetSignIntentResultSchema, sparkFlashnetSignIntentSuccessResponseSchema, sparkFlashnetSignStructuredMessageParamsSchema, sparkFlashnetSignStructuredMessageRequestSchema, sparkFlashnetSignStructuredMessageResultSchema, sparkFlashnetSignStructuredMessageSuccessResponseSchema, sparkGetAddressesParamsSchema, sparkGetAddressesRequestSchema, sparkGetAddressesResultSchema, sparkGetAddressesSuccessResponseSchema, sparkGetAddressesV2ParamsSchema, sparkGetAddressesV2RequestSchema, sparkGetAddressesV2ResultSchema, sparkGetAddressesV2SuccessResponseSchema, sparkGetBalanceParamsSchema, sparkGetBalanceRequestSchema, sparkGetBalanceResultSchema, sparkGetBalanceSuccessResponseSchema, sparkGetClawbackEligibleTransfersParamsSchema, sparkGetClawbackEligibleTransfersRequestSchema, sparkGetClawbackEligibleTransfersResultSchema, sparkGetClawbackEligibleTransfersSuccessResponseSchema, sparkMethods, sparkModeToLegacySparkNetworkType, sparkNetworkConfigurationOptionsSchema, sparkRequestSchema, sparkSignMessageParamsSchema, sparkSignMessageRequestSchema, sparkSignMessageResultSchema, sparkSignMessageSuccessResponseSchema, sparkSuccessResponseSchema, sparkTransferParamsSchema, sparkTransferRequestSchema, sparkTransferResultSchema, sparkTransferSuccessResponseSchema, sparkTransferTokenParamsSchema, sparkTransferTokenRequestSchema, sparkTransferTokenResultSchema, sparkTransferTokenSuccessResponseSchema, specErrorObjectSchema, specErrorResponseSchema, specIdSchema, specRequestSchema, specResponseSchema, specSuccessResponseSchema, specSuccessWithExtensionsResponseSchema, stacksCallContractParamsSchema, stacksCallContractRequestSchema, stacksCallContractResultSchema, stacksCallContractSuccessResponseSchema, stacksDeployContractParamsSchema, stacksDeployContractRequestSchema, stacksDeployContractResultSchema, stacksDeployContractSuccessResponseSchema, stacksGetAccountsParamsSchema, stacksGetAccountsRequestSchema, stacksGetAccountsResultSchema, stacksGetAccountsSuccessResponseSchema, stacksGetAddressesParamsSchema, stacksGetAddressesRequestSchema, stacksGetAddressesResultSchema, stacksGetAddressesSuccessResponseSchema, stacksMethods, stacksModeToLegacyStacksNetworkType, stacksNetworkConfigurationOptionsSchema, stacksRequestSchema, stacksSignMessageParamsSchema, stacksSignMessageRequestSchema, stacksSignMessageResultSchema, stacksSignMessageSuccessResponseSchema, stacksSignStructuredMessageParamsSchema, stacksSignStructuredMessageRequestSchema, stacksSignStructuredMessageResultSchema, stacksSignStructuredMessageSuccessResponseSchema, stacksSignTransactionParamsSchema, stacksSignTransactionRequestSchema, stacksSignTransactionResultSchema, stacksSignTransactionSuccessResponseSchema, stacksSignTransactionsParamsSchema, stacksSignTransactionsRequestSchema, stacksSignTransactionsResultSchema, stacksSignTransactionsSuccessResponseSchema, stacksSuccessResponseSchema, stacksTransferStxParamsSchema, stacksTransferStxRequestSchema, stacksTransferStxResultSchema, stacksTransferStxSuccessResponseSchema, starknetNetworkConfigurationOptionsSchema, walletAddNetworkParamsSchema, walletAddNetworkRequestSchema, walletAddNetworkResultSchema, walletAddNetworkSuccessResponseSchema, walletAddNetworkV2ParamsSchema, walletAddNetworkV2RequestSchema, walletAddNetworkV2ResultSchema, walletAddNetworkV2SuccessResponseSchema, walletChangeNetworkByIdResultSchema, walletChangeNetworkByIdSuccessResponseSchema, walletChangeNetworkParamsSchema, walletChangeNetworkRequestSchema, walletChangeNetworkResultSchema, walletChangeNetworkSuccessResponseSchema, walletConnectParamsSchema, walletConnectRequestSchema, walletConnectResultSchema, walletConnectSuccessResponseSchema, walletConnectV2ParamsSchema, walletConnectV2RequestSchema, walletConnectV2ResultSchema, walletConnectV2SuccessResponseSchema, walletDisconnectParamsSchema, walletDisconnectRequestSchema, walletDisconnectResultSchema, walletDisconnectSuccessResponseSchema, walletEventSchema, walletGetAccountParamsSchema, walletGetAccountRequestSchema, walletGetAccountResultSchema, walletGetAccountSuccessResponseSchema, walletGetAccountV2ParamsSchema, walletGetAccountV2RequestSchema, walletGetAccountV2ResultSchema, walletGetAccountV2SuccessResponseSchema, walletGetCurrentPermissionsParamsSchema, walletGetCurrentPermissionsRequestSchema, walletGetCurrentPermissionsResultSchema, walletGetCurrentPermissionsSuccessResponseSchema, walletGetNetworkParamsSchema, walletGetNetworkRequestSchema, walletGetNetworkResultSchema, walletGetNetworkSuccessResponseSchema, walletGetNetworksParamsSchema, walletGetNetworksRequestSchema, walletGetNetworksResultSchema, walletGetNetworksSuccessResponseSchema, walletGetWalletTypeParamsSchema, walletGetWalletTypeRequestSchema, walletGetWalletTypeResultSchema, walletGetWalletTypeSuccessResponseSchema, walletMethods, walletOpenBridgeParamsSchema, walletOpenBridgeRequestSchema, walletOpenBridgeResultSchema, walletOpenBridgeSuccessResponseSchema, walletOpenBuyParamsSchema, walletOpenBuyRequestSchema, walletOpenBuyResultSchema, walletOpenBuySuccessResponseSchema, walletOpenReceiveParamsSchema, walletOpenReceiveRequestSchema, walletOpenReceiveResultSchema, walletOpenReceiveSuccessResponseSchema, walletRenouncePermissionsParamsSchema, walletRenouncePermissionsRequestSchema, walletRenouncePermissionsResultSchema, walletRenouncePermissionsSuccessResponseSchema, walletRequestPermissionsParamsSchema, walletRequestPermissionsRequestSchema, walletRequestPermissionsResultSchema, walletRequestPermissionsSuccessResponseSchema, walletRequestSchema, walletSuccessResponseSchema, walletSwitchNetworkByIdParamsSchema, walletSwitchNetworkByIdRequestSchema, walletTypeSchema, walletTypes };