@sats-connect/core 0.1.2 → 0.2.0

package/dist/index.mjs

@@ -1,24 +1,84 @@
-// src/types.ts
+// src/provider/index.ts
+import omit from "lodash.omit";
+
+// src/provider/types.ts
 import * as v from "valibot";
+var accountChangeEventName = "accountChange";
+var accountChangeSchema = v.object({
+  type: v.literal(accountChangeEventName)
+});
+var networkChangeEventName = "networkChange";
+var networkChangeSchema = v.object({
+  type: v.literal(networkChangeEventName)
+});
+var walletEventSchema = v.variant("type", [accountChangeSchema, networkChangeSchema]);
+
+// 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 btc_providers = getProviders();
+  const allProviders = [...btc_providers];
+  for (const key in omit(DefaultAdaptersInfo, ["xverse"])) {
+    allProviders.push(DefaultAdaptersInfo[key]);
+  }
+  const wallets = allProviders.map((provider) => {
+    {
+      return {
+        ...provider,
+        isInstalled: isProviderInstalled(provider.id)
+      };
+    }
+  });
+  return wallets;
+}
+
+// src/types.ts
+import * as v2 from "valibot";
 var BitcoinNetworkType = /* @__PURE__ */ ((BitcoinNetworkType3) => {
   BitcoinNetworkType3["Mainnet"] = "Mainnet";
   BitcoinNetworkType3["Testnet"] = "Testnet";
   BitcoinNetworkType3["Signet"] = "Signet";
   return BitcoinNetworkType3;
 })(BitcoinNetworkType || {});
-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 = v2.optional(v2.union([v2.string(), v2.number(), v2.null()]));
+var rpcRequestMessageSchema = v2.object({
+  jsonrpc: v2.literal("2.0"),
+  method: v2.string(),
+  params: v2.optional(
+    v2.union([
+      v2.array(v2.unknown()),
+      v2.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()
+      v2.null()
     ])
   ),
   id: RpcIdSchema
@@ -34,687 +94,181 @@ 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 = v2.object({
+  jsonrpc: v2.literal("2.0"),
+  result: v2.nonOptional(v2.unknown()),
   id: RpcIdSchema
 });
-var rpcErrorResponseMessageSchema = v.object({
-  jsonrpc: v.literal("2.0"),
-  error: v.nonOptional(v.unknown()),
+var rpcErrorResponseMessageSchema = v2.object({
+  jsonrpc: v2.literal("2.0"),
+  error: v2.nonOptional(v2.unknown()),
   id: RpcIdSchema
 });
-var rpcResponseMessageSchema = v.union([
+var rpcResponseMessageSchema = v2.union([
   rpcSuccessResponseMessageSchema,
   rpcErrorResponseMessageSchema
 ]);
 
-// src/runes/api.ts
-import axios from "axios";
-var urlNetworkSuffix = {
-  ["Mainnet" /* Mainnet */]: "",
-  ["Testnet" /* Testnet */]: "-testnet",
-  ["Signet" /* Signet */]: "-signet"
-};
-var ORDINALS_API_BASE_URL = (network = "Mainnet" /* Mainnet */) => `https://ordinals${urlNetworkSuffix[network]}.xverse.app/v1`;
-var RunesApi = class {
-  client;
-  constructor(network) {
-    this.client = axios.create({
-      baseURL: ORDINALS_API_BASE_URL(network)
-    });
+// src/request/index.ts
+import * as v10 from "valibot";
+
+// src/addresses/index.ts
+import { createUnsecuredToken } from "jsontokens";
+
+// src/addresses/types.ts
+import * as v3 from "valibot";
+var AddressPurpose = /* @__PURE__ */ ((AddressPurpose2) => {
+  AddressPurpose2["Ordinals"] = "ordinals";
+  AddressPurpose2["Payment"] = "payment";
+  AddressPurpose2["Stacks"] = "stacks";
+  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";
+  return AddressType3;
+})(AddressType || {});
+var addressSchema = v3.object({
+  address: v3.string(),
+  publicKey: v3.string(),
+  purpose: v3.enum(AddressPurpose),
+  addressType: v3.enum(AddressType)
+});
+
+// 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");
   }
-  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
-        }
-      };
-    }
-  }
-  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/index.ts
-import omit from "lodash.omit";
-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 btc_providers = getProviders();
-  const allProviders = [...btc_providers];
-  for (const key in omit(DefaultAdaptersInfo, ["xverse"])) {
-    allProviders.push(DefaultAdaptersInfo[key]);
-  }
-  const wallets = allProviders.map((provider) => {
-    {
-      return {
-        ...provider,
-        isInstalled: isProviderInstalled(provider.id)
-      };
-    }
-  });
-  return wallets;
-}
-
-// src/request/index.ts
-import * as v9 from "valibot";
-
-// src/addresses/index.ts
-import { createUnsecuredToken } from "jsontokens";
-
-// src/addresses/types.ts
-import * as v2 from "valibot";
-var AddressPurpose = /* @__PURE__ */ ((AddressPurpose2) => {
-  AddressPurpose2["Ordinals"] = "ordinals";
-  AddressPurpose2["Payment"] = "payment";
-  AddressPurpose2["Stacks"] = "stacks";
-  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";
-  return AddressType3;
-})(AddressType || {});
-var addressSchema = v2.object({
-  address: v2.string(),
-  publicKey: v2.string(),
-  purpose: v2.enum(AddressPurpose),
-  addressType: v2.enum(AddressType)
-});
-
-// 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?.();
+  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/request/types/stxMethods.ts
-import * as v3 from "valibot";
+import * as v4 from "valibot";
 var stxGetAddressesMethodName = "stx_getAddresses";
-var stxGetAddressesParamsSchema = v3.nullish(
-  v3.object({
+var stxGetAddressesParamsSchema = v4.nullish(
+  v4.object({
     /**
      * A message to be displayed to the user in the request prompt.
      */
-    message: v3.optional(v3.string())
+    message: v4.optional(v4.string())
   })
 );
-var stxGetAddressesResultSchema = v3.object({
+var stxGetAddressesResultSchema = v4.object({
   /**
    * The addresses generated for the given purposes.
    */
-  addresses: v3.array(addressSchema)
+  addresses: v4.array(addressSchema)
 });
-var stxGetAddressesRequestMessageSchema = v3.object({
+var stxGetAddressesRequestMessageSchema = v4.object({
   ...rpcRequestMessageSchema.entries,
-  ...v3.object({
-    method: v3.literal(stxGetAddressesMethodName),
+  ...v4.object({
+    method: v4.literal(stxGetAddressesMethodName),
     params: stxGetAddressesParamsSchema,
-    id: v3.string()
+    id: v4.string()
   }).entries
 });
 var stxSignTransactionMethodName = "stx_signTransaction";
-var stxSignTransactionParamsSchema = v3.object({
+var stxSignTransactionParamsSchema = v4.object({
   /**
    * The transaction to sign as a hex-encoded string.
    */
-  transaction: v3.string(),
+  transaction: v4.string(),
   /**
    * The public key to sign the transaction with. The wallet may use any key
    * when not provided.
    */
-  pubkey: v3.optional(v3.string()),
+  pubkey: v4.optional(v4.string()),
   /**
    * Whether to broadcast the transaction after signing. Defaults to `true`.
    */
-  broadcast: v3.optional(v3.boolean())
+  broadcast: v4.optional(v4.boolean())
 });
-var stxSignTransactionResultSchema = v3.object({
+var stxSignTransactionResultSchema = v4.object({
   /**
    * The signed transaction as a hex-encoded string.
    */
-  transaction: v3.string()
+  transaction: v4.string()
 });
-var stxSignTransactionRequestMessageSchema = v3.object({
+var stxSignTransactionRequestMessageSchema = v4.object({
   ...rpcRequestMessageSchema.entries,
-  ...v3.object({
-    method: v3.literal(stxSignTransactionMethodName),
+  ...v4.object({
+    method: v4.literal(stxSignTransactionMethodName),
     params: stxSignTransactionParamsSchema,
-    id: v3.string()
+    id: v4.string()
   }).entries
 });
 
 // src/request/types/btcMethods.ts
-import * as v5 from "valibot";
+import * as v6 from "valibot";
 
 // src/request/types/common.ts
-import * as v4 from "valibot";
+import * as v5 from "valibot";
 var walletTypes = ["software", "ledger"];
-var walletTypeSchema = v4.picklist(walletTypes);
+var walletTypeSchema = v5.picklist(walletTypes);
 
 // src/request/types/btcMethods.ts
 var getInfoMethodName = "getInfo";
-var getInfoParamsSchema = v5.nullish(v5.null());
-var getInfoResultSchema = v5.object({
+var getInfoParamsSchema = v6.nullish(v6.null());
+var getInfoResultSchema = v6.object({
   /**
    * Version of the wallet.
    */
-  version: v5.string(),
+  version: v6.string(),
   /**
    * [WBIP](https://wbips.netlify.app/wbips/WBIP002) methods supported by the wallet.
    */
-  methods: v5.optional(v5.array(v5.string())),
+  methods: v6.optional(v6.array(v6.string())),
   /**
    * List of WBIP standards supported by the wallet. Not currently used.
    */
-  supports: v5.array(v5.string())
+  supports: v6.array(v6.string())
 });
-var getInfoRequestMessageSchema = v5.object({
+var getInfoRequestMessageSchema = v6.object({
   ...rpcRequestMessageSchema.entries,
-  ...v5.object({
-    method: v5.literal(getInfoMethodName),
+  ...v6.object({
+    method: v6.literal(getInfoMethodName),
     params: getInfoParamsSchema,
-    id: v5.string()
+    id: v6.string()
   }).entries
 });
 var getAddressesMethodName = "getAddresses";
-var getAddressesParamsSchema = v5.object({
+var getAddressesParamsSchema = v6.object({
   /**
    * The purposes for which to generate addresses. See
    * {@linkcode AddressPurpose} for available purposes.
    */
-  purposes: v5.array(v5.enum(AddressPurpose)),
+  purposes: v6.array(v6.enum(AddressPurpose)),
   /**
    * A message to be displayed to the user in the request prompt.
    */
-  message: v5.optional(v5.string())
+  message: v6.optional(v6.string())
 });
-var getAddressesResultSchema = v5.object({
+var getAddressesResultSchema = v6.object({
   /**
    * The addresses generated for the given purposes.
    */
-  addresses: v5.array(addressSchema)
+  addresses: v6.array(addressSchema)
 });
-var getAddressesRequestMessageSchema = v5.object({
+var getAddressesRequestMessageSchema = v6.object({
   ...rpcRequestMessageSchema.entries,
-  ...v5.object({
-    method: v5.literal(getAddressesMethodName),
+  ...v6.object({
+    method: v6.literal(getAddressesMethodName),
     params: getAddressesParamsSchema,
-    id: v5.string()
+    id: v6.string()
   }).entries
 });
 var signMessageMethodName = "signMessage";
@@ -723,216 +277,237 @@ var MessageSigningProtocols = /* @__PURE__ */ ((MessageSigningProtocols2) => {
   MessageSigningProtocols2["BIP322"] = "BIP322";
   return MessageSigningProtocols2;
 })(MessageSigningProtocols || {});
-var signMessageParamsSchema = v5.object({
+var signMessageParamsSchema = v6.object({
   /**
    * The address used for signing.
    **/
-  address: v5.string(),
+  address: v6.string(),
   /**
    * The message to sign.
    **/
-  message: v5.string(),
+  message: v6.string(),
   /**
    * The protocol to use for signing the message.
    */
-  protocol: v5.optional(v5.enum(MessageSigningProtocols))
+  protocol: v6.optional(v6.enum(MessageSigningProtocols))
 });
-var signMessageResultSchema = v5.object({
+var signMessageResultSchema = v6.object({
   /**
    * The signature of the message.
    */
-  signature: v5.string(),
+  signature: v6.string(),
   /**
    * hash of the message.
    */
-  messageHash: v5.string(),
+  messageHash: v6.string(),
   /**
    * The address used for signing.
    */
-  address: v5.string(),
+  address: v6.string(),
   /**
    * The protocol to use for signing the message.
    */
-  protocol: v5.enum(MessageSigningProtocols)
+  protocol: v6.enum(MessageSigningProtocols)
 });
-var signMessageRequestMessageSchema = v5.object({
+var signMessageRequestMessageSchema = v6.object({
   ...rpcRequestMessageSchema.entries,
-  ...v5.object({
-    method: v5.literal(signMessageMethodName),
+  ...v6.object({
+    method: v6.literal(signMessageMethodName),
     params: signMessageParamsSchema,
-    id: v5.string()
+    id: v6.string()
   }).entries
 });
 var getAccountsMethodName = "getAccounts";
-var getAccountsParamsSchema = v5.object({
+var getAccountsParamsSchema = v6.object({
   /**
    * The purposes for which to generate addresses. See
    * {@linkcode AddressPurpose} for available purposes.
    */
-  purposes: v5.array(v5.enum(AddressPurpose)),
+  purposes: v6.array(v6.enum(AddressPurpose)),
   /**
    * A message to be displayed to the user in the request prompt.
    */
-  message: v5.optional(v5.string())
+  message: v6.optional(v6.string())
 });
-var getAccountsResultSchema = v5.array(
-  v5.object({
+var getAccountsResultSchema = v6.array(
+  v6.object({
     ...addressSchema.entries,
-    ...v5.object({
+    ...v6.object({
       walletType: walletTypeSchema
     }).entries
   })
 );
-var getAccountsRequestMessageSchema = v5.object({
+var getAccountsRequestMessageSchema = v6.object({
   ...rpcRequestMessageSchema.entries,
-  ...v5.object({
-    method: v5.literal(getAccountsMethodName),
+  ...v6.object({
+    method: v6.literal(getAccountsMethodName),
     params: getAccountsParamsSchema,
-    id: v5.string()
+    id: v6.string()
   }).entries
 });
 var getBalanceMethodName = "getBalance";
-var getBalanceParamsSchema = v5.nullish(v5.null());
-var getBalanceResultSchema = v5.object({
+var getBalanceParamsSchema = v6.nullish(v6.null());
+var getBalanceResultSchema = v6.object({
   /**
    * The confirmed balance of the wallet in sats. Using a string due to chrome
    * messages not supporting bigint
    * (https://issues.chromium.org/issues/40116184).
    */
-  confirmed: v5.string(),
+  confirmed: v6.string(),
   /**
    * The unconfirmed balance of the wallet in sats. Using a string due to chrome
    * messages not supporting bigint
    * (https://issues.chromium.org/issues/40116184).
    */
-  unconfirmed: v5.string(),
+  unconfirmed: v6.string(),
   /**
    * The total balance (both confirmed and unconfrimed UTXOs) of the wallet in
    * sats. Using a string due to chrome messages not supporting bigint
    * (https://issues.chromium.org/issues/40116184).
    */
-  total: v5.string()
+  total: v6.string()
 });
-var getBalanceRequestMessageSchema = v5.object({
+var getBalanceRequestMessageSchema = v6.object({
   ...rpcRequestMessageSchema.entries,
-  ...v5.object({
-    method: v5.literal(getBalanceMethodName),
-    id: v5.string()
+  ...v6.object({
+    method: v6.literal(getBalanceMethodName),
+    id: v6.string()
   }).entries
 });
 
 // src/request/types/walletMethods.ts
-import * as v6 from "valibot";
+import * as v7 from "valibot";
 var requestPermissionsMethodName = "wallet_requestPermissions";
-var requestPermissionsParamsSchema = v6.undefined();
-var requestPermissionsResultSchema = v6.literal(true);
-var requestPermissionsRequestMessageSchema = v6.object({
+var requestPermissionsParamsSchema = v7.undefined();
+var requestPermissionsResultSchema = v7.literal(true);
+var requestPermissionsRequestMessageSchema = v7.object({
   ...rpcRequestMessageSchema.entries,
-  ...v6.object({
-    method: v6.literal(requestPermissionsMethodName),
+  ...v7.object({
+    method: v7.literal(requestPermissionsMethodName),
     params: requestPermissionsParamsSchema,
-    id: v6.string()
+    id: v7.string()
   }).entries
 });
 var renouncePermissionsMethodName = "wallet_renouncePermissions";
-var renouncePermissionsParamsSchema = v6.undefined();
-var renouncePermissionsResultSchema = v6.literal(true);
-var renouncePermissionsRequestMessageSchema = v6.object({
+var renouncePermissionsParamsSchema = v7.undefined();
+var renouncePermissionsResultSchema = v7.literal(true);
+var renouncePermissionsRequestMessageSchema = v7.object({
   ...rpcRequestMessageSchema.entries,
-  ...v6.object({
-    method: v6.literal(renouncePermissionsMethodName),
+  ...v7.object({
+    method: v7.literal(renouncePermissionsMethodName),
     params: renouncePermissionsParamsSchema,
-    id: v6.string()
+    id: v7.string()
   }).entries
 });
 var getWalletTypeMethodName = "wallet_getWalletType";
-var getWalletTypeParamsSchema = v6.nullish(v6.null());
+var getWalletTypeParamsSchema = v7.nullish(v7.null());
 var getWalletTypeResultSchema = walletTypeSchema;
-var getWalletTypeRequestMessageSchema = v6.object({
+var getWalletTypeRequestMessageSchema = v7.object({
   ...rpcRequestMessageSchema.entries,
-  ...v6.object({
-    method: v6.literal(getWalletTypeMethodName),
-    id: v6.string()
+  ...v7.object({
+    method: v7.literal(getWalletTypeMethodName),
+    id: v7.string()
   }).entries
 });
 
 // src/request/types/runesMethods.ts
-import * as v7 from "valibot";
+import * as v8 from "valibot";
 var getRunesBalanceMethodName = "runes_getBalance";
-var getRunesBalanceParamsSchema = v7.nullish(v7.null());
-var getRunesBalanceResultSchema = v7.object({
-  balances: v7.array(
-    v7.object({
-      runeName: v7.string(),
-      amount: v7.string(),
-      divisibility: v7.number(),
-      symbol: v7.string(),
-      inscriptionId: v7.nullish(v7.string())
+var getRunesBalanceParamsSchema = v8.nullish(v8.null());
+var getRunesBalanceResultSchema = v8.object({
+  balances: v8.array(
+    v8.object({
+      runeName: v8.string(),
+      amount: v8.string(),
+      divisibility: v8.number(),
+      symbol: v8.string(),
+      inscriptionId: v8.nullish(v8.string())
     })
   )
 });
-var getRunesBalanceRequestMessageSchema = v7.object({
+var getRunesBalanceRequestMessageSchema = v8.object({
   ...rpcRequestMessageSchema.entries,
-  ...v7.object({
-    method: v7.literal(getRunesBalanceMethodName),
+  ...v8.object({
+    method: v8.literal(getRunesBalanceMethodName),
     params: getRunesBalanceParamsSchema,
-    id: v7.string()
+    id: v8.string()
+  }).entries
+});
+var transferRunesMethodName = "runes_transfer";
+var transferRunesParamsSchema = v8.object({
+  recipients: v8.array(
+    v8.object({
+      runeName: v8.string(),
+      amount: v8.string(),
+      address: v8.string()
+    })
+  )
+});
+var transferRunesRequestSchema = v8.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v8.object({
+    method: v8.literal(transferRunesMethodName),
+    params: transferRunesParamsSchema,
+    id: v8.string()
   }).entries
 });
+var TransferRunesResultSchema = v8.object({
+  txid: v8.string()
+});
 
 // src/request/types/ordinalsMethods.ts
-import * as v8 from "valibot";
+import * as v9 from "valibot";
 var getInscriptionsMethodName = "ord_getInscriptions";
-var getInscriptionsParamsSchema = v8.object({
-  offset: v8.number(),
-  limit: v8.number()
+var getInscriptionsParamsSchema = v9.object({
+  offset: v9.number(),
+  limit: v9.number()
 });
-var getInscriptionsResultSchema = v8.object({
-  total: v8.number(),
-  limit: v8.number(),
-  offset: v8.number(),
-  inscriptions: v8.array(
-    v8.object({
-      inscriptionId: v8.string(),
-      inscriptionNumber: v8.string(),
-      address: v8.string(),
-      collectionName: v8.optional(v8.string()),
-      postage: v8.string(),
-      contentLength: v8.string(),
-      contentType: v8.string(),
-      timestamp: v8.number(),
-      offset: v8.number(),
-      genesisTransaction: v8.string(),
-      output: v8.string()
+var getInscriptionsResultSchema = v9.object({
+  total: v9.number(),
+  limit: v9.number(),
+  offset: v9.number(),
+  inscriptions: v9.array(
+    v9.object({
+      inscriptionId: v9.string(),
+      inscriptionNumber: v9.string(),
+      address: v9.string(),
+      collectionName: v9.optional(v9.string()),
+      postage: v9.string(),
+      contentLength: v9.string(),
+      contentType: v9.string(),
+      timestamp: v9.number(),
+      offset: v9.number(),
+      genesisTransaction: v9.string(),
+      output: v9.string()
     })
   )
 });
-var getInscriptionsSchema = v8.object({
+var getInscriptionsSchema = v9.object({
   ...rpcRequestMessageSchema.entries,
-  ...v8.object({
-    method: v8.literal(getInscriptionsMethodName),
+  ...v9.object({
+    method: v9.literal(getInscriptionsMethodName),
     params: getInscriptionsParamsSchema,
-    id: v8.string()
+    id: v9.string()
   }).entries
 });
 var sendInscriptionsMethodName = "ord_sendInscriptions";
-var sendInscriptionsParamsSchema = v8.object({
-  transfers: v8.array(
-    v8.object({
-      address: v8.string(),
-      inscriptionId: v8.string()
+var sendInscriptionsParamsSchema = v9.object({
+  transfers: v9.array(
+    v9.object({
+      address: v9.string(),
+      inscriptionId: v9.string()
     })
   )
 });
-var sendInscriptionsResultSchema = v8.object({
-  txid: v8.string()
+var sendInscriptionsResultSchema = v9.object({
+  txid: v9.string()
 });
-var sendInscriptionsSchema = v8.object({
+var sendInscriptionsSchema = v9.object({
   ...rpcRequestMessageSchema.entries,
-  ...v8.object({
-    method: v8.literal(sendInscriptionsMethodName),
+  ...v9.object({
+    method: v9.literal(sendInscriptionsMethodName),
     params: sendInscriptionsParamsSchema,
-    id: v8.string()
+    id: v9.string()
   }).entries
 });
 
@@ -942,33 +517,503 @@ 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 (v10.is(rpcErrorResponseMessageSchema, response)) {
+    return {
+      status: "error",
+      error: response.error
+    };
+  }
+  if (v10.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 = (event, cb, providerId) => {
+  let provider = window.XverseProviders?.BitcoinProvider || window.BitcoinProvider;
+  if (providerId) {
+    provider = getProviderById(providerId);
+  }
+  if (!provider) {
+    throw new Error("no wallet provider was found");
+  }
+  return provider.addListener(event, cb);
+};
+
+// src/runes/api.ts
+import axios from "axios";
+var urlNetworkSuffix = {
+  ["Mainnet" /* Mainnet */]: "",
+  ["Testnet" /* Testnet */]: "-testnet",
+  ["Signet" /* Signet */]: "-signet"
+};
+var ORDINALS_API_BASE_URL = (network = "Mainnet" /* Mainnet */) => `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
+        }
+      };
+    }
+  }
+  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
+        }
+      };
+    }
   }
-  if (!method) {
-    throw new Error("A wallet method is required");
+  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
+      }
+    };
   }
-  const response = await provider.request(method, params);
-  if (v9.is(rpcErrorResponseMessageSchema, 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: "error",
-      error: response.error
+      error: {
+        code: response.error.code === 400 ? -32600 /* INVALID_REQUEST */ : -32603 /* INTERNAL_ERROR */,
+        message: response.error.message
+      }
     };
   }
-  if (v9.is(rpcSuccessResponseMessageSchema, response)) {
+  async getOrder(params) {
+    const response = await getRunesApiClient(params.network).getOrder(params.id);
+    if (response.data) {
+      return {
+        status: "success",
+        result: response.data
+      };
+    }
     return {
-      status: "success",
-      result: response.result
+      status: "error",
+      error: {
+        code: response.error.code === 400 || response.error.code === 404 ? -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 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/adapters/xverse.ts
@@ -977,6 +1022,15 @@ var XverseAdapter = class extends SatsConnectAdapter {
   requestInternal = async (method, params) => {
     return request(method, params, this.id);
   };
+  addListener = (event, cb) => {
+    return addListener(
+      event,
+      // The types of the `addListener` function being called here are not
+      // entirely accurate.
+      cb,
+      this.id
+    );
+  };
 };
 
 // src/adapters/unisat.ts
@@ -1145,6 +1199,9 @@ var BaseAdapter = class extends SatsConnectAdapter {
   requestInternal = async (method, params) => {
     return request(method, params, this.id);
   };
+  addListener = (..._args) => {
+    throw new Error("Method not supported for `BaseAdapter`.");
+  };
 };
 
 // src/adapters/index.ts
@@ -1190,7 +1247,8 @@ var extractOrValidateCapabilities = (provider, reportedCapabilities) => {
     sendBtcTransaction: validateCapability("sendBtcTransaction"),
     createInscription: validateCapability("createInscription"),
     createRepeatInscriptions: validateCapability("createRepeatInscriptions"),
-    signMultipleTransactions: validateCapability("signMultipleTransactions")
+    signMultipleTransactions: validateCapability("signMultipleTransactions"),
+    addListener: validateCapability("addListener")
   };
   return Object.entries(capabilityMap).reduce((acc, [capability, value]) => {
     if (value)
@@ -1388,6 +1446,10 @@ export {
   RpcErrorCode,
   RpcIdSchema,
   SatsConnectAdapter,
+  TransferRunesResultSchema,
+  accountChangeEventName,
+  accountChangeSchema,
+  addListener,
   addressSchema,
   createInscription,
   createRepeatInscriptions,
@@ -1428,6 +1490,8 @@ export {
   getWalletTypeRequestMessageSchema,
   getWalletTypeResultSchema,
   isProviderInstalled,
+  networkChangeEventName,
+  networkChangeSchema,
   removeDefaultProvider,
   renouncePermissionsMethodName,
   renouncePermissionsParamsSchema,
@@ -1463,6 +1527,10 @@ export {
   stxSignTransactionParamsSchema,
   stxSignTransactionRequestMessageSchema,
   stxSignTransactionResultSchema,
+  transferRunesMethodName,
+  transferRunesParamsSchema,
+  transferRunesRequestSchema,
+  walletEventSchema,
   walletTypeSchema,
   walletTypes
 };