@sats-connect/core 0.8.1-b5b5706 → 0.8.1-d85ba2a

package/dist/index.mjs

@@ -1,5 +1,64 @@
-// src/types.ts
+// src/provider/types.ts
+import * as v4 from "valibot";
+
+// src/addresses/index.ts
+import { createUnsecuredToken } from "jsontokens";
+
+// src/addresses/types.ts
+import * as v2 from "valibot";
+
+// src/request/types/common.ts
 import * as v from "valibot";
+var walletTypes = ["software", "ledger", "keystone"];
+var walletTypeSchema = v.picklist(walletTypes);
+
+// src/addresses/types.ts
+var AddressPurpose = /* @__PURE__ */ ((AddressPurpose2) => {
+  AddressPurpose2["Ordinals"] = "ordinals";
+  AddressPurpose2["Payment"] = "payment";
+  AddressPurpose2["Stacks"] = "stacks";
+  AddressPurpose2["Starknet"] = "starknet";
+  AddressPurpose2["Spark"] = "spark";
+  return AddressPurpose2;
+})(AddressPurpose || {});
+var AddressType = /* @__PURE__ */ ((AddressType3) => {
+  AddressType3["p2pkh"] = "p2pkh";
+  AddressType3["p2sh"] = "p2sh";
+  AddressType3["p2wpkh"] = "p2wpkh";
+  AddressType3["p2wsh"] = "p2wsh";
+  AddressType3["p2tr"] = "p2tr";
+  AddressType3["stacks"] = "stacks";
+  AddressType3["starknet"] = "starknet";
+  AddressType3["spark"] = "spark";
+  return AddressType3;
+})(AddressType || {});
+var addressSchema = v2.object({
+  address: v2.string(),
+  publicKey: v2.string(),
+  purpose: v2.enum(AddressPurpose),
+  addressType: v2.enum(AddressType),
+  walletType: walletTypeSchema
+});
+
+// src/addresses/index.ts
+var getAddress = async (options) => {
+  const provider = await getProviderOrThrow(options.getProvider);
+  const { purposes } = options.payload;
+  if (!purposes) {
+    throw new Error("Address purposes are required");
+  }
+  try {
+    const request2 = createUnsecuredToken(options.payload);
+    const response = await provider.connect(request2);
+    options.onFinish?.(response);
+  } catch (error) {
+    console.error("[Connect] Error during address request", error);
+    options.onCancel?.();
+  }
+};
+
+// src/types.ts
+import * as v3 from "valibot";
 var BitcoinNetworkType = /* @__PURE__ */ ((BitcoinNetworkType2) => {
   BitcoinNetworkType2["Mainnet"] = "Mainnet";
   BitcoinNetworkType2["Testnet"] = "Testnet";
@@ -23,22 +82,22 @@ var SparkNetworkType = /* @__PURE__ */ ((SparkNetworkType2) => {
   SparkNetworkType2["Regtest"] = "regtest";
   return SparkNetworkType2;
 })(SparkNetworkType || {});
-var RpcIdSchema = v.optional(v.union([v.string(), v.number(), v.null()]));
-var rpcRequestMessageSchema = v.object({
-  jsonrpc: v.literal("2.0"),
-  method: v.string(),
-  params: v.optional(
-    v.union([
-      v.array(v.unknown()),
-      v.looseObject({}),
+var RpcIdSchema = v3.optional(v3.union([v3.string(), v3.number(), v3.null()]));
+var rpcRequestMessageSchema = v3.object({
+  jsonrpc: v3.literal("2.0"),
+  method: v3.string(),
+  params: v3.optional(
+    v3.union([
+      v3.array(v3.unknown()),
+      v3.looseObject({}),
       // Note: This is to support current incorrect usage of RPC 2.0. Params need
       // to be either an array or an object when provided. Changing this now would
       // be a breaking change, so accepting null values for now. Tracking in
       // https://linear.app/xverseapp/issue/ENG-4538.
-      v.null()
+      v3.null()
     ])
   ),
-  id: v.unwrap(RpcIdSchema)
+  id: v3.unwrap(RpcIdSchema)
 });
 var RpcErrorCode = /* @__PURE__ */ ((RpcErrorCode2) => {
   RpcErrorCode2[RpcErrorCode2["PARSE_ERROR"] = -32700] = "PARSE_ERROR";
@@ -51,647 +110,89 @@ var RpcErrorCode = /* @__PURE__ */ ((RpcErrorCode2) => {
   RpcErrorCode2[RpcErrorCode2["ACCESS_DENIED"] = -32002] = "ACCESS_DENIED";
   return RpcErrorCode2;
 })(RpcErrorCode || {});
-var rpcSuccessResponseMessageSchema = v.object({
-  jsonrpc: v.literal("2.0"),
-  result: v.nonOptional(v.unknown()),
+var rpcSuccessResponseMessageSchema = v3.object({
+  jsonrpc: v3.literal("2.0"),
+  result: v3.nonOptional(v3.unknown()),
   id: RpcIdSchema
 });
-var rpcErrorResponseMessageSchema = v.object({
-  jsonrpc: v.literal("2.0"),
-  error: v.nonOptional(v.unknown()),
+var rpcErrorResponseMessageSchema = v3.object({
+  jsonrpc: v3.literal("2.0"),
+  error: v3.nonOptional(v3.unknown()),
   id: RpcIdSchema
 });
-var rpcResponseMessageSchema = v.union([
+var rpcResponseMessageSchema = v3.union([
   rpcSuccessResponseMessageSchema,
   rpcErrorResponseMessageSchema
 ]);
 
-// src/runes/api.ts
-import axios from "axios";
-var urlNetworkSuffix = {
-  ["Mainnet" /* Mainnet */]: "",
-  ["Testnet" /* Testnet */]: "-testnet",
-  ["Testnet4" /* Testnet4 */]: "-testnet4",
-  ["Signet" /* Signet */]: "-signet"
-};
-var ORDINALS_API_BASE_URL = (network = "Mainnet" /* Mainnet */) => {
-  if (network === "Regtest" /* 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)
-    });
+// src/provider/types.ts
+var accountChangeEventName = "accountChange";
+var accountChangeSchema = v4.object({
+  type: v4.literal(accountChangeEventName),
+  addresses: v4.optional(v4.array(addressSchema))
+});
+var networkChangeEventName = "networkChange";
+var networkChangeSchema = v4.object({
+  type: v4.literal(networkChangeEventName),
+  bitcoin: v4.object({
+    name: v4.enum(BitcoinNetworkType)
+  }),
+  stacks: v4.object({
+    name: v4.string()
+  }),
+  addresses: v4.optional(v4.array(addressSchema))
+});
+var disconnectEventName = "disconnect";
+var disconnectSchema = v4.object({
+  type: v4.literal(disconnectEventName)
+});
+var walletEventSchema = v4.variant("type", [
+  accountChangeSchema,
+  networkChangeSchema,
+  disconnectSchema
+]);
+
+// src/provider/index.ts
+async function getProviderOrThrow(getProvider) {
+  const provider = await getProvider?.() || window.XverseProviders?.BitcoinProvider || window.BitcoinProvider;
+  if (!provider) {
+    throw new Error("No Bitcoin wallet installed");
   }
-  parseError = (error) => {
-    return {
-      code: error.response?.status,
-      message: JSON.stringify(error.response?.data)
-    };
-  };
-  estimateMintCost = async (mintParams) => {
-    try {
-      const response = await this.client.post("/runes/mint/estimate", {
-        ...mintParams
-      });
-      return {
-        data: response.data
-      };
-    } catch (error) {
-      const err = error;
-      return {
-        error: this.parseError(err)
-      };
-    }
-  };
-  estimateEtchCost = async (etchParams) => {
-    try {
-      const response = await this.client.post("/runes/etch/estimate", {
-        ...etchParams
-      });
-      return {
-        data: response.data
-      };
-    } catch (error) {
-      const err = error;
-      return {
-        error: this.parseError(err)
-      };
-    }
-  };
-  createMintOrder = async (mintOrderParams) => {
-    try {
-      const response = await this.client.post("/runes/mint/orders", {
-        ...mintOrderParams
-      });
-      return {
-        data: response.data
-      };
-    } catch (error) {
-      const err = error;
-      return {
-        error: this.parseError(err)
-      };
-    }
-  };
-  createEtchOrder = async (etchOrderParams) => {
-    try {
-      const response = await this.client.post("/runes/etch/orders", {
-        ...etchOrderParams
-      });
-      return {
-        data: response.data
-      };
-    } catch (error) {
-      const err = error;
-      return {
-        error: this.parseError(err)
-      };
-    }
-  };
-  executeMint = async (orderId, fundTransactionId) => {
-    try {
-      const response = await this.client.post(`/runes/mint/orders/${orderId}/execute`, {
-        fundTransactionId
-      });
-      return {
-        data: response.data
-      };
-    } catch (error) {
-      const err = error;
-      return {
-        error: this.parseError(err)
-      };
-    }
-  };
-  executeEtch = async (orderId, fundTransactionId) => {
-    try {
-      const response = await this.client.post(`/runes/etch/orders/${orderId}/execute`, {
-        fundTransactionId
-      });
-      return {
-        data: response.data
-      };
-    } catch (error) {
-      const err = error;
-      return {
-        error: this.parseError(err)
-      };
-    }
-  };
-  getOrder = async (orderId) => {
-    try {
-      const response = await this.client.get(`/orders/${orderId}`);
-      return {
-        data: response.data
-      };
-    } catch (error) {
-      const err = error;
-      return {
-        error: this.parseError(err)
-      };
-    }
-  };
-  rbfOrder = async (rbfRequest) => {
-    const { orderId, newFeeRate } = rbfRequest;
-    try {
-      const response = await this.client.post(`/orders/${orderId}/rbf-estimate`, {
-        newFeeRate
-      });
-      return {
-        data: response.data
-      };
-    } catch (error) {
-      const err = error;
+  return provider;
+}
+function getProviders() {
+  if (!window.btc_providers) window.btc_providers = [];
+  return window.btc_providers;
+}
+function getProviderById(providerId) {
+  return providerId?.split(".").reduce((acc, part) => acc?.[part], window);
+}
+function isProviderInstalled(providerId) {
+  return !!getProviderById(providerId);
+}
+function setDefaultProvider(providerId) {
+  localStorage.setItem("sats-connect_defaultProvider", providerId);
+}
+function getDefaultProvider() {
+  return localStorage.getItem("sats-connect_defaultProvider");
+}
+function removeDefaultProvider() {
+  localStorage.removeItem("sats-connect_defaultProvider");
+}
+function getSupportedWallets() {
+  const wallets = Object.values(DefaultAdaptersInfo).map((provider) => {
+    {
       return {
-        error: this.parseError(err)
-      };
-    }
-  };
-};
-var clients = {};
-var getRunesApiClient = (network = "Mainnet" /* Mainnet */) => {
-  if (!clients[network]) {
-    clients[network] = new RunesApi(network);
-  }
-  return clients[network];
-};
-
-// 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") {
-        const isMintSupported = walletInfo.result.methods?.includes("runes_mint");
-        if (isMintSupported) {
-          const response = await this.requestInternal("runes_mint", params);
-          if (response) {
-            if (response.status === "success") {
-              return response;
-            }
-            if (response.status === "error" && response.error.code !== -32601 /* 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 ? -32600 /* INVALID_REQUEST */ : -32603 /* 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: -32603 /* 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") {
-        const isEtchSupported = walletInfo.result.methods?.includes("runes_etch");
-        if (isEtchSupported) {
-          const response = await this.requestInternal("runes_etch", params);
-          if (response) {
-            if (response.status === "success") {
-              return response;
-            }
-            if (response.status === "error" && response.error.code !== -32601 /* 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 ? -32600 /* INVALID_REQUEST */ : -32603 /* 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: -32603 /* 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 ? -32600 /* INVALID_REQUEST */ : -32603 /* 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 ? -32600 /* INVALID_REQUEST */ : -32603 /* 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 ? -32600 /* INVALID_REQUEST */ : -32603 /* 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 ? -32600 /* INVALID_REQUEST */ : -32603 /* 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 ? -32600 /* INVALID_REQUEST */ : -32603 /* 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: -32603 /* 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);
-    }
-  }
-};
-
-// src/provider/types.ts
-import * as v4 from "valibot";
-
-// src/addresses/index.ts
-import { createUnsecuredToken } from "jsontokens";
-
-// src/addresses/types.ts
-import * as v3 from "valibot";
-
-// src/request/types/common.ts
-import * as v2 from "valibot";
-var walletTypes = ["software", "ledger", "keystone"];
-var walletTypeSchema = v2.picklist(walletTypes);
-
-// src/addresses/types.ts
-var AddressPurpose = /* @__PURE__ */ ((AddressPurpose2) => {
-  AddressPurpose2["Ordinals"] = "ordinals";
-  AddressPurpose2["Payment"] = "payment";
-  AddressPurpose2["Stacks"] = "stacks";
-  AddressPurpose2["Starknet"] = "starknet";
-  AddressPurpose2["Spark"] = "spark";
-  return AddressPurpose2;
-})(AddressPurpose || {});
-var AddressType = /* @__PURE__ */ ((AddressType3) => {
-  AddressType3["p2pkh"] = "p2pkh";
-  AddressType3["p2sh"] = "p2sh";
-  AddressType3["p2wpkh"] = "p2wpkh";
-  AddressType3["p2wsh"] = "p2wsh";
-  AddressType3["p2tr"] = "p2tr";
-  AddressType3["stacks"] = "stacks";
-  AddressType3["starknet"] = "starknet";
-  AddressType3["spark"] = "spark";
-  return AddressType3;
-})(AddressType || {});
-var addressSchema = v3.object({
-  address: v3.string(),
-  publicKey: v3.string(),
-  purpose: v3.enum(AddressPurpose),
-  addressType: v3.enum(AddressType),
-  walletType: walletTypeSchema
-});
-
-// src/addresses/index.ts
-var getAddress = async (options) => {
-  const provider = await getProviderOrThrow(options.getProvider);
-  const { purposes } = options.payload;
-  if (!purposes) {
-    throw new Error("Address purposes are required");
-  }
-  try {
-    const request2 = createUnsecuredToken(options.payload);
-    const response = await provider.connect(request2);
-    options.onFinish?.(response);
-  } catch (error) {
-    console.error("[Connect] Error during address request", error);
-    options.onCancel?.();
-  }
-};
-
-// src/provider/types.ts
-var accountChangeEventName = "accountChange";
-var accountChangeSchema = v4.object({
-  type: v4.literal(accountChangeEventName),
-  addresses: v4.optional(v4.array(addressSchema))
-});
-var networkChangeEventName = "networkChange";
-var networkChangeSchema = v4.object({
-  type: v4.literal(networkChangeEventName),
-  bitcoin: v4.object({
-    name: v4.enum(BitcoinNetworkType)
-  }),
-  stacks: v4.object({
-    name: v4.string()
-  }),
-  addresses: v4.optional(v4.array(addressSchema))
-});
-var disconnectEventName = "disconnect";
-var disconnectSchema = v4.object({
-  type: v4.literal(disconnectEventName)
-});
-var walletEventSchema = v4.variant("type", [
-  accountChangeSchema,
-  networkChangeSchema,
-  disconnectSchema
-]);
-
-// src/provider/index.ts
-async function getProviderOrThrow(getProvider) {
-  const provider = await getProvider?.() || window.XverseProviders?.BitcoinProvider || window.BitcoinProvider;
-  if (!provider) {
-    throw new Error("No Bitcoin wallet installed");
-  }
-  return provider;
-}
-function getProviders() {
-  if (!window.btc_providers) window.btc_providers = [];
-  return window.btc_providers;
-}
-function getProviderById(providerId) {
-  return providerId?.split(".").reduce((acc, part) => acc?.[part], window);
-}
-function isProviderInstalled(providerId) {
-  return !!getProviderById(providerId);
-}
-function setDefaultProvider(providerId) {
-  localStorage.setItem("sats-connect_defaultProvider", providerId);
-}
-function getDefaultProvider() {
-  return localStorage.getItem("sats-connect_defaultProvider");
-}
-function removeDefaultProvider() {
-  localStorage.removeItem("sats-connect_defaultProvider");
-}
-function getSupportedWallets() {
-  const wallets = Object.values(DefaultAdaptersInfo).map((provider) => {
-    {
-      return {
-        ...provider,
-        isInstalled: isProviderInstalled(provider.id)
+        ...provider,
+        isInstalled: isProviderInstalled(provider.id)
       };
     }
   });
   return wallets;
 }
 
-// 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);
-  };
-};
-
-// src/adapters/unisat.ts
-import { AddressType as AddressType2, getAddressInfo } from "bitcoin-address-validation";
-import { Buffer } from "buffer";
-
 // src/request/index.ts
-import * as v25 from "valibot";
+import * as v35 from "valibot";
 
 // src/request/types/btcMethods.ts
 import * as v6 from "valibot";
@@ -910,11 +411,6 @@ var addNetworkResultSchema = v5.object({
 });
 
 // src/request/types/btcMethods.ts
-var ProviderPlatform = /* @__PURE__ */ ((ProviderPlatform2) => {
-  ProviderPlatform2["Web"] = "web";
-  ProviderPlatform2["Mobile"] = "mobile";
-  return ProviderPlatform2;
-})(ProviderPlatform || {});
 var getInfoMethodName = "getInfo";
 var getInfoParamsSchema = v6.nullish(v6.null());
 var getInfoResultSchema = v6.object({
@@ -922,10 +418,6 @@ var getInfoResultSchema = v6.object({
    * Version of the wallet.
    */
   version: v6.string(),
-  /**
-   * The platform the wallet is running on (web or mobile).
-   */
-  platform: v6.optional(v6.enum(ProviderPlatform)),
   /**
    * [WBIP](https://wbips.netlify.app/wbips/WBIP002) methods supported by the wallet.
    */
@@ -1313,10 +805,10 @@ var runesTransferRequestMessageSchema = v11.object({
   }).entries
 });
 
-// src/request/types/sparkMethods/getAddresses.ts
+// src/request/types/sparkMethods/flashnetMethods/getJwt.ts
 import * as v12 from "valibot";
-var sparkGetAddressesMethodName = "spark_getAddresses";
-var sparkGetAddressesParamsSchema = v12.nullish(
+var sparkFlashnetGetJwtMethodName = "spark_flashnet_getJwt";
+var sparkFlashnetGetJwtParamsSchema = v12.nullish(
   v12.object({
     /**
      * A message to be displayed to the user in the request prompt.
@@ -1324,135 +816,315 @@ var sparkGetAddressesParamsSchema = v12.nullish(
     message: v12.optional(v12.string())
   })
 );
-var sparkGetAddressesResultSchema = v12.object({
+var sparkFlashnetGetJwtResultSchema = v12.object({
+  /**
+   * The JWT token for authenticated requests to the Flashnet API.
+   */
+  jwt: v12.string()
+});
+var sparkFlashnetGetJwtRequestMessageSchema = v12.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v12.object({
+    method: v12.literal(sparkFlashnetGetJwtMethodName),
+    params: sparkFlashnetGetJwtParamsSchema,
+    id: v12.string()
+  }).entries
+});
+
+// src/request/types/sparkMethods/flashnetMethods/intents/addLiquidity.ts
+import * as v13 from "valibot";
+var sparkFlashnetAddLiquidityIntentSchema = v13.object({
+  type: v13.literal("addLiquidity"),
+  data: v13.object({
+    userPublicKey: v13.string(),
+    poolId: v13.string(),
+    assetAAmount: v13.string(),
+    assetBAmount: v13.string(),
+    assetAMinAmountIn: v13.string(),
+    assetBMinAmountIn: v13.string(),
+    assetATransferId: v13.string(),
+    assetBTransferId: v13.string(),
+    nonce: v13.string()
+  })
+});
+
+// src/request/types/sparkMethods/flashnetMethods/intents/clawback.ts
+import * as v14 from "valibot";
+var sparkFlashnetClawbackIntentSchema = v14.object({
+  type: v14.literal("clawback"),
+  data: v14.object({
+    senderPublicKey: v14.string(),
+    sparkTransferId: v14.string(),
+    lpIdentityPublicKey: v14.string(),
+    nonce: v14.string()
+  })
+});
+
+// src/request/types/sparkMethods/flashnetMethods/intents/confirmInitialDeposit.ts
+import * as v15 from "valibot";
+var sparkFlashnetConfirmInitialDepositIntentSchema = v15.object({
+  type: v15.literal("confirmInitialDeposit"),
+  data: v15.object({
+    poolId: v15.string(),
+    assetASparkTransferId: v15.string(),
+    poolOwnerPublicKey: v15.string(),
+    nonce: v15.string()
+  })
+});
+
+// src/request/types/sparkMethods/flashnetMethods/intents/createConstantProductPool.ts
+import * as v16 from "valibot";
+var sparkFlashnetCreateConstantProductPoolIntentSchema = v16.object({
+  type: v16.literal("createConstantProductPool"),
+  data: v16.object({
+    poolOwnerPublicKey: v16.string(),
+    assetAAddress: v16.string(),
+    assetBAddress: v16.string(),
+    lpFeeRateBps: v16.number(),
+    totalHostFeeRateBps: v16.number(),
+    nonce: v16.string()
+  })
+});
+
+// src/request/types/sparkMethods/flashnetMethods/intents/createSingleSidedPool.ts
+import * as v17 from "valibot";
+var sparkFlashnetCreateSingleSidedPoolIntentSchema = v17.object({
+  type: v17.literal("createSingleSidedPool"),
+  data: v17.object({
+    assetAAddress: v17.string(),
+    assetBAddress: v17.string(),
+    assetAInitialReserve: v17.string(),
+    virtualReserveA: v17.union([v17.number(), v17.string()]),
+    virtualReserveB: v17.union([v17.number(), v17.string()]),
+    threshold: v17.union([v17.number(), v17.string()]),
+    lpFeeRateBps: v17.number(),
+    totalHostFeeRateBps: v17.number(),
+    poolOwnerPublicKey: v17.string(),
+    nonce: v17.string()
+  })
+});
+
+// src/request/types/sparkMethods/flashnetMethods/intents/removeLiquidity.ts
+import * as v18 from "valibot";
+var sparkFlashnetRemoveLiquidityIntentSchema = v18.object({
+  type: v18.literal("removeLiquidity"),
+  data: v18.object({
+    userPublicKey: v18.string(),
+    poolId: v18.string(),
+    lpTokensToRemove: v18.string(),
+    nonce: v18.string()
+  })
+});
+
+// src/request/types/sparkMethods/flashnetMethods/intents/routeSwap.ts
+import * as v19 from "valibot";
+var sparkFlashnetRouteSwapIntentSchema = v19.object({
+  type: v19.literal("executeRouteSwap"),
+  data: v19.object({
+    userPublicKey: v19.string(),
+    initialSparkTransferId: v19.string(),
+    hops: v19.array(
+      v19.object({
+        poolId: v19.string(),
+        assetInAddress: v19.string(),
+        assetOutAddress: v19.string(),
+        hopIntegratorFeeRateBps: v19.optional(v19.number())
+      })
+    ),
+    inputAmount: v19.string(),
+    maxRouteSlippageBps: v19.number(),
+    minAmountOut: v19.string(),
+    defaultIntegratorFeeRateBps: v19.optional(v19.number()),
+    nonce: v19.string()
+  })
+});
+
+// src/request/types/sparkMethods/flashnetMethods/intents/swap.ts
+import * as v20 from "valibot";
+var sparkFlashnetSwapIntentSchema = v20.object({
+  type: v20.literal("executeSwap"),
+  data: v20.object({
+    userPublicKey: v20.string(),
+    poolId: v20.string(),
+    transferId: v20.string(),
+    assetInAddress: v20.string(),
+    assetOutAddress: v20.string(),
+    amountIn: v20.string(),
+    maxSlippageBps: v20.number(),
+    minAmountOut: v20.string(),
+    totalIntegratorFeeRateBps: v20.optional(v20.number()),
+    nonce: v20.string()
+  })
+});
+
+// src/request/types/sparkMethods/flashnetMethods/signIntent.ts
+import * as v21 from "valibot";
+var sparkFlashnetSignIntentMethodName = "spark_flashnet_signIntent";
+var sparkFlashnetSignIntentParamsSchema = v21.union([
+  sparkFlashnetSwapIntentSchema,
+  sparkFlashnetRouteSwapIntentSchema,
+  sparkFlashnetAddLiquidityIntentSchema,
+  sparkFlashnetClawbackIntentSchema,
+  sparkFlashnetConfirmInitialDepositIntentSchema,
+  sparkFlashnetCreateConstantProductPoolIntentSchema,
+  sparkFlashnetCreateSingleSidedPoolIntentSchema,
+  sparkFlashnetRemoveLiquidityIntentSchema
+]);
+var sparkFlashnetSignIntentResultSchema = v21.object({
+  /**
+   * The signed intent as a hex string.
+   */
+  signature: v21.string()
+});
+var sparkFlashnetSignIntentRequestMessageSchema = v21.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v21.object({
+    method: v21.literal(sparkFlashnetSignIntentMethodName),
+    params: sparkFlashnetSignIntentParamsSchema,
+    id: v21.string()
+  }).entries
+});
+
+// src/request/types/sparkMethods/getAddresses.ts
+import * as v22 from "valibot";
+var sparkGetAddressesMethodName = "spark_getAddresses";
+var sparkGetAddressesParamsSchema = v22.nullish(
+  v22.object({
+    /**
+     * A message to be displayed to the user in the request prompt.
+     */
+    message: v22.optional(v22.string())
+  })
+);
+var sparkGetAddressesResultSchema = v22.object({
   /**
    * The addresses generated for the given purposes.
    */
-  addresses: v12.array(addressSchema),
+  addresses: v22.array(addressSchema),
   network: getNetworkResultSchema
 });
-var sparkGetAddressesRequestMessageSchema = v12.object({
+var sparkGetAddressesRequestMessageSchema = v22.object({
   ...rpcRequestMessageSchema.entries,
-  ...v12.object({
-    method: v12.literal(sparkGetAddressesMethodName),
+  ...v22.object({
+    method: v22.literal(sparkGetAddressesMethodName),
     params: sparkGetAddressesParamsSchema,
-    id: v12.string()
+    id: v22.string()
   }).entries
 });
 
 // src/request/types/sparkMethods/getBalance.ts
-import * as v13 from "valibot";
+import * as v23 from "valibot";
 var sparkGetBalanceMethodName = "spark_getBalance";
-var sparkGetBalanceParamsSchema = v13.nullish(v13.null());
-var sparkGetBalanceResultSchema = v13.object({
+var sparkGetBalanceParamsSchema = v23.nullish(v23.null());
+var sparkGetBalanceResultSchema = v23.object({
   /**
    * The Spark Bitcoin address balance in sats in string form.
    */
-  balance: v13.string(),
-  tokenBalances: v13.array(
-    v13.object({
+  balance: v23.string(),
+  tokenBalances: v23.array(
+    v23.object({
       /* The address balance of the token in string form as it can overflow a js number */
-      balance: v13.string(),
-      tokenMetadata: v13.object({
-        tokenIdentifier: v13.string(),
-        tokenName: v13.string(),
-        tokenTicker: v13.string(),
-        decimals: v13.number(),
-        maxSupply: v13.string()
+      balance: v23.string(),
+      tokenMetadata: v23.object({
+        tokenIdentifier: v23.string(),
+        tokenName: v23.string(),
+        tokenTicker: v23.string(),
+        decimals: v23.number(),
+        maxSupply: v23.string()
       })
     })
   )
 });
-var sparkGetBalanceRequestMessageSchema = v13.object({
+var sparkGetBalanceRequestMessageSchema = v23.object({
   ...rpcRequestMessageSchema.entries,
-  ...v13.object({
-    method: v13.literal(sparkGetBalanceMethodName),
+  ...v23.object({
+    method: v23.literal(sparkGetBalanceMethodName),
     params: sparkGetBalanceParamsSchema,
-    id: v13.string()
+    id: v23.string()
   }).entries
 });
 
 // src/request/types/sparkMethods/transfer.ts
-import * as v14 from "valibot";
+import * as v24 from "valibot";
 var sparkTransferMethodName = "spark_transfer";
-var sparkTransferParamsSchema = v14.object({
+var sparkTransferParamsSchema = v24.object({
   /**
    * Amount of SATS to transfer as a string or number.
    */
-  amountSats: v14.union([v14.number(), v14.string()]),
+  amountSats: v24.union([v24.number(), v24.string()]),
   /**
    * The recipient's spark address.
    */
-  receiverSparkAddress: v14.string()
+  receiverSparkAddress: v24.string()
 });
-var sparkTransferResultSchema = v14.object({
+var sparkTransferResultSchema = v24.object({
   /**
    * The ID of the transaction.
    */
-  id: v14.string()
+  id: v24.string()
 });
-var sparkTransferRequestMessageSchema = v14.object({
+var sparkTransferRequestMessageSchema = v24.object({
   ...rpcRequestMessageSchema.entries,
-  ...v14.object({
-    method: v14.literal(sparkTransferMethodName),
+  ...v24.object({
+    method: v24.literal(sparkTransferMethodName),
     params: sparkTransferParamsSchema,
-    id: v14.string()
+    id: v24.string()
   }).entries
 });
 
 // src/request/types/sparkMethods/transferToken.ts
-import * as v15 from "valibot";
+import * as v25 from "valibot";
 var sparkTransferTokenMethodName = "spark_transferToken";
-var sparkTransferTokenParamsSchema = v15.object({
+var sparkTransferTokenParamsSchema = v25.object({
   /**
    * Amount of units of the token to transfer as a string or number.
    */
-  tokenAmount: v15.union([v15.number(), v15.string()]),
+  tokenAmount: v25.union([v25.number(), v25.string()]),
   /**
    * The Bech32m token identifier.
    */
-  tokenIdentifier: v15.string(),
+  tokenIdentifier: v25.string(),
   /**
    * The recipient's spark address.
    */
-  receiverSparkAddress: v15.string()
+  receiverSparkAddress: v25.string()
 });
-var sparkTransferTokenResultSchema = v15.object({
+var sparkTransferTokenResultSchema = v25.object({
   /**
    * The ID of the transaction.
    */
-  id: v15.string()
+  id: v25.string()
 });
-var sparkTransferTokenRequestMessageSchema = v15.object({
+var sparkTransferTokenRequestMessageSchema = v25.object({
   ...rpcRequestMessageSchema.entries,
-  ...v15.object({
-    method: v15.literal(sparkTransferTokenMethodName),
+  ...v25.object({
+    method: v25.literal(sparkTransferTokenMethodName),
     params: sparkTransferTokenParamsSchema,
-    id: v15.string()
+    id: v25.string()
   }).entries
 });
 
 // src/request/types/stxMethods/callContract.ts
-import * as v16 from "valibot";
+import * as v26 from "valibot";
 var stxCallContractMethodName = "stx_callContract";
-var stxCallContractParamsSchema = v16.object({
+var stxCallContractParamsSchema = v26.object({
   /**
    * The contract principal.
    *
    * E.g. `"SPKE...GD5C.my-contract"`
    */
-  contract: v16.string(),
+  contract: v26.string(),
   /**
    * The name of the function to call.
    *
    * Note: spec changes ongoing,
    * https://github.com/stacksgov/sips/pull/166#pullrequestreview-1914236999
    */
-  functionName: v16.string(),
+  functionName: v26.string(),
   /**
    * @deprecated in favor of `functionArgs` for @stacks/connect compatibility
    */
-  arguments: v16.optional(v16.array(v16.string())),
+  arguments: v26.optional(v26.array(v26.string())),
   /**
    * The function's arguments. The arguments are expected to be hex-encoded
    * strings of Clarity values.
@@ -1467,274 +1139,274 @@ var stxCallContractParamsSchema = v16.object({
    * const hexArgs = functionArgs.map(cvToHex);
    * ```
    */
-  functionArgs: v16.optional(v16.array(v16.string())),
+  functionArgs: v26.optional(v26.array(v26.string())),
   /**
    * The post conditions to apply to the contract call.
    */
-  postConditions: v16.optional(v16.array(v16.string())),
+  postConditions: v26.optional(v26.array(v26.string())),
   /**
    * The mode to apply to the post conditions.
    */
-  postConditionMode: v16.optional(v16.union([v16.literal("allow"), v16.literal("deny")]))
+  postConditionMode: v26.optional(v26.union([v26.literal("allow"), v26.literal("deny")]))
 });
-var stxCallContractResultSchema = v16.object({
+var stxCallContractResultSchema = v26.object({
   /**
    * The ID of the transaction.
    */
-  txid: v16.string(),
+  txid: v26.string(),
   /**
    * A Stacks transaction as a hex-encoded string.
    */
-  transaction: v16.string()
+  transaction: v26.string()
 });
-var stxCallContractRequestMessageSchema = v16.object({
+var stxCallContractRequestMessageSchema = v26.object({
   ...rpcRequestMessageSchema.entries,
-  ...v16.object({
-    method: v16.literal(stxCallContractMethodName),
+  ...v26.object({
+    method: v26.literal(stxCallContractMethodName),
     params: stxCallContractParamsSchema,
-    id: v16.string()
+    id: v26.string()
   }).entries
 });
 
 // src/request/types/stxMethods/deployContract.ts
-import * as v17 from "valibot";
+import * as v27 from "valibot";
 var stxDeployContractMethodName = "stx_deployContract";
-var stxDeployContractParamsSchema = v17.object({
+var stxDeployContractParamsSchema = v27.object({
   /**
    * Name of the contract.
    */
-  name: v17.string(),
+  name: v27.string(),
   /**
    * The source code of the Clarity contract.
    */
-  clarityCode: v17.string(),
+  clarityCode: v27.string(),
   /**
    * The version of the Clarity contract.
    */
-  clarityVersion: v17.optional(v17.number()),
+  clarityVersion: v27.optional(v27.number()),
   /**
    * The post conditions to apply to the contract call.
    */
-  postConditions: v17.optional(v17.array(v17.string())),
+  postConditions: v27.optional(v27.array(v27.string())),
   /**
    * The mode to apply to the post conditions.
    */
-  postConditionMode: v17.optional(v17.union([v17.literal("allow"), v17.literal("deny")]))
+  postConditionMode: v27.optional(v27.union([v27.literal("allow"), v27.literal("deny")]))
 });
-var stxDeployContractResultSchema = v17.object({
+var stxDeployContractResultSchema = v27.object({
   /**
    * The ID of the transaction.
    */
-  txid: v17.string(),
+  txid: v27.string(),
   /**
    * A Stacks transaction as a hex-encoded string.
    */
-  transaction: v17.string()
+  transaction: v27.string()
 });
-var stxDeployContractRequestMessageSchema = v17.object({
+var stxDeployContractRequestMessageSchema = v27.object({
   ...rpcRequestMessageSchema.entries,
-  ...v17.object({
-    method: v17.literal(stxDeployContractMethodName),
+  ...v27.object({
+    method: v27.literal(stxDeployContractMethodName),
     params: stxDeployContractParamsSchema,
-    id: v17.string()
+    id: v27.string()
   }).entries
 });
 
 // src/request/types/stxMethods/getAccounts.ts
-import * as v18 from "valibot";
+import * as v28 from "valibot";
 var stxGetAccountsMethodName = "stx_getAccounts";
-var stxGetAccountsParamsSchema = v18.nullish(v18.null());
-var stxGetAccountsResultSchema = v18.object({
+var stxGetAccountsParamsSchema = v28.nullish(v28.null());
+var stxGetAccountsResultSchema = v28.object({
   /**
    * The addresses generated for the given purposes.
    */
-  addresses: v18.array(
-    v18.object({
-      address: v18.string(),
-      publicKey: v18.string(),
-      gaiaHubUrl: v18.string(),
-      gaiaAppKey: v18.string()
+  addresses: v28.array(
+    v28.object({
+      address: v28.string(),
+      publicKey: v28.string(),
+      gaiaHubUrl: v28.string(),
+      gaiaAppKey: v28.string()
     })
   ),
   network: getNetworkResultSchema
 });
-var stxGetAccountsRequestMessageSchema = v18.object({
+var stxGetAccountsRequestMessageSchema = v28.object({
   ...rpcRequestMessageSchema.entries,
-  ...v18.object({
-    method: v18.literal(stxGetAccountsMethodName),
+  ...v28.object({
+    method: v28.literal(stxGetAccountsMethodName),
     params: stxGetAccountsParamsSchema,
-    id: v18.string()
+    id: v28.string()
   }).entries
 });
 
 // src/request/types/stxMethods/getAddresses.ts
-import * as v19 from "valibot";
+import * as v29 from "valibot";
 var stxGetAddressesMethodName = "stx_getAddresses";
-var stxGetAddressesParamsSchema = v19.nullish(
-  v19.object({
+var stxGetAddressesParamsSchema = v29.nullish(
+  v29.object({
     /**
      * A message to be displayed to the user in the request prompt.
      */
-    message: v19.optional(v19.string())
+    message: v29.optional(v29.string())
   })
 );
-var stxGetAddressesResultSchema = v19.object({
+var stxGetAddressesResultSchema = v29.object({
   /**
    * The addresses generated for the given purposes.
    */
-  addresses: v19.array(addressSchema),
+  addresses: v29.array(addressSchema),
   network: getNetworkResultSchema
 });
-var stxGetAddressesRequestMessageSchema = v19.object({
+var stxGetAddressesRequestMessageSchema = v29.object({
   ...rpcRequestMessageSchema.entries,
-  ...v19.object({
-    method: v19.literal(stxGetAddressesMethodName),
+  ...v29.object({
+    method: v29.literal(stxGetAddressesMethodName),
     params: stxGetAddressesParamsSchema,
-    id: v19.string()
+    id: v29.string()
   }).entries
 });
 
 // src/request/types/stxMethods/signMessage.ts
-import * as v20 from "valibot";
+import * as v30 from "valibot";
 var stxSignMessageMethodName = "stx_signMessage";
-var stxSignMessageParamsSchema = v20.object({
+var stxSignMessageParamsSchema = v30.object({
   /**
    * The message to sign.
    */
-  message: v20.string()
+  message: v30.string()
 });
-var stxSignMessageResultSchema = v20.object({
+var stxSignMessageResultSchema = v30.object({
   /**
    * The signature of the message.
    */
-  signature: v20.string(),
+  signature: v30.string(),
   /**
    * The public key used to sign the message.
    */
-  publicKey: v20.string()
+  publicKey: v30.string()
 });
-var stxSignMessageRequestMessageSchema = v20.object({
+var stxSignMessageRequestMessageSchema = v30.object({
   ...rpcRequestMessageSchema.entries,
-  ...v20.object({
-    method: v20.literal(stxSignMessageMethodName),
+  ...v30.object({
+    method: v30.literal(stxSignMessageMethodName),
     params: stxSignMessageParamsSchema,
-    id: v20.string()
+    id: v30.string()
   }).entries
 });
 
 // src/request/types/stxMethods/signStructuredMessage.ts
-import * as v21 from "valibot";
+import * as v31 from "valibot";
 var stxSignStructuredMessageMethodName = "stx_signStructuredMessage";
-var stxSignStructuredMessageParamsSchema = v21.object({
+var stxSignStructuredMessageParamsSchema = v31.object({
   /**
    * The domain to be signed.
    */
-  domain: v21.string(),
+  domain: v31.string(),
   /**
    * Message payload to be signed.
    */
-  message: v21.string(),
+  message: v31.string(),
   /**
    * The public key to sign the message with.
    */
-  publicKey: v21.optional(v21.string())
+  publicKey: v31.optional(v31.string())
 });
-var stxSignStructuredMessageResultSchema = v21.object({
+var stxSignStructuredMessageResultSchema = v31.object({
   /**
    * Signature of the message.
    */
-  signature: v21.string(),
+  signature: v31.string(),
   /**
    * Public key as hex-encoded string.
    */
-  publicKey: v21.string()
+  publicKey: v31.string()
 });
-var stxSignStructuredMessageRequestMessageSchema = v21.object({
+var stxSignStructuredMessageRequestMessageSchema = v31.object({
   ...rpcRequestMessageSchema.entries,
-  ...v21.object({
-    method: v21.literal(stxSignStructuredMessageMethodName),
+  ...v31.object({
+    method: v31.literal(stxSignStructuredMessageMethodName),
     params: stxSignStructuredMessageParamsSchema,
-    id: v21.string()
+    id: v31.string()
   }).entries
 });
 
 // src/request/types/stxMethods/signTransaction.ts
-import * as v22 from "valibot";
+import * as v32 from "valibot";
 var stxSignTransactionMethodName = "stx_signTransaction";
-var stxSignTransactionParamsSchema = v22.object({
+var stxSignTransactionParamsSchema = v32.object({
   /**
    * The transaction to sign as a hex-encoded string.
    */
-  transaction: v22.string(),
+  transaction: v32.string(),
   /**
    * The public key to sign the transaction with. The wallet may use any key
    * when not provided.
    */
-  pubkey: v22.optional(v22.string()),
+  pubkey: v32.optional(v32.string()),
   /**
    * Whether to broadcast the transaction after signing. Defaults to `true`.
    */
-  broadcast: v22.optional(v22.boolean())
+  broadcast: v32.optional(v32.boolean())
 });
-var stxSignTransactionResultSchema = v22.object({
+var stxSignTransactionResultSchema = v32.object({
   /**
    * The signed transaction as a hex-encoded string.
    */
-  transaction: v22.string()
+  transaction: v32.string()
 });
-var stxSignTransactionRequestMessageSchema = v22.object({
+var stxSignTransactionRequestMessageSchema = v32.object({
   ...rpcRequestMessageSchema.entries,
-  ...v22.object({
-    method: v22.literal(stxSignTransactionMethodName),
+  ...v32.object({
+    method: v32.literal(stxSignTransactionMethodName),
     params: stxSignTransactionParamsSchema,
-    id: v22.string()
+    id: v32.string()
   }).entries
 });
 
 // src/request/types/stxMethods/signTransactions.ts
-import * as v23 from "valibot";
+import * as v33 from "valibot";
 var stxSignTransactionsMethodName = "stx_signTransactions";
-var stxSignTransactionsParamsSchema = v23.object({
+var stxSignTransactionsParamsSchema = v33.object({
   /**
    * The transactions to sign as hex-encoded strings.
    */
-  transactions: v23.pipe(
-    v23.array(
-      v23.pipe(
-        v23.string(),
-        v23.check((hex) => {
+  transactions: v33.pipe(
+    v33.array(
+      v33.pipe(
+        v33.string(),
+        v33.check((hex) => {
           return true;
         }, "Invalid hex-encoded Stacks transaction.")
       )
     ),
-    v23.minLength(1)
+    v33.minLength(1)
   ),
   /**
    * Whether the signed transactions should be broadcast after signing. Defaults
    * to `true`.
    */
-  broadcast: v23.optional(v23.boolean())
+  broadcast: v33.optional(v33.boolean())
 });
-var stxSignTransactionsResultSchema = v23.object({
+var stxSignTransactionsResultSchema = v33.object({
   /**
    * The signed transactions as hex-encoded strings, in the same order as in the
    * sign request.
    */
-  transactions: v23.array(v23.string())
+  transactions: v33.array(v33.string())
 });
-var stxSignTransactionsRequestMessageSchema = v23.object({
+var stxSignTransactionsRequestMessageSchema = v33.object({
   ...rpcRequestMessageSchema.entries,
-  ...v23.object({
-    method: v23.literal(stxSignTransactionsMethodName),
+  ...v33.object({
+    method: v33.literal(stxSignTransactionsMethodName),
     params: stxSignTransactionsParamsSchema,
-    id: v23.string()
+    id: v33.string()
   }).entries
 });
 
 // src/request/types/stxMethods/transferStx.ts
-import * as v24 from "valibot";
+import * as v34 from "valibot";
 var stxTransferStxMethodName = "stx_transferStx";
-var stxTransferStxParamsSchema = v24.object({
+var stxTransferStxParamsSchema = v34.object({
   /**
    * Amount of STX tokens to transfer in microstacks as a string. Anything
    * parseable by `BigInt` is acceptable.
@@ -1747,23 +1419,23 @@ var stxTransferStxParamsSchema = v24.object({
    * const amount3 = '1234';
    * ```
    */
-  amount: v24.union([v24.number(), v24.string()]),
+  amount: v34.union([v34.number(), v34.string()]),
   /**
    * The recipient's principal.
    */
-  recipient: v24.string(),
+  recipient: v34.string(),
   /**
    * A string representing the memo.
    */
-  memo: v24.optional(v24.string()),
+  memo: v34.optional(v34.string()),
   /**
    * Version of parameter format.
    */
-  version: v24.optional(v24.string()),
+  version: v34.optional(v34.string()),
   /**
    * The mode of the post conditions.
    */
-  postConditionMode: v24.optional(v24.number()),
+  postConditionMode: v34.optional(v34.number()),
   /**
    * A hex-encoded string representing the post conditions.
    *
@@ -1776,29 +1448,29 @@ var stxTransferStxParamsSchema = v24.object({
    * const hexPostCondition = serializePostCondition(postCondition).toString('hex');
    * ```
    */
-  postConditions: v24.optional(v24.array(v24.string())),
+  postConditions: v34.optional(v34.array(v34.string())),
   /**
    * The public key to sign the transaction with. The wallet may use any key
    * when not provided.
    */
-  pubkey: v24.optional(v24.string())
+  pubkey: v34.optional(v34.string())
 });
-var stxTransferStxResultSchema = v24.object({
+var stxTransferStxResultSchema = v34.object({
   /**
    * The ID of the transaction.
    */
-  txid: v24.string(),
+  txid: v34.string(),
   /**
    * A Stacks transaction as a hex-encoded string.
    */
-  transaction: v24.string()
+  transaction: v34.string()
 });
-var stxTransferStxRequestMessageSchema = v24.object({
+var stxTransferStxRequestMessageSchema = v34.object({
   ...rpcRequestMessageSchema.entries,
-  ...v24.object({
-    method: v24.literal(stxTransferStxMethodName),
+  ...v34.object({
+    method: v34.literal(stxTransferStxMethodName),
     params: stxTransferStxParamsSchema,
-    id: v24.string()
+    id: v34.string()
   }).entries
 });
 
@@ -1808,83 +1480,562 @@ var request = async (method, params, providerId) => {
   if (providerId) {
     provider = await getProviderById(providerId);
   }
-  if (!provider) {
-    throw new Error("no wallet provider was found");
+  if (!provider) {
+    throw new Error("no wallet provider was found");
+  }
+  if (!method) {
+    throw new Error("A wallet method is required");
+  }
+  const response = await provider.request(method, params);
+  if (v35.is(rpcErrorResponseMessageSchema, response)) {
+    return {
+      status: "error",
+      error: response.error
+    };
+  }
+  if (v35.is(rpcSuccessResponseMessageSchema, response)) {
+    return {
+      status: "success",
+      result: response.result
+    };
+  }
+  return {
+    status: "error",
+    error: {
+      code: -32603 /* INTERNAL_ERROR */,
+      message: "Received unknown response from provider.",
+      data: response
+    }
+  };
+};
+var 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);
+};
+
+// src/runes/api.ts
+import axios from "axios";
+var urlNetworkSuffix = {
+  ["Mainnet" /* Mainnet */]: "",
+  ["Testnet" /* Testnet */]: "-testnet",
+  ["Testnet4" /* Testnet4 */]: "-testnet4",
+  ["Signet" /* Signet */]: "-signet"
+};
+var ORDINALS_API_BASE_URL = (network = "Mainnet" /* Mainnet */) => {
+  if (network === "Regtest" /* 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 {
+      const response = await this.client.post("/runes/mint/estimate", {
+        ...mintParams
+      });
+      return {
+        data: response.data
+      };
+    } catch (error) {
+      const err = error;
+      return {
+        error: this.parseError(err)
+      };
+    }
+  };
+  estimateEtchCost = async (etchParams) => {
+    try {
+      const response = await this.client.post("/runes/etch/estimate", {
+        ...etchParams
+      });
+      return {
+        data: response.data
+      };
+    } catch (error) {
+      const err = error;
+      return {
+        error: this.parseError(err)
+      };
+    }
+  };
+  createMintOrder = async (mintOrderParams) => {
+    try {
+      const response = await this.client.post("/runes/mint/orders", {
+        ...mintOrderParams
+      });
+      return {
+        data: response.data
+      };
+    } catch (error) {
+      const err = error;
+      return {
+        error: this.parseError(err)
+      };
+    }
+  };
+  createEtchOrder = async (etchOrderParams) => {
+    try {
+      const response = await this.client.post("/runes/etch/orders", {
+        ...etchOrderParams
+      });
+      return {
+        data: response.data
+      };
+    } catch (error) {
+      const err = error;
+      return {
+        error: this.parseError(err)
+      };
+    }
+  };
+  executeMint = async (orderId, fundTransactionId) => {
+    try {
+      const response = await this.client.post(`/runes/mint/orders/${orderId}/execute`, {
+        fundTransactionId
+      });
+      return {
+        data: response.data
+      };
+    } catch (error) {
+      const err = error;
+      return {
+        error: this.parseError(err)
+      };
+    }
+  };
+  executeEtch = async (orderId, fundTransactionId) => {
+    try {
+      const response = await this.client.post(`/runes/etch/orders/${orderId}/execute`, {
+        fundTransactionId
+      });
+      return {
+        data: response.data
+      };
+    } catch (error) {
+      const err = error;
+      return {
+        error: this.parseError(err)
+      };
+    }
+  };
+  getOrder = async (orderId) => {
+    try {
+      const response = await this.client.get(`/orders/${orderId}`);
+      return {
+        data: response.data
+      };
+    } catch (error) {
+      const err = error;
+      return {
+        error: this.parseError(err)
+      };
+    }
+  };
+  rbfOrder = async (rbfRequest) => {
+    const { orderId, newFeeRate } = rbfRequest;
+    try {
+      const response = await this.client.post(`/orders/${orderId}/rbf-estimate`, {
+        newFeeRate
+      });
+      return {
+        data: response.data
+      };
+    } catch (error) {
+      const err = error;
+      return {
+        error: this.parseError(err)
+      };
+    }
+  };
+};
+var clients = {};
+var getRunesApiClient = (network = "Mainnet" /* Mainnet */) => {
+  if (!clients[network]) {
+    clients[network] = new RunesApi(network);
+  }
+  return clients[network];
+};
+
+// 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") {
+        const isMintSupported = walletInfo.result.methods?.includes("runes_mint");
+        if (isMintSupported) {
+          const response = await this.requestInternal("runes_mint", params);
+          if (response) {
+            if (response.status === "success") {
+              return response;
+            }
+            if (response.status === "error" && response.error.code !== -32601 /* 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 ? -32600 /* INVALID_REQUEST */ : -32603 /* 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: -32603 /* INTERNAL_ERROR */,
+          message: error.message
+        }
+      };
+    }
   }
-  if (!method) {
-    throw new Error("A wallet method is required");
+  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") {
+        const isEtchSupported = walletInfo.result.methods?.includes("runes_etch");
+        if (isEtchSupported) {
+          const response = await this.requestInternal("runes_etch", params);
+          if (response) {
+            if (response.status === "success") {
+              return response;
+            }
+            if (response.status === "error" && response.error.code !== -32601 /* 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 ? -32600 /* INVALID_REQUEST */ : -32603 /* 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: -32603 /* INTERNAL_ERROR */,
+          message: error.message
+        }
+      };
+    }
   }
-  const response = await provider.request(method, params);
-  if (v25.is(rpcErrorResponseMessageSchema, response)) {
+  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: response.error
+      error: {
+        code: response.error.code === 400 ? -32600 /* INVALID_REQUEST */ : -32603 /* INTERNAL_ERROR */,
+        message: response.error.message
+      }
     };
   }
-  if (v25.is(rpcSuccessResponseMessageSchema, response)) {
+  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: "success",
-      result: response.result
+      status: "error",
+      error: {
+        code: response.error.code === 400 ? -32600 /* INVALID_REQUEST */ : -32603 /* INTERNAL_ERROR */,
+        message: response.error.message
+      }
     };
   }
-  return {
-    status: "error",
-    error: {
-      code: -32603 /* INTERNAL_ERROR */,
-      message: "Received unknown response from provider.",
-      data: response
+  async getOrder(params) {
+    const response = await getRunesApiClient(params.network).getOrder(params.id);
+    if (response.data) {
+      return {
+        status: "success",
+        result: response.data
+      };
     }
-  };
-};
-var addListener = (...rawArgs) => {
-  const [listenerInfo, providerId] = (() => {
-    if (rawArgs.length === 1) {
-      return [rawArgs[0], void 0];
+    return {
+      status: "error",
+      error: {
+        code: response.error.code === 400 || response.error.code === 404 ? -32600 /* INVALID_REQUEST */ : -32603 /* 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
+        }
+      };
     }
-    if (rawArgs.length === 2) {
-      if (typeof rawArgs[1] === "function") {
-        return [
+    return {
+      status: "error",
+      error: {
+        code: response.error.code === 400 || response.error.code === 404 ? -32600 /* INVALID_REQUEST */ : -32603 /* 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 ? -32600 /* INVALID_REQUEST */ : -32603 /* INTERNAL_ERROR */,
+            message: orderResponse.error.message
+          }
+        };
+      }
+      const paymentResponse = await this.requestInternal("sendTransfer", {
+        recipients: [
           {
-            eventName: rawArgs[0],
-            cb: rawArgs[1]
-          },
-          void 0
-        ];
-      } else {
-        return rawArgs;
+            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: -32603 /* INTERNAL_ERROR */,
+          message: error.message
+        }
+      };
     }
-    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 () => {
-    };
+  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);
+    }
   }
-  return provider.addListener(listenerInfo);
+};
+
+// src/adapters/xverse.ts
+var XverseAdapter = class extends SatsConnectAdapter {
+  id = DefaultAdaptersInfo.xverse.id;
+  requestInternal = async (method, params) => {
+    return request(method, params, this.id);
+  };
+  addListener = (listenerInfo) => {
+    return addListener(listenerInfo, this.id);
+  };
 };
 
 // src/adapters/unisat.ts
+import { AddressType as AddressType2, getAddressInfo } from "bitcoin-address-validation";
+import { Buffer } from "buffer";
 function convertSignInputsToInputType(signInputs) {
   let result = [];
   if (!signInputs) {
@@ -2070,77 +2221,32 @@ var UnisatAdapter = class extends SatsConnectAdapter {
   };
 };
 
-// src/adapters/xverse/sanitizeRequest.ts
-var sanitizeRequest = (method, params, providerInfo) => {
-  try {
-    const [major, minor, patch] = providerInfo.version.split(".").map((part) => parseInt(part, 10));
-    const platform = providerInfo.platform;
-    if (
-      // platform is missing for versions < 1.5.0 on web and < 1.55.0 on mobile
-      !platform || platform === "web" /* Web */ && major <= 1 && minor <= 4 || platform === "mobile" /* Mobile */ && major <= 1 && minor <= 54
-    ) {
-      const v1Sanitized = sanitizeAddressPurposeRequest(method, params);
-      method = v1Sanitized.method;
-      params = v1Sanitized.params;
-    }
-  } catch {
-  }
-  return { method, params };
-};
-var sanitizeAddressPurposeRequest = (method, params) => {
-  const filterPurposes = (purposes) => purposes?.filter(
-    (purpose) => purpose !== "spark" /* Spark */ && purpose !== "starknet" /* Starknet */
-  );
-  if (method === "wallet_connect") {
-    const typedParams = params;
-    if (!typedParams) {
-      return { method, params };
-    }
-    const { addresses, ...rest } = typedParams;
-    const overrideParams = {
-      ...rest,
-      addresses: filterPurposes(addresses)
-    };
-    return { method, params: overrideParams };
-  }
-  if (method === "getAccounts") {
-    const typedParams = params;
-    const { purposes, ...rest } = typedParams;
-    const overrideParams = { ...rest, purposes: filterPurposes(purposes) };
-    return { method, params: overrideParams };
-  }
-  if (method === "getAddresses") {
-    const typedParams = params;
-    const { purposes, ...rest } = typedParams;
-    const overrideParams = { ...rest, purposes: filterPurposes(purposes) };
-    return { method, params: overrideParams };
-  }
-  return { method, params };
-};
-
-// src/adapters/xverse/index.ts
-var XverseAdapter = class extends SatsConnectAdapter {
-  id = DefaultAdaptersInfo.xverse.id;
-  providerInfo;
+// src/adapters/fordefi.ts
+var FordefiAdapter = class extends SatsConnectAdapter {
+  id = DefaultAdaptersInfo.fordefi.id;
   requestInternal = async (method, params) => {
-    if (!this.providerInfo) {
-      const infoResult = await request("getInfo", null, this.id);
-      if (infoResult.status === "success") {
-        this.providerInfo = infoResult.result;
-      }
+    const provider = getProviderById(this.id);
+    if (!provider) {
+      throw new Error("no wallet provider was found");
     }
-    if (this.providerInfo) {
-      const sanitized = sanitizeRequest(method, params, this.providerInfo);
-      if (sanitized.overrideResponse) {
-        return sanitized.overrideResponse;
-      }
-      method = sanitized.method;
-      params = sanitized.params;
+    if (!method) {
+      throw new Error("A wallet method is required");
     }
-    return request(method, params, this.id);
+    return await provider.request(method, params);
   };
-  addListener = (listenerInfo) => {
-    return addListener(listenerInfo, this.id);
+  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);
   };
 };
 
@@ -2406,7 +2512,6 @@ export {
   DefaultAdaptersInfo,
   MessageSigningProtocols,
   PermissionRequestParams,
-  ProviderPlatform,
   RpcErrorCode,
   RpcIdSchema,
   SatsConnectAdapter,
@@ -2542,6 +2647,22 @@ export {
   signPsbtRequestMessageSchema,
   signPsbtResultSchema,
   signTransaction,
+  sparkFlashnetAddLiquidityIntentSchema,
+  sparkFlashnetClawbackIntentSchema,
+  sparkFlashnetConfirmInitialDepositIntentSchema,
+  sparkFlashnetCreateConstantProductPoolIntentSchema,
+  sparkFlashnetCreateSingleSidedPoolIntentSchema,
+  sparkFlashnetGetJwtMethodName,
+  sparkFlashnetGetJwtParamsSchema,
+  sparkFlashnetGetJwtRequestMessageSchema,
+  sparkFlashnetGetJwtResultSchema,
+  sparkFlashnetRemoveLiquidityIntentSchema,
+  sparkFlashnetRouteSwapIntentSchema,
+  sparkFlashnetSignIntentMethodName,
+  sparkFlashnetSignIntentParamsSchema,
+  sparkFlashnetSignIntentRequestMessageSchema,
+  sparkFlashnetSignIntentResultSchema,
+  sparkFlashnetSwapIntentSchema,
   sparkGetAddressesMethodName,
   sparkGetAddressesParamsSchema,
   sparkGetAddressesRequestMessageSchema,