@sats-connect/core 0.4.0-791813d → 0.4.0-80a221a

package/dist/index.js

@@ -0,0 +1,2786 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AddressPurpose: () => AddressPurpose,
+  AddressType: () => AddressType,
+  BaseAdapter: () => BaseAdapter,
+  BitcoinNetworkType: () => BitcoinNetworkType,
+  DefaultAdaptersInfo: () => DefaultAdaptersInfo,
+  MessageSigningProtocols: () => MessageSigningProtocols,
+  RpcErrorCode: () => RpcErrorCode,
+  RpcIdSchema: () => RpcIdSchema,
+  SatsConnectAdapter: () => SatsConnectAdapter,
+  accountChangeEventName: () => accountChangeEventName,
+  accountChangeSchema: () => accountChangeSchema,
+  addListener: () => addListener,
+  addressSchema: () => addressSchema,
+  connectMethodName: () => connectMethodName,
+  connectParamsSchema: () => connectParamsSchema,
+  connectRequestMessageSchema: () => connectRequestMessageSchema,
+  connectResultSchema: () => connectResultSchema,
+  createInscription: () => createInscription,
+  createRepeatInscriptions: () => createRepeatInscriptions,
+  defaultAdapters: () => defaultAdapters,
+  disconnectEventName: () => disconnectEventName,
+  disconnectMethodName: () => disconnectMethodName,
+  disconnectParamsSchema: () => disconnectParamsSchema,
+  disconnectRequestMessageSchema: () => disconnectRequestMessageSchema,
+  disconnectResultSchema: () => disconnectResultSchema,
+  disconnectSchema: () => disconnectSchema,
+  getAccountMethodName: () => getAccountMethodName,
+  getAccountParamsSchema: () => getAccountParamsSchema,
+  getAccountRequestMessageSchema: () => getAccountRequestMessageSchema,
+  getAccountResultSchema: () => getAccountResultSchema,
+  getAccountsMethodName: () => getAccountsMethodName,
+  getAccountsParamsSchema: () => getAccountsParamsSchema,
+  getAccountsRequestMessageSchema: () => getAccountsRequestMessageSchema,
+  getAccountsResultSchema: () => getAccountsResultSchema,
+  getAddress: () => getAddress,
+  getAddressesMethodName: () => getAddressesMethodName,
+  getAddressesParamsSchema: () => getAddressesParamsSchema,
+  getAddressesRequestMessageSchema: () => getAddressesRequestMessageSchema,
+  getAddressesResultSchema: () => getAddressesResultSchema,
+  getBalanceMethodName: () => getBalanceMethodName,
+  getBalanceParamsSchema: () => getBalanceParamsSchema,
+  getBalanceRequestMessageSchema: () => getBalanceRequestMessageSchema,
+  getBalanceResultSchema: () => getBalanceResultSchema,
+  getCapabilities: () => getCapabilities,
+  getCurrentPermissionsMethodName: () => getCurrentPermissionsMethodName,
+  getCurrentPermissionsParamsSchema: () => getCurrentPermissionsParamsSchema,
+  getCurrentPermissionsRequestMessageSchema: () => getCurrentPermissionsRequestMessageSchema,
+  getCurrentPermissionsResultSchema: () => getCurrentPermissionsResultSchema,
+  getDefaultProvider: () => getDefaultProvider,
+  getInfoMethodName: () => getInfoMethodName,
+  getInfoParamsSchema: () => getInfoParamsSchema,
+  getInfoRequestMessageSchema: () => getInfoRequestMessageSchema,
+  getInfoResultSchema: () => getInfoResultSchema,
+  getInscriptionsMethodName: () => getInscriptionsMethodName,
+  getInscriptionsParamsSchema: () => getInscriptionsParamsSchema,
+  getInscriptionsRequestMessageSchema: () => getInscriptionsRequestMessageSchema,
+  getInscriptionsResultSchema: () => getInscriptionsResultSchema,
+  getProviderById: () => getProviderById,
+  getProviderOrThrow: () => getProviderOrThrow,
+  getProviders: () => getProviders,
+  getSupportedWallets: () => getSupportedWallets,
+  getWalletTypeMethodName: () => getWalletTypeMethodName,
+  getWalletTypeParamsSchema: () => getWalletTypeParamsSchema,
+  getWalletTypeRequestMessageSchema: () => getWalletTypeRequestMessageSchema,
+  getWalletTypeResultSchema: () => getWalletTypeResultSchema,
+  isProviderInstalled: () => isProviderInstalled,
+  networkChangeEventName: () => networkChangeEventName,
+  networkChangeSchema: () => networkChangeSchema,
+  permissionTemplate: () => permissionTemplate,
+  removeDefaultProvider: () => removeDefaultProvider,
+  renouncePermissionsMethodName: () => renouncePermissionsMethodName,
+  renouncePermissionsParamsSchema: () => renouncePermissionsParamsSchema,
+  renouncePermissionsRequestMessageSchema: () => renouncePermissionsRequestMessageSchema,
+  renouncePermissionsResultSchema: () => renouncePermissionsResultSchema,
+  request: () => request,
+  requestPermissionsMethodName: () => requestPermissionsMethodName,
+  requestPermissionsParamsSchema: () => requestPermissionsParamsSchema,
+  requestPermissionsRequestMessageSchema: () => requestPermissionsRequestMessageSchema,
+  requestPermissionsResultSchema: () => requestPermissionsResultSchema,
+  rpcErrorResponseMessageSchema: () => rpcErrorResponseMessageSchema,
+  rpcRequestMessageSchema: () => rpcRequestMessageSchema,
+  rpcResponseMessageSchema: () => rpcResponseMessageSchema,
+  rpcSuccessResponseMessageSchema: () => rpcSuccessResponseMessageSchema,
+  runesEtchMethodName: () => runesEtchMethodName,
+  runesEtchParamsSchema: () => runesEtchParamsSchema,
+  runesEtchRequestMessageSchema: () => runesEtchRequestMessageSchema,
+  runesEtchResultSchema: () => runesEtchResultSchema,
+  runesGetBalanceMethodName: () => runesGetBalanceMethodName,
+  runesGetBalanceParamsSchema: () => runesGetBalanceParamsSchema,
+  runesGetBalanceRequestMessageSchema: () => runesGetBalanceRequestMessageSchema,
+  runesGetBalanceResultSchema: () => runesGetBalanceResultSchema,
+  runesMintMethodName: () => runesMintMethodName,
+  runesMintParamsSchema: () => runesMintParamsSchema,
+  runesMintRequestMessageSchema: () => runesMintRequestMessageSchema,
+  runesMintResultSchema: () => runesMintResultSchema,
+  runesTransferMethodName: () => runesTransferMethodName,
+  runesTransferParamsSchema: () => runesTransferParamsSchema,
+  runesTransferRequestMessageSchema: () => runesTransferRequestMessageSchema,
+  runesTransferResultSchema: () => runesTransferResultSchema,
+  sendBtcTransaction: () => sendBtcTransaction,
+  sendInscriptionsMethodName: () => sendInscriptionsMethodName,
+  sendInscriptionsParamsSchema: () => sendInscriptionsParamsSchema,
+  sendInscriptionsRequestMessageSchema: () => sendInscriptionsRequestMessageSchema,
+  sendInscriptionsResultSchema: () => sendInscriptionsResultSchema,
+  sendTransferMethodName: () => sendTransferMethodName,
+  sendTransferParamsSchema: () => sendTransferParamsSchema,
+  sendTransferRequestMessageSchema: () => sendTransferRequestMessageSchema,
+  sendTransferResultSchema: () => sendTransferResultSchema,
+  setDefaultProvider: () => setDefaultProvider,
+  signMessage: () => signMessage,
+  signMessageMethodName: () => signMessageMethodName,
+  signMessageParamsSchema: () => signMessageParamsSchema,
+  signMessageRequestMessageSchema: () => signMessageRequestMessageSchema,
+  signMessageResultSchema: () => signMessageResultSchema,
+  signMultipleTransactions: () => signMultipleTransactions,
+  signPsbtMethodName: () => signPsbtMethodName,
+  signPsbtParamsSchema: () => signPsbtParamsSchema,
+  signPsbtRequestMessageSchema: () => signPsbtRequestMessageSchema,
+  signPsbtResultSchema: () => signPsbtResultSchema,
+  signTransaction: () => signTransaction,
+  stxCallContractMethodName: () => stxCallContractMethodName,
+  stxCallContractParamsSchema: () => stxCallContractParamsSchema,
+  stxCallContractRequestMessageSchema: () => stxCallContractRequestMessageSchema,
+  stxCallContractResultSchema: () => stxCallContractResultSchema,
+  stxDeployContractMethodName: () => stxDeployContractMethodName,
+  stxDeployContractParamsSchema: () => stxDeployContractParamsSchema,
+  stxDeployContractRequestMessageSchema: () => stxDeployContractRequestMessageSchema,
+  stxDeployContractResultSchema: () => stxDeployContractResultSchema,
+  stxGetAccountsMethodName: () => stxGetAccountsMethodName,
+  stxGetAccountsParamsSchema: () => stxGetAccountsParamsSchema,
+  stxGetAccountsRequestMessageSchema: () => stxGetAccountsRequestMessageSchema,
+  stxGetAccountsResultSchema: () => stxGetAccountsResultSchema,
+  stxGetAddressesMethodName: () => stxGetAddressesMethodName,
+  stxGetAddressesParamsSchema: () => stxGetAddressesParamsSchema,
+  stxGetAddressesRequestMessageSchema: () => stxGetAddressesRequestMessageSchema,
+  stxGetAddressesResultSchema: () => stxGetAddressesResultSchema,
+  stxSignMessageMethodName: () => stxSignMessageMethodName,
+  stxSignMessageParamsSchema: () => stxSignMessageParamsSchema,
+  stxSignMessageRequestMessageSchema: () => stxSignMessageRequestMessageSchema,
+  stxSignMessageResultSchema: () => stxSignMessageResultSchema,
+  stxSignStructuredMessageMethodName: () => stxSignStructuredMessageMethodName,
+  stxSignStructuredMessageParamsSchema: () => stxSignStructuredMessageParamsSchema,
+  stxSignStructuredMessageRequestMessageSchema: () => stxSignStructuredMessageRequestMessageSchema,
+  stxSignStructuredMessageResultSchema: () => stxSignStructuredMessageResultSchema,
+  stxSignTransactionMethodName: () => stxSignTransactionMethodName,
+  stxSignTransactionParamsSchema: () => stxSignTransactionParamsSchema,
+  stxSignTransactionRequestMessageSchema: () => stxSignTransactionRequestMessageSchema,
+  stxSignTransactionResultSchema: () => stxSignTransactionResultSchema,
+  stxTransferStxMethodName: () => stxTransferStxMethodName,
+  stxTransferStxParamsSchema: () => stxTransferStxParamsSchema,
+  stxTransferStxRequestMessageSchema: () => stxTransferStxRequestMessageSchema,
+  stxTransferStxResultSchema: () => stxTransferStxResultSchema,
+  walletEventSchema: () => walletEventSchema,
+  walletTypeSchema: () => walletTypeSchema,
+  walletTypes: () => walletTypes
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/provider/types.ts
+var v = __toESM(require("valibot"));
+var accountChangeEventName = "accountChange";
+var accountChangeSchema = v.object({
+  type: v.literal(accountChangeEventName)
+});
+var networkChangeEventName = "networkChange";
+var networkChangeSchema = v.object({
+  type: v.literal(networkChangeEventName)
+});
+var disconnectEventName = "disconnect";
+var disconnectSchema = v.object({
+  type: v.literal(disconnectEventName)
+});
+var walletEventSchema = v.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)
+      };
+    }
+  });
+  return wallets;
+}
+
+// src/types.ts
+var v2 = __toESM(require("valibot"));
+var BitcoinNetworkType = /* @__PURE__ */ ((BitcoinNetworkType2) => {
+  BitcoinNetworkType2["Mainnet"] = "Mainnet";
+  BitcoinNetworkType2["Testnet"] = "Testnet";
+  BitcoinNetworkType2["Signet"] = "Signet";
+  return BitcoinNetworkType2;
+})(BitcoinNetworkType || {});
+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.
+      v2.null()
+    ])
+  ),
+  id: v2.unwrap(RpcIdSchema)
+});
+var RpcErrorCode = /* @__PURE__ */ ((RpcErrorCode2) => {
+  RpcErrorCode2[RpcErrorCode2["PARSE_ERROR"] = -32700] = "PARSE_ERROR";
+  RpcErrorCode2[RpcErrorCode2["INVALID_REQUEST"] = -32600] = "INVALID_REQUEST";
+  RpcErrorCode2[RpcErrorCode2["METHOD_NOT_FOUND"] = -32601] = "METHOD_NOT_FOUND";
+  RpcErrorCode2[RpcErrorCode2["INVALID_PARAMS"] = -32602] = "INVALID_PARAMS";
+  RpcErrorCode2[RpcErrorCode2["INTERNAL_ERROR"] = -32603] = "INTERNAL_ERROR";
+  RpcErrorCode2[RpcErrorCode2["USER_REJECTION"] = -32e3] = "USER_REJECTION";
+  RpcErrorCode2[RpcErrorCode2["METHOD_NOT_SUPPORTED"] = -32001] = "METHOD_NOT_SUPPORTED";
+  RpcErrorCode2[RpcErrorCode2["ACCESS_DENIED"] = -32002] = "ACCESS_DENIED";
+  return RpcErrorCode2;
+})(RpcErrorCode || {});
+var rpcSuccessResponseMessageSchema = v2.object({
+  jsonrpc: v2.literal("2.0"),
+  result: v2.nonOptional(v2.unknown()),
+  id: RpcIdSchema
+});
+var rpcErrorResponseMessageSchema = v2.object({
+  jsonrpc: v2.literal("2.0"),
+  error: v2.nonOptional(v2.unknown()),
+  id: RpcIdSchema
+});
+var rpcResponseMessageSchema = v2.union([
+  rpcSuccessResponseMessageSchema,
+  rpcErrorResponseMessageSchema
+]);
+
+// src/request/index.ts
+var v25 = __toESM(require("valibot"));
+
+// src/request/types/stxMethods/callContract.ts
+var v3 = __toESM(require("valibot"));
+var stxCallContractMethodName = "stx_callContract";
+var stxCallContractParamsSchema = v3.object({
+  /**
+   * The contract principal.
+   *
+   * E.g. `"SPKE...GD5C.my-contract"`
+   */
+  contract: v3.string(),
+  /**
+   * The name of the function to call.
+   *
+   * Note: spec changes ongoing,
+   * https://github.com/stacksgov/sips/pull/166#pullrequestreview-1914236999
+   */
+  functionName: v3.string(),
+  /**
+   * The function's arguments. The arguments are expected to be hex-encoded
+   * strings of Clarity values.
+   *
+   * To convert Clarity values to their hex representation, the `cvToString`
+   * helper from the `@stacks/transactions` package may be helpful.
+   *
+   * ```js
+   * import { cvToString } from '@stacks/transactions';
+   *
+   * const functionArgs = [someClarityValue1, someClarityValue2];
+   * const hexArgs = functionArgs.map(cvToString);
+   * ```
+   */
+  arguments: v3.optional(v3.array(v3.string()))
+});
+var stxCallContractResultSchema = v3.object({
+  /**
+   * The ID of the transaction.
+   */
+  txid: v3.string(),
+  /**
+   * A Stacks transaction as a hex-encoded string.
+   */
+  transaction: v3.string()
+});
+var stxCallContractRequestMessageSchema = v3.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v3.object({
+    method: v3.literal(stxCallContractMethodName),
+    params: stxCallContractParamsSchema,
+    id: v3.string()
+  }).entries
+});
+
+// src/request/types/stxMethods/deployContract.ts
+var v4 = __toESM(require("valibot"));
+var stxDeployContractMethodName = "stx_deployContract";
+var stxDeployContractParamsSchema = v4.object({
+  /**
+   * Name of the contract.
+   */
+  name: v4.string(),
+  /**
+   * The source code of the Clarity contract.
+   */
+  clarityCode: v4.string(),
+  /**
+   * The version of the Clarity contract.
+   */
+  clarityVersion: v4.optional(v4.string())
+});
+var stxDeployContractResultSchema = v4.object({
+  /**
+   * The ID of the transaction.
+   */
+  txid: v4.string(),
+  /**
+   * A Stacks transaction as a hex-encoded string.
+   */
+  transaction: v4.string()
+});
+var stxDeployContractRequestMessageSchema = v4.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v4.object({
+    method: v4.literal(stxDeployContractMethodName),
+    params: stxDeployContractParamsSchema,
+    id: v4.string()
+  }).entries
+});
+
+// src/request/types/stxMethods/getAccounts.ts
+var v5 = __toESM(require("valibot"));
+var stxGetAccountsMethodName = "stx_getAccounts";
+var stxGetAccountsParamsSchema = v5.nullish(v5.null());
+var stxGetAccountsResultSchema = v5.object({
+  /**
+   * The addresses generated for the given purposes.
+   */
+  addresses: v5.array(
+    v5.object({
+      address: v5.string(),
+      publicKey: v5.string(),
+      gaiaHubUrl: v5.string(),
+      gaiaAppKey: v5.string()
+    })
+  )
+});
+var stxGetAccountsRequestMessageSchema = v5.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v5.object({
+    method: v5.literal(stxGetAccountsMethodName),
+    params: stxGetAccountsParamsSchema,
+    id: v5.string()
+  }).entries
+});
+
+// src/addresses/index.ts
+var import_jsontokens = require("jsontokens");
+
+// src/addresses/types.ts
+var v6 = __toESM(require("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 = v6.object({
+  address: v6.string(),
+  publicKey: v6.string(),
+  purpose: v6.enum(AddressPurpose),
+  addressType: v6.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 = (0, import_jsontokens.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/getAddresses.ts
+var v7 = __toESM(require("valibot"));
+var stxGetAddressesMethodName = "stx_getAddresses";
+var stxGetAddressesParamsSchema = v7.nullish(
+  v7.object({
+    /**
+     * A message to be displayed to the user in the request prompt.
+     */
+    message: v7.optional(v7.string())
+  })
+);
+var stxGetAddressesResultSchema = v7.object({
+  /**
+   * The addresses generated for the given purposes.
+   */
+  addresses: v7.array(addressSchema)
+});
+var stxGetAddressesRequestMessageSchema = v7.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v7.object({
+    method: v7.literal(stxGetAddressesMethodName),
+    params: stxGetAddressesParamsSchema,
+    id: v7.string()
+  }).entries
+});
+
+// src/request/types/stxMethods/signMessage.ts
+var v8 = __toESM(require("valibot"));
+var stxSignMessageMethodName = "stx_signMessage";
+var stxSignMessageParamsSchema = v8.object({
+  /**
+   * The message to sign.
+   */
+  message: v8.string(),
+  /**
+   * The public key to sign the message with.
+   */
+  publicKey: v8.string(),
+  /**
+   * The format version of the parameter.
+   */
+  parameterFormatVersion: v8.optional(v8.number())
+});
+var stxSignMessageResultSchema = v8.object({
+  /**
+   * The signature of the message.
+   */
+  signature: v8.string(),
+  /**
+   * The public key used to sign the message.
+   */
+  publicKey: v8.string()
+});
+var stxSignMessageRequestMessageSchema = v8.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v8.object({
+    method: v8.literal(stxSignMessageMethodName),
+    params: stxSignMessageParamsSchema,
+    id: v8.string()
+  }).entries
+});
+
+// src/request/types/stxMethods/signStructuredMessage.ts
+var v9 = __toESM(require("valibot"));
+var stxSignStructuredMessageMethodName = "stx_signStructuredMessage";
+var stxSignStructuredMessageParamsSchema = v9.object({
+  /**
+   * The domain to be signed.
+   */
+  domain: v9.string(),
+  /**
+   * Message payload to be signed.
+   */
+  message: v9.string(),
+  /**
+   * The format version of the parameter.
+   */
+  parameterFormatVersion: v9.optional(v9.number()),
+  /**
+   * The public key to sign the message with.
+   */
+  publicKey: v9.optional(v9.string())
+});
+var stxSignStructuredMessageResultSchema = v9.object({
+  /**
+   * Signature of the message.
+   */
+  signature: v9.string(),
+  /**
+   * Public key as hex-encoded string.
+   */
+  publicKey: v9.string()
+});
+var stxSignStructuredMessageRequestMessageSchema = v9.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v9.object({
+    method: v9.literal(stxSignStructuredMessageMethodName),
+    params: stxSignStructuredMessageParamsSchema,
+    id: v9.string()
+  }).entries
+});
+
+// src/request/types/stxMethods/signTransaction.ts
+var v10 = __toESM(require("valibot"));
+var stxSignTransactionMethodName = "stx_signTransaction";
+var stxSignTransactionParamsSchema = v10.object({
+  /**
+   * The transaction to sign as a hex-encoded string.
+   */
+  transaction: v10.string(),
+  /**
+   * The public key to sign the transaction with. The wallet may use any key
+   * when not provided.
+   */
+  pubkey: v10.optional(v10.string()),
+  /**
+   * Whether to broadcast the transaction after signing. Defaults to `true`.
+   */
+  broadcast: v10.optional(v10.boolean())
+});
+var stxSignTransactionResultSchema = v10.object({
+  /**
+   * The signed transaction as a hex-encoded string.
+   */
+  transaction: v10.string()
+});
+var stxSignTransactionRequestMessageSchema = v10.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v10.object({
+    method: v10.literal(stxSignTransactionMethodName),
+    params: stxSignTransactionParamsSchema,
+    id: v10.string()
+  }).entries
+});
+
+// src/request/types/stxMethods/transferStx.ts
+var v11 = __toESM(require("valibot"));
+var stxTransferStxMethodName = "stx_transferStx";
+var stxTransferStxParamsSchema = v11.object({
+  /**
+   * Amount of STX tokens to transfer in microstacks as a string. Anything
+   * parseable by `BigInt` is acceptable.
+   *
+   * Example,
+   *
+   * ```js
+   * const amount1 = 1234;
+   * const amount2 = 1234n;
+   * const amount3 = '1234';
+   * ```
+   */
+  amount: v11.union([v11.number(), v11.string()]),
+  /**
+   * The recipeint's principal.
+   */
+  recipient: v11.string(),
+  /**
+   * A string representing the memo.
+   */
+  memo: v11.optional(v11.string()),
+  /**
+   * Version of parameter format.
+   */
+  version: v11.optional(v11.string()),
+  /**
+   * The mode of the post conditions.
+   */
+  postConditionMode: v11.optional(v11.number()),
+  /**
+   * A hex-encoded string representing the post conditions.
+   *
+   * A post condition may be converted to it's hex representation using the `serializePostCondition` helper from the `@stacks/transactions` package,
+   *
+   * ```js
+   * import { serializePostCondition } from '@stacks/transactions';
+   *
+   * const postCondition = somePostCondition;
+   * const hexPostCondition = serializePostCondition(postCondition).toString('hex');
+   * ```
+   */
+  postConditions: v11.optional(v11.array(v11.string())),
+  /**
+   * The public key to sign the transaction with. The wallet may use any key
+   * when not provided.
+   */
+  pubkey: v11.optional(v11.string())
+});
+var stxTransferStxResultSchema = v11.object({
+  /**
+   * The ID of the transaction.
+   */
+  txid: v11.string(),
+  /**
+   * A Stacks transaction as a hex-encoded string.
+   */
+  transaction: v11.string()
+});
+var stxTransferStxRequestMessageSchema = v11.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v11.object({
+    method: v11.literal(stxTransferStxMethodName),
+    params: stxTransferStxParamsSchema,
+    id: v11.string()
+  }).entries
+});
+
+// src/request/types/btcMethods.ts
+var v13 = __toESM(require("valibot"));
+
+// src/request/types/common.ts
+var v12 = __toESM(require("valibot"));
+var walletTypes = ["software", "ledger"];
+var walletTypeSchema = v12.picklist(walletTypes);
+
+// src/request/types/btcMethods.ts
+var getInfoMethodName = "getInfo";
+var getInfoParamsSchema = v13.nullish(v13.null());
+var getInfoResultSchema = v13.object({
+  /**
+   * Version of the wallet.
+   */
+  version: v13.string(),
+  /**
+   * [WBIP](https://wbips.netlify.app/wbips/WBIP002) methods supported by the wallet.
+   */
+  methods: v13.optional(v13.array(v13.string())),
+  /**
+   * List of WBIP standards supported by the wallet. Not currently used.
+   */
+  supports: v13.array(v13.string())
+});
+var getInfoRequestMessageSchema = v13.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v13.object({
+    method: v13.literal(getInfoMethodName),
+    params: getInfoParamsSchema,
+    id: v13.string()
+  }).entries
+});
+var getAddressesMethodName = "getAddresses";
+var getAddressesParamsSchema = v13.object({
+  /**
+   * The purposes for which to generate addresses. See
+   * {@linkcode AddressPurpose} for available purposes.
+   */
+  purposes: v13.array(v13.enum(AddressPurpose)),
+  /**
+   * A message to be displayed to the user in the request prompt.
+   */
+  message: v13.optional(v13.string())
+});
+var getAddressesResultSchema = v13.object({
+  /**
+   * The addresses generated for the given purposes.
+   */
+  addresses: v13.array(addressSchema)
+});
+var getAddressesRequestMessageSchema = v13.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v13.object({
+    method: v13.literal(getAddressesMethodName),
+    params: getAddressesParamsSchema,
+    id: v13.string()
+  }).entries
+});
+var signMessageMethodName = "signMessage";
+var MessageSigningProtocols = /* @__PURE__ */ ((MessageSigningProtocols2) => {
+  MessageSigningProtocols2["ECDSA"] = "ECDSA";
+  MessageSigningProtocols2["BIP322"] = "BIP322";
+  return MessageSigningProtocols2;
+})(MessageSigningProtocols || {});
+var signMessageParamsSchema = v13.object({
+  /**
+   * The address used for signing.
+   **/
+  address: v13.string(),
+  /**
+   * The message to sign.
+   **/
+  message: v13.string(),
+  /**
+   * The protocol to use for signing the message.
+   */
+  protocol: v13.optional(v13.enum(MessageSigningProtocols))
+});
+var signMessageResultSchema = v13.object({
+  /**
+   * The signature of the message.
+   */
+  signature: v13.string(),
+  /**
+   * hash of the message.
+   */
+  messageHash: v13.string(),
+  /**
+   * The address used for signing.
+   */
+  address: v13.string(),
+  /**
+   * The protocol to use for signing the message.
+   */
+  protocol: v13.enum(MessageSigningProtocols)
+});
+var signMessageRequestMessageSchema = v13.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v13.object({
+    method: v13.literal(signMessageMethodName),
+    params: signMessageParamsSchema,
+    id: v13.string()
+  }).entries
+});
+var sendTransferMethodName = "sendTransfer";
+var sendTransferParamsSchema = v13.object({
+  /**
+   * Array of recipients to send to.
+   * The amount to send to each recipient is in satoshis.
+   */
+  recipients: v13.array(
+    v13.object({
+      address: v13.string(),
+      amount: v13.number()
+    })
+  )
+});
+var sendTransferResultSchema = v13.object({
+  /**
+   * The transaction id as a hex-encoded string.
+   */
+  txid: v13.string()
+});
+var sendTransferRequestMessageSchema = v13.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v13.object({
+    method: v13.literal(sendTransferMethodName),
+    params: sendTransferParamsSchema,
+    id: v13.string()
+  }).entries
+});
+var signPsbtMethodName = "signPsbt";
+var signPsbtParamsSchema = v13.object({
+  /**
+   * The base64 encoded PSBT to sign.
+   */
+  psbt: v13.string(),
+  /**
+   * The inputs to sign.
+   * The key is the address and the value is an array of indexes of the inputs to sign.
+   */
+  signInputs: v13.record(v13.string(), v13.array(v13.number())),
+  /**
+   * Whether to broadcast the transaction after signing.
+   **/
+  broadcast: v13.optional(v13.boolean())
+});
+var signPsbtResultSchema = v13.object({
+  /**
+   * The base64 encoded PSBT after signing.
+   */
+  psbt: v13.string(),
+  /**
+   * The transaction id as a hex-encoded string.
+   * This is only returned if the transaction was broadcast.
+   **/
+  txid: v13.optional(v13.string())
+});
+var signPsbtRequestMessageSchema = v13.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v13.object({
+    method: v13.literal(signPsbtMethodName),
+    params: signPsbtParamsSchema,
+    id: v13.string()
+  }).entries
+});
+var getAccountsMethodName = "getAccounts";
+var getAccountsParamsSchema = v13.object({
+  /**
+   * The purposes for which to generate addresses. See
+   * {@linkcode AddressPurpose} for available purposes.
+   */
+  purposes: v13.array(v13.enum(AddressPurpose)),
+  /**
+   * A message to be displayed to the user in the request prompt.
+   */
+  message: v13.optional(v13.string())
+});
+var getAccountsResultSchema = v13.array(
+  v13.object({
+    ...addressSchema.entries,
+    ...v13.object({
+      walletType: walletTypeSchema
+    }).entries
+  })
+);
+var getAccountsRequestMessageSchema = v13.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v13.object({
+    method: v13.literal(getAccountsMethodName),
+    params: getAccountsParamsSchema,
+    id: v13.string()
+  }).entries
+});
+var getBalanceMethodName = "getBalance";
+var getBalanceParamsSchema = v13.nullish(v13.null());
+var getBalanceResultSchema = v13.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: v13.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: v13.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: v13.string()
+});
+var getBalanceRequestMessageSchema = v13.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v13.object({
+    method: v13.literal(getBalanceMethodName),
+    id: v13.string()
+  }).entries
+});
+
+// src/request/types/walletMethods.ts
+var v19 = __toESM(require("valibot"));
+
+// node_modules/@noble/hashes/esm/_assert.js
+function isBytes(a) {
+  return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
+}
+function bytes(b, ...lengths) {
+  if (!isBytes(b))
+    throw new Error("Uint8Array expected");
+  if (lengths.length > 0 && !lengths.includes(b.length))
+    throw new Error(`Uint8Array expected of length ${lengths}, not of length=${b.length}`);
+}
+function exists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function output(out, instance) {
+  bytes(out);
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error(`digestInto() expects output buffer of length at least ${min}`);
+  }
+}
+
+// node_modules/@noble/hashes/esm/utils.js
+var createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+var rotr = (word, shift) => word << 32 - shift | word >>> shift;
+var isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+var hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+function bytesToHex(bytes2) {
+  bytes(bytes2);
+  let hex = "";
+  for (let i = 0; i < bytes2.length; i++) {
+    hex += hexes[bytes2[i]];
+  }
+  return hex;
+}
+function utf8ToBytes(str) {
+  if (typeof str !== "string")
+    throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
+  return new Uint8Array(new TextEncoder().encode(str));
+}
+function toBytes(data) {
+  if (typeof data === "string")
+    data = utf8ToBytes(data);
+  bytes(data);
+  return data;
+}
+var Hash = class {
+  // Safe version that clones internal state
+  clone() {
+    return this._cloneInto();
+  }
+};
+var toStr = {}.toString;
+function wrapConstructor(hashCons) {
+  const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+  const tmp = hashCons();
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = () => hashCons();
+  return hashC;
+}
+
+// node_modules/@noble/hashes/esm/_md.js
+function setBigUint64(view, byteOffset, value, isLE2) {
+  if (typeof view.setBigUint64 === "function")
+    return view.setBigUint64(byteOffset, value, isLE2);
+  const _32n = BigInt(32);
+  const _u32_max = BigInt(4294967295);
+  const wh = Number(value >> _32n & _u32_max);
+  const wl = Number(value & _u32_max);
+  const h = isLE2 ? 4 : 0;
+  const l = isLE2 ? 0 : 4;
+  view.setUint32(byteOffset + h, wh, isLE2);
+  view.setUint32(byteOffset + l, wl, isLE2);
+}
+var Chi = (a, b, c) => a & b ^ ~a & c;
+var Maj = (a, b, c) => a & b ^ a & c ^ b & c;
+var HashMD = class extends Hash {
+  constructor(blockLen, outputLen, padOffset, isLE2) {
+    super();
+    this.blockLen = blockLen;
+    this.outputLen = outputLen;
+    this.padOffset = padOffset;
+    this.isLE = isLE2;
+    this.finished = false;
+    this.length = 0;
+    this.pos = 0;
+    this.destroyed = false;
+    this.buffer = new Uint8Array(blockLen);
+    this.view = createView(this.buffer);
+  }
+  update(data) {
+    exists(this);
+    const { view, buffer, blockLen } = this;
+    data = toBytes(data);
+    const len = data.length;
+    for (let pos = 0; pos < len; ) {
+      const take = Math.min(blockLen - this.pos, len - pos);
+      if (take === blockLen) {
+        const dataView = createView(data);
+        for (; blockLen <= len - pos; pos += blockLen)
+          this.process(dataView, pos);
+        continue;
+      }
+      buffer.set(data.subarray(pos, pos + take), this.pos);
+      this.pos += take;
+      pos += take;
+      if (this.pos === blockLen) {
+        this.process(view, 0);
+        this.pos = 0;
+      }
+    }
+    this.length += data.length;
+    this.roundClean();
+    return this;
+  }
+  digestInto(out) {
+    exists(this);
+    output(out, this);
+    this.finished = true;
+    const { buffer, view, blockLen, isLE: isLE2 } = this;
+    let { pos } = this;
+    buffer[pos++] = 128;
+    this.buffer.subarray(pos).fill(0);
+    if (this.padOffset > blockLen - pos) {
+      this.process(view, 0);
+      pos = 0;
+    }
+    for (let i = pos; i < blockLen; i++)
+      buffer[i] = 0;
+    setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE2);
+    this.process(view, 0);
+    const oview = createView(out);
+    const len = this.outputLen;
+    if (len % 4)
+      throw new Error("_sha2: outputLen should be aligned to 32bit");
+    const outLen = len / 4;
+    const state = this.get();
+    if (outLen > state.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let i = 0; i < outLen; i++)
+      oview.setUint32(4 * i, state[i], isLE2);
+  }
+  digest() {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
+  }
+  _cloneInto(to) {
+    to || (to = new this.constructor());
+    to.set(...this.get());
+    const { blockLen, buffer, length, finished, destroyed, pos } = this;
+    to.length = length;
+    to.pos = pos;
+    to.finished = finished;
+    to.destroyed = destroyed;
+    if (length % blockLen)
+      to.buffer.set(buffer);
+    return to;
+  }
+};
+
+// node_modules/@noble/hashes/esm/sha256.js
+var SHA256_K = /* @__PURE__ */ new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var SHA256_IV = /* @__PURE__ */ new Uint32Array([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+var SHA256_W = /* @__PURE__ */ new Uint32Array(64);
+var SHA256 = class extends HashMD {
+  constructor() {
+    super(64, 32, 8, false);
+    this.A = SHA256_IV[0] | 0;
+    this.B = SHA256_IV[1] | 0;
+    this.C = SHA256_IV[2] | 0;
+    this.D = SHA256_IV[3] | 0;
+    this.E = SHA256_IV[4] | 0;
+    this.F = SHA256_IV[5] | 0;
+    this.G = SHA256_IV[6] | 0;
+    this.H = SHA256_IV[7] | 0;
+  }
+  get() {
+    const { A, B, C, D, E, F, G, H } = this;
+    return [A, B, C, D, E, F, G, H];
+  }
+  // prettier-ignore
+  set(A, B, C, D, E, F, G, H) {
+    this.A = A | 0;
+    this.B = B | 0;
+    this.C = C | 0;
+    this.D = D | 0;
+    this.E = E | 0;
+    this.F = F | 0;
+    this.G = G | 0;
+    this.H = H | 0;
+  }
+  process(view, offset) {
+    for (let i = 0; i < 16; i++, offset += 4)
+      SHA256_W[i] = view.getUint32(offset, false);
+    for (let i = 16; i < 64; i++) {
+      const W15 = SHA256_W[i - 15];
+      const W2 = SHA256_W[i - 2];
+      const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
+      const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
+      SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
+    }
+    let { A, B, C, D, E, F, G, H } = this;
+    for (let i = 0; i < 64; i++) {
+      const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
+      const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
+      const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
+      const T2 = sigma0 + Maj(A, B, C) | 0;
+      H = G;
+      G = F;
+      F = E;
+      E = D + T1 | 0;
+      D = C;
+      C = B;
+      B = A;
+      A = T1 + T2 | 0;
+    }
+    A = A + this.A | 0;
+    B = B + this.B | 0;
+    C = C + this.C | 0;
+    D = D + this.D | 0;
+    E = E + this.E | 0;
+    F = F + this.F | 0;
+    G = G + this.G | 0;
+    H = H + this.H | 0;
+    this.set(A, B, C, D, E, F, G, H);
+  }
+  roundClean() {
+    SHA256_W.fill(0);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0);
+    this.buffer.fill(0);
+  }
+};
+var sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256());
+
+// src/request/types/permissions/resources/account.ts
+var v16 = __toESM(require("valibot"));
+
+// src/request/types/permissions/resources/common.ts
+var v14 = __toESM(require("valibot"));
+var actionDescriptionSchema = v14.object({
+  name: v14.string(),
+  description: v14.variant("type", [
+    v14.object({ type: v14.literal("single"), value: v14.string() }),
+    v14.object({ type: v14.literal("multiple"), values: v14.array(v14.string()) })
+  ])
+});
+
+// src/request/types/permissions/utils/account-id.ts
+var v15 = __toESM(require("valibot"));
+var accountIdBrandName = "AccountId";
+var accountIdSchema = v15.pipe(v15.string(), v15.brand(accountIdBrandName));
+function makeAccountId(options) {
+  return v15.parse(
+    accountIdSchema,
+    bytesToHex(
+      sha256(
+        `account-${options.masterPubKey}-${// NOTE: This "account ID" is actually the ~account~ address index from BIP-44.
+        options.accountId}-${options.networkType}`
+      )
+    )
+  );
+}
+
+// src/request/types/permissions/resources/account.ts
+var accountResourceIdBrandName = "AccountResourceId";
+var sha256HexStringRegex = /^[\da-f]{64}$/;
+var accountResourceIdSchema = v16.pipe(
+  v16.string(),
+  v16.check((input) => sha256HexStringRegex.test(input)),
+  v16.brand("AccountResourceId")
+);
+function makeAccountResourceId(accountId) {
+  return v16.parse(accountResourceIdSchema, bytesToHex(sha256(`account-resource-${accountId}`)));
+}
+var accountResourceSchema = v16.object({
+  type: v16.literal("account"),
+  id: accountResourceIdSchema,
+  accountId: accountIdSchema,
+  name: v16.string()
+});
+function makeAccountResource(args) {
+  return {
+    type: "account",
+    id: makeAccountResourceId(args.accountId),
+    accountId: args.accountId,
+    name: `Account ${args.accountId}, ${args.masterPubKey.slice(0, 6)}...(${args.networkType})`
+  };
+}
+var accountActionsSchema = v16.object({
+  read: v16.optional(v16.boolean()),
+  autoSign: v16.optional(v16.boolean()),
+  rename: v16.optional(v16.boolean())
+});
+var accountActionsDescriptionSchema = v16.record(
+  v16.keyof(accountActionsSchema),
+  actionDescriptionSchema
+);
+var accountPermissionSchema = v16.object({
+  type: v16.literal("account"),
+  resourceId: accountResourceIdSchema,
+  clientId: v16.string(),
+  actions: accountActionsSchema
+});
+
+// src/request/types/permissions/resources/wallet.ts
+var v17 = __toESM(require("valibot"));
+var walletResourceSchema = v17.object({
+  type: v17.literal("wallet"),
+  id: v17.literal("wallet"),
+  name: v17.literal("Wallet")
+});
+var walletActionsSchema = v17.object({
+  addPrivateKey: v17.optional(v17.boolean()),
+  openPopup: v17.optional(v17.boolean()),
+  openFullPage: v17.optional(v17.boolean()),
+  readAllAccounts: v17.optional(v17.boolean())
+});
+var walletActionsDescriptionSchema = v17.record(
+  v17.keyof(walletActionsSchema),
+  actionDescriptionSchema
+);
+var walletIdSchema = v17.literal("wallet");
+var walletPermissionSchema = v17.object({
+  type: v17.literal("wallet"),
+  resourceId: walletIdSchema,
+  clientId: v17.string(),
+  actions: walletActionsSchema
+});
+
+// src/request/types/permissions/resources/index.ts
+var account = {
+  accountResourceIdBrandName,
+  accountResourceIdSchema,
+  accountResourceSchema,
+  accountActionsSchema,
+  accountActionsDescriptionSchema,
+  accountPermissionSchema,
+  makeAccountResourceId,
+  makeAccountResource
+};
+var common = {
+  actionDescriptionSchema
+};
+var wallet = {
+  walletResourceSchema,
+  walletActionsSchema,
+  walletIdSchema,
+  walletPermissionSchema,
+  walletActionsDescriptionSchema
+};
+
+// src/request/types/permissions/utils/index.ts
+var account2 = {
+  makeAccountId,
+  accountIdBrandName,
+  accountIdSchema
+};
+
+// src/request/types/permissions/store.ts
+var v18 = __toESM(require("valibot"));
+var clientId = v18.pipe(v18.string(), v18.url(), v18.brand("ClientId"));
+var client = v18.object({
+  id: clientId,
+  origin: v18.string(),
+  name: v18.optional(v18.string()),
+  description: v18.optional(v18.string())
+});
+var clientsTable = v18.array(client);
+var clientMetadata = v18.object({
+  clientId: client.entries.id,
+  lastUsed: v18.optional(v18.number())
+});
+var clientMetadataTable = v18.array(clientMetadata);
+var resource = v18.variant("type", [accountResourceSchema, walletResourceSchema]);
+var resourcesTable = v18.array(resource);
+var permission = v18.variant("type", [accountPermissionSchema, walletPermissionSchema]);
+var permissionsTable = v18.array(permission);
+var permissionsStore = v18.object({
+  version: v18.literal(4),
+  clients: clientsTable,
+  clientMetadata: clientMetadataTable,
+  resources: resourcesTable,
+  permissions: permissionsTable
+});
+
+// src/request/types/permissions/index.ts
+var resources = {
+  account,
+  common,
+  wallet
+};
+var utils = {
+  account: account2
+};
+var store = {
+  clientId,
+  client,
+  clientMetadata,
+  clientMetadataTable,
+  clientsTable,
+  resource,
+  resourcesTable,
+  permission,
+  permissionsTable,
+  permissionsStore
+};
+var permissions = {
+  resources,
+  utils,
+  store
+};
+
+// src/request/types/walletMethods.ts
+var permissionTemplate = v19.variant("type", [
+  v19.object({
+    ...v19.omit(permissions.resources.account.accountPermissionSchema, ["clientId"]).entries
+  }),
+  v19.object({
+    ...v19.omit(permissions.resources.wallet.walletPermissionSchema, ["clientId"]).entries
+  })
+]);
+var requestPermissionsMethodName = "wallet_requestPermissions";
+var requestPermissionsParamsSchema = v19.nullish(v19.array(permissionTemplate));
+var requestPermissionsResultSchema = v19.literal(true);
+var requestPermissionsRequestMessageSchema = v19.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v19.object({
+    method: v19.literal(requestPermissionsMethodName),
+    params: requestPermissionsParamsSchema,
+    id: v19.string()
+  }).entries
+});
+var renouncePermissionsMethodName = "wallet_renouncePermissions";
+var renouncePermissionsParamsSchema = v19.nullish(v19.null());
+var renouncePermissionsResultSchema = v19.nullish(v19.null());
+var renouncePermissionsRequestMessageSchema = v19.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v19.object({
+    method: v19.literal(renouncePermissionsMethodName),
+    params: renouncePermissionsParamsSchema,
+    id: v19.string()
+  }).entries
+});
+var disconnectMethodName = "wallet_disconnect";
+var disconnectParamsSchema = v19.nullish(v19.null());
+var disconnectResultSchema = v19.nullish(v19.null());
+var disconnectRequestMessageSchema = v19.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v19.object({
+    method: v19.literal(disconnectMethodName),
+    params: disconnectParamsSchema,
+    id: v19.string()
+  }).entries
+});
+var getWalletTypeMethodName = "wallet_getWalletType";
+var getWalletTypeParamsSchema = v19.nullish(v19.null());
+var getWalletTypeResultSchema = walletTypeSchema;
+var getWalletTypeRequestMessageSchema = v19.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v19.object({
+    method: v19.literal(getWalletTypeMethodName),
+    params: getWalletTypeParamsSchema,
+    id: v19.string()
+  }).entries
+});
+var getCurrentPermissionsMethodName = "wallet_getCurrentPermissions";
+var getCurrentPermissionsParamsSchema = v19.nullish(v19.null());
+var getCurrentPermissionsResultSchema = v19.array(permissions.store.permission);
+var getCurrentPermissionsRequestMessageSchema = v19.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v19.object({
+    method: v19.literal(getCurrentPermissionsMethodName),
+    params: getCurrentPermissionsParamsSchema,
+    id: v19.string()
+  }).entries
+});
+var getAccountMethodName = "wallet_getAccount";
+var getAccountParamsSchema = v19.nullish(v19.null());
+var getAccountResultSchema = v19.object({
+  id: permissions.utils.account.accountIdSchema,
+  addresses: v19.array(addressSchema),
+  walletType: walletTypeSchema
+});
+var getAccountRequestMessageSchema = v19.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v19.object({
+    method: v19.literal(getAccountMethodName),
+    params: getAccountParamsSchema,
+    id: v19.string()
+  }).entries
+});
+var connectMethodName = "wallet_connect";
+var connectParamsSchema = v19.nullish(
+  v19.object({
+    permissions: v19.optional(v19.array(permissionTemplate)),
+    addresses: v19.optional(v19.array(v19.enum(AddressPurpose))),
+    message: v19.optional(
+      v19.pipe(v19.string(), v19.maxLength(80, "The message must not exceed 80 characters."))
+    )
+  })
+);
+var connectResultSchema = getAccountResultSchema;
+var connectRequestMessageSchema = v19.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v19.object({
+    method: v19.literal(connectMethodName),
+    params: connectParamsSchema,
+    id: v19.string()
+  }).entries
+});
+
+// src/request/types/runesMethods/etch.ts
+var v20 = __toESM(require("valibot"));
+var runesEtchMethodName = "runes_etch";
+var etchTermsSchema = v20.object({
+  amount: v20.string(),
+  cap: v20.string(),
+  heightStart: v20.optional(v20.string()),
+  heightEnd: v20.optional(v20.string()),
+  offsetStart: v20.optional(v20.string()),
+  offsetEnd: v20.optional(v20.string())
+});
+var inscriptionDetailsSchema = v20.object({
+  contentType: v20.string(),
+  contentBase64: v20.string()
+});
+var runesEtchParamsSchema = v20.object({
+  runeName: v20.string(),
+  divisibility: v20.optional(v20.number()),
+  symbol: v20.optional(v20.string()),
+  premine: v20.optional(v20.string()),
+  isMintable: v20.boolean(),
+  delegateInscriptionId: v20.optional(v20.string()),
+  destinationAddress: v20.string(),
+  refundAddress: v20.string(),
+  feeRate: v20.number(),
+  appServiceFee: v20.optional(v20.number()),
+  appServiceFeeAddress: v20.optional(v20.string()),
+  terms: v20.optional(etchTermsSchema),
+  inscriptionDetails: v20.optional(inscriptionDetailsSchema),
+  network: v20.optional(v20.enum(BitcoinNetworkType))
+});
+var runesEtchResultSchema = v20.object({
+  orderId: v20.string(),
+  fundTransactionId: v20.string(),
+  fundingAddress: v20.string()
+});
+var runesEtchRequestMessageSchema = v20.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v20.object({
+    method: v20.literal(runesEtchMethodName),
+    params: runesEtchParamsSchema,
+    id: v20.string()
+  }).entries
+});
+
+// src/request/types/runesMethods/getBalance.ts
+var v21 = __toESM(require("valibot"));
+var runesGetBalanceMethodName = "runes_getBalance";
+var runesGetBalanceParamsSchema = v21.nullish(v21.null());
+var runesGetBalanceResultSchema = v21.object({
+  balances: v21.array(
+    v21.object({
+      runeName: v21.string(),
+      amount: v21.string(),
+      divisibility: v21.number(),
+      symbol: v21.string(),
+      inscriptionId: v21.nullish(v21.string())
+    })
+  )
+});
+var runesGetBalanceRequestMessageSchema = v21.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v21.object({
+    method: v21.literal(runesGetBalanceMethodName),
+    params: runesGetBalanceParamsSchema,
+    id: v21.string()
+  }).entries
+});
+
+// src/request/types/runesMethods/mint.ts
+var v22 = __toESM(require("valibot"));
+var runesMintMethodName = "runes_mint";
+var runesMintParamsSchema = v22.object({
+  appServiceFee: v22.optional(v22.number()),
+  appServiceFeeAddress: v22.optional(v22.string()),
+  destinationAddress: v22.string(),
+  feeRate: v22.number(),
+  refundAddress: v22.string(),
+  repeats: v22.number(),
+  runeName: v22.string(),
+  network: v22.optional(v22.enum(BitcoinNetworkType))
+});
+var runesMintResultSchema = v22.object({
+  orderId: v22.string(),
+  fundTransactionId: v22.string(),
+  fundingAddress: v22.string()
+});
+var runesMintRequestMessageSchema = v22.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v22.object({
+    method: v22.literal(runesMintMethodName),
+    params: runesMintParamsSchema,
+    id: v22.string()
+  }).entries
+});
+
+// src/request/types/runesMethods/transfer.ts
+var v23 = __toESM(require("valibot"));
+var runesTransferMethodName = "runes_transfer";
+var runesTransferParamsSchema = v23.object({
+  recipients: v23.array(
+    v23.object({
+      runeName: v23.string(),
+      amount: v23.string(),
+      address: v23.string()
+    })
+  )
+});
+var runesTransferResultSchema = v23.object({
+  txid: v23.string()
+});
+var runesTransferRequestMessageSchema = v23.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v23.object({
+    method: v23.literal(runesTransferMethodName),
+    params: runesTransferParamsSchema,
+    id: v23.string()
+  }).entries
+});
+
+// src/request/types/ordinalsMethods.ts
+var v24 = __toESM(require("valibot"));
+var getInscriptionsMethodName = "ord_getInscriptions";
+var getInscriptionsParamsSchema = v24.object({
+  offset: v24.number(),
+  limit: v24.number()
+});
+var getInscriptionsResultSchema = v24.object({
+  total: v24.number(),
+  limit: v24.number(),
+  offset: v24.number(),
+  inscriptions: v24.array(
+    v24.object({
+      inscriptionId: v24.string(),
+      inscriptionNumber: v24.string(),
+      address: v24.string(),
+      collectionName: v24.optional(v24.string()),
+      postage: v24.string(),
+      contentLength: v24.string(),
+      contentType: v24.string(),
+      timestamp: v24.number(),
+      offset: v24.number(),
+      genesisTransaction: v24.string(),
+      output: v24.string()
+    })
+  )
+});
+var getInscriptionsRequestMessageSchema = v24.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v24.object({
+    method: v24.literal(getInscriptionsMethodName),
+    params: getInscriptionsParamsSchema,
+    id: v24.string()
+  }).entries
+});
+var sendInscriptionsMethodName = "ord_sendInscriptions";
+var sendInscriptionsParamsSchema = v24.object({
+  transfers: v24.array(
+    v24.object({
+      address: v24.string(),
+      inscriptionId: v24.string()
+    })
+  )
+});
+var sendInscriptionsResultSchema = v24.object({
+  txid: v24.string()
+});
+var sendInscriptionsRequestMessageSchema = v24.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v24.object({
+    method: v24.literal(sendInscriptionsMethodName),
+    params: sendInscriptionsParamsSchema,
+    id: v24.string()
+  }).entries
+});
+
+// src/request/index.ts
+var request = async (method, params, providerId) => {
+  let provider = window.XverseProviders?.BitcoinProvider || window.BitcoinProvider;
+  if (providerId) {
+    provider = await getProviderById(providerId);
+  }
+  if (!provider) {
+    throw new Error("no wallet provider was found");
+  }
+  if (!method) {
+    throw new Error("A wallet method is required");
+  }
+  const response = await provider.request(method, params);
+  if (v25.is(rpcErrorResponseMessageSchema, response)) {
+    return {
+      status: "error",
+      error: response.error
+    };
+  }
+  if (v25.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");
+  }
+  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(event, cb);
+};
+
+// src/runes/api.ts
+var import_axios = __toESM(require("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 = import_axios.default.create({
+      baseURL: ORDINALS_API_BASE_URL(network)
+    });
+  }
+  parseError = (error) => {
+    return {
+      code: error.response?.status,
+      message: JSON.stringify(error.response?.data)
+    };
+  };
+  estimateMintCost = async (mintParams) => {
+    try {
+      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/adapters/xverse.ts
+var XverseAdapter = class extends SatsConnectAdapter {
+  id = DefaultAdaptersInfo.xverse.id;
+  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
+var import_bitcoin_address_validation = require("bitcoin-address-validation");
+var import_buffer = require("buffer");
+function convertSignInputsToInputType(signInputs) {
+  let result = [];
+  for (let address in signInputs) {
+    let indexes = signInputs[address];
+    for (let index of indexes) {
+      result.push({
+        index,
+        address
+      });
+    }
+  }
+  return result;
+}
+var UnisatAdapter = class extends SatsConnectAdapter {
+  id = DefaultAdaptersInfo.unisat.id;
+  async getAccounts(params) {
+    const { purposes } = params;
+    if (purposes.includes("stacks" /* Stacks */)) {
+      throw new Error("Only bitcoin addresses are supported");
+    }
+    const accounts = await window.unisat.requestAccounts();
+    const publicKey = await window.unisat.getPublicKey();
+    const address = accounts[0];
+    const addressType = (0, import_bitcoin_address_validation.getAddressInfo)(accounts[0]).type;
+    const pk = addressType === import_bitcoin_address_validation.AddressType.p2tr ? publicKey.slice(2) : publicKey;
+    const paymentAddress = {
+      address,
+      publicKey: pk,
+      addressType,
+      purpose: "payment" /* Payment */
+    };
+    const ordinalsAddress = {
+      address,
+      publicKey: pk,
+      addressType,
+      purpose: "ordinals" /* Ordinals */
+    };
+    const response = [];
+    if (purposes.includes("payment" /* Payment */)) {
+      response.push({ ...paymentAddress, walletType: "software" });
+    }
+    if (purposes.includes("ordinals" /* Ordinals */)) {
+      response.push({ ...ordinalsAddress, walletType: "software" });
+    }
+    return response;
+  }
+  async signMessage(params) {
+    const { message, address } = params;
+    const addressType = (0, import_bitcoin_address_validation.getAddressInfo)(address).type;
+    const Bip322supportedTypes = [import_bitcoin_address_validation.AddressType.p2wpkh, import_bitcoin_address_validation.AddressType.p2tr];
+    if (Bip322supportedTypes.includes(addressType)) {
+      const response2 = await window.unisat.signMessage(message, "bip322-simple");
+      return {
+        address,
+        messageHash: "",
+        signature: response2,
+        protocol: "BIP322" /* BIP322 */
+      };
+    }
+    const response = await window.unisat.signMessage(message, "ecdsa");
+    return {
+      address,
+      messageHash: "",
+      signature: response,
+      protocol: "ECDSA" /* ECDSA */
+    };
+  }
+  async sendTransfer(params) {
+    const { recipients } = params;
+    if (recipients.length > 1) {
+      throw new Error("Only one recipient is supported by this wallet provider");
+    }
+    const txid = await window.unisat.sendBitcoin(recipients[0].address, recipients[0].amount);
+    return {
+      txid
+    };
+  }
+  async signPsbt(params) {
+    const { psbt, signInputs, broadcast } = params;
+    const psbtHex = import_buffer.Buffer.from(psbt, "base64").toString("hex");
+    const signedPsbt = await window.unisat.signPsbt(psbtHex, {
+      autoFinalized: broadcast,
+      toSignInputs: convertSignInputsToInputType(signInputs)
+    });
+    if (broadcast) {
+      const txid = await window.unisat.pushPsbt(psbtHex);
+      return {
+        psbt: signedPsbt,
+        txid
+      };
+    }
+    return {
+      psbt: psbtHex
+    };
+  }
+  requestInternal = async (method, params) => {
+    try {
+      switch (method) {
+        case "getAccounts": {
+          const response = await this.getAccounts(
+            params
+          );
+          return {
+            status: "success",
+            result: response
+          };
+        }
+        case "sendTransfer": {
+          const response = await this.sendTransfer(params);
+          return {
+            status: "success",
+            result: response
+          };
+        }
+        case "signMessage": {
+          const response = await this.signMessage(params);
+          return {
+            status: "success",
+            result: response
+          };
+        }
+        case "signPsbt": {
+          const response = await this.signPsbt(params);
+          return {
+            status: "success",
+            result: response
+          };
+        }
+        default: {
+          const error = {
+            code: -32001 /* METHOD_NOT_SUPPORTED */,
+            message: "Method not supported by the selected wallet"
+          };
+          console.error("Error calling the method", error);
+          return {
+            status: "error",
+            error
+          };
+        }
+      }
+    } catch (error) {
+      console.error("Error calling the method", error);
+      return {
+        status: "error",
+        error: {
+          code: error.code === 4001 ? -32e3 /* USER_REJECTION */ : -32603 /* INTERNAL_ERROR */,
+          message: error.message ? error.message : "Wallet method call error",
+          data: error
+        }
+      };
+    }
+  };
+  addListener = (eventName, cb) => {
+    switch (eventName) {
+      case "accountChange": {
+        const handler = () => {
+          cb({ type: "accountChange" });
+        };
+        window.unisat.on("accountsChanged", handler);
+        return () => {
+          window.unisat.removeListener("accountsChanged", handler);
+        };
+      }
+      case "networkChange": {
+        const handler = () => {
+          cb({ type: "networkChange" });
+        };
+        window.unisat.on("networkChanged", handler);
+        return () => {
+          window.unisat.removeListener("networkChanged", handler);
+        };
+      }
+      default: {
+        console.error("Event not supported by the selected wallet");
+        return () => {
+        };
+      }
+    }
+  };
+};
+
+// src/adapters/BaseAdapter.ts
+var BaseAdapter = class extends SatsConnectAdapter {
+  id = "";
+  constructor(providerId) {
+    super();
+    this.id = providerId;
+  }
+  requestInternal = async (method, params) => {
+    return request(method, params, this.id);
+  };
+  addListener = (..._args) => {
+    throw new Error("Method not supported for `BaseAdapter`.");
+  };
+};
+
+// src/adapters/index.ts
+var DefaultAdaptersInfo = {
+  xverse: {
+    id: "XverseProviders.BitcoinProvider",
+    name: "Xverse",
+    webUrl: "https://www.xverse.app/",
+    googlePlayStoreUrl: "https://play.google.com/store/apps/details?id=com.secretkeylabs.xverse",
+    iOSAppStoreUrl: "https://apps.apple.com/app/xverse-bitcoin-web3-wallet/id1552272513",
+    chromeWebStoreUrl: "https://chromewebstore.google.com/detail/xverse-wallet/idnnbdplmphpflfnlkomgpfbpcgelopg",
+    icon: "data:image/svg+xml;base64,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"
+  },
+  unisat: {
+    id: "unisat",
+    name: "Unisat",
+    webUrl: "https://unisat.io/",
+    icon: "data:image/svg+xml;base64,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"
+  }
+};
+var defaultAdapters = {
+  [DefaultAdaptersInfo.xverse.id]: XverseAdapter,
+  [DefaultAdaptersInfo.unisat.id]: UnisatAdapter
+};
+
+// src/capabilities/index.ts
+var import_jsontokens2 = require("jsontokens");
+var extractOrValidateCapabilities = (provider, reportedCapabilities) => {
+  const validateCapability = (capability) => {
+    if (!provider[capability]) {
+      return false;
+    }
+    if (reportedCapabilities && !reportedCapabilities.has(capability)) {
+      return false;
+    }
+    return true;
+  };
+  const capabilityMap = {
+    request: validateCapability("request"),
+    connect: validateCapability("connect"),
+    signMessage: validateCapability("signMessage"),
+    signTransaction: validateCapability("signTransaction"),
+    sendBtcTransaction: validateCapability("sendBtcTransaction"),
+    createInscription: validateCapability("createInscription"),
+    createRepeatInscriptions: validateCapability("createRepeatInscriptions"),
+    signMultipleTransactions: validateCapability("signMultipleTransactions"),
+    addListener: validateCapability("addListener")
+  };
+  return Object.entries(capabilityMap).reduce((acc, [capability, value]) => {
+    if (value) return [...acc, capability];
+    return acc;
+  }, []);
+};
+var getCapabilities = async (options) => {
+  const provider = await getProviderOrThrow(options.getProvider);
+  const request2 = (0, import_jsontokens2.createUnsecuredToken)(options.payload);
+  if (provider.getCapabilities) {
+    try {
+      const response = await provider.getCapabilities(request2);
+      options.onFinish?.(extractOrValidateCapabilities(provider, new Set(response)));
+    } catch (error) {
+      console.error("[Connect] Error during capabilities request", error);
+    }
+  }
+  try {
+    const inferredCapabilities = extractOrValidateCapabilities(provider);
+    options.onFinish?.(inferredCapabilities);
+  } catch (error) {
+    console.error("[Connect] Error during capabilities request", error);
+    options.onCancel?.();
+  }
+};
+
+// src/inscriptions/createInscription.ts
+var import_jsontokens3 = require("jsontokens");
+
+// src/inscriptions/utils.ts
+var MAX_CONTENT_LENGTH_MAINNET = 4e5;
+var MAX_CONTENT_LENGTH_TESTNET = 6e4;
+var validateInscriptionPayload = (payload) => {
+  const { contentType, content, payloadType, network, appFeeAddress, appFee } = payload;
+  if (!/^[a-z]+\/[a-z0-9\-\.\+]+(?=;.*|$)/.test(contentType)) {
+    throw new Error("Invalid content type detected");
+  }
+  if (!content || content.length === 0) {
+    throw new Error("Empty content not allowed");
+  }
+  if (!payloadType || payloadType !== "BASE_64" && payloadType !== "PLAIN_TEXT") {
+    throw new Error("Empty invalid payloadType specified");
+  }
+  if (content.length > (network.type === "Mainnet" ? MAX_CONTENT_LENGTH_MAINNET : MAX_CONTENT_LENGTH_TESTNET)) {
+    throw new Error("Content too large");
+  }
+  if ((appFeeAddress?.length ?? 0) > 0 && (appFee ?? 0) <= 0) {
+    throw new Error("Invalid combination of app fee address and fee provided");
+  }
+};
+
+// src/inscriptions/createInscription.ts
+var createInscription = async (options) => {
+  const { getProvider } = options;
+  const provider = await getProviderOrThrow(getProvider);
+  validateInscriptionPayload(options.payload);
+  try {
+    const request2 = (0, import_jsontokens3.createUnsecuredToken)(options.payload);
+    const response = await provider.createInscription(request2);
+    options.onFinish?.(response);
+  } catch (error) {
+    console.error("[Connect] Error during create inscription", error);
+    options.onCancel?.();
+  }
+};
+
+// src/inscriptions/createRepeatInscriptions.ts
+var import_jsontokens4 = require("jsontokens");
+var createRepeatInscriptions = async (options) => {
+  const { getProvider } = options;
+  const provider = await getProviderOrThrow(getProvider);
+  validateInscriptionPayload(options.payload);
+  try {
+    const request2 = (0, import_jsontokens4.createUnsecuredToken)(options.payload);
+    const response = await provider.createRepeatInscriptions(request2);
+    options.onFinish?.(response);
+  } catch (error) {
+    console.error("[Connect] Error during create repeat inscriptions", error);
+    options.onCancel?.();
+  }
+};
+
+// src/messages/index.ts
+var import_jsontokens5 = require("jsontokens");
+var signMessage = async (options) => {
+  const provider = await getProviderOrThrow(options.getProvider);
+  const { address, message } = options.payload;
+  if (!address) {
+    throw new Error("An address is required to sign a message");
+  }
+  if (!message) {
+    throw new Error("A message to be signed is required");
+  }
+  try {
+    const request2 = (0, import_jsontokens5.createUnsecuredToken)(options.payload);
+    const response = await provider.signMessage(request2);
+    options.onFinish?.(response);
+  } catch (error) {
+    console.error("[Connect] Error during sign message request", error);
+    options.onCancel?.();
+  }
+};
+
+// src/transactions/sendBtcTransaction.ts
+var import_jsontokens6 = require("jsontokens");
+var serializer = (recipient) => {
+  return recipient.map((value) => {
+    const { address, amountSats } = value;
+    return {
+      address,
+      amountSats: amountSats.toString()
+    };
+  });
+};
+var sendBtcTransaction = async (options) => {
+  const provider = await getProviderOrThrow(options.getProvider);
+  const { recipients, senderAddress, network, message } = options.payload;
+  if (!recipients || recipients.length === 0) {
+    throw new Error("At least one recipient is required");
+  }
+  if (recipients.some(
+    (item) => typeof item.address !== "string" || typeof item.amountSats !== "bigint"
+  )) {
+    throw new Error("Incorrect recipient format");
+  }
+  if (!senderAddress) {
+    throw new Error("The sender address is required");
+  }
+  try {
+    const serializedRecipients = serializer(recipients);
+    const serializedPayload = {
+      network,
+      senderAddress,
+      message,
+      recipients: serializedRecipients
+    };
+    const request2 = (0, import_jsontokens6.createUnsecuredToken)(serializedPayload);
+    const response = await provider.sendBtcTransaction(request2);
+    options.onFinish?.(response);
+  } catch (error) {
+    console.error("[Connect] Error during send BTC transaction request", error);
+    options.onCancel?.();
+  }
+};
+
+// src/transactions/signTransaction.ts
+var import_jsontokens7 = require("jsontokens");
+var signTransaction = async (options) => {
+  const provider = await getProviderOrThrow(options.getProvider);
+  const { psbtBase64, inputsToSign } = options.payload;
+  if (!psbtBase64) {
+    throw new Error("A value for psbtBase64 representing the tx hash is required");
+  }
+  if (!inputsToSign) {
+    throw new Error("An array specifying the inputs to be signed by the wallet is required");
+  }
+  try {
+    const request2 = (0, import_jsontokens7.createUnsecuredToken)(options.payload);
+    const response = await provider.signTransaction(request2);
+    options.onFinish?.(response);
+  } catch (error) {
+    console.error("[Connect] Error during sign transaction request", error);
+    options.onCancel?.();
+  }
+};
+
+// src/transactions/signMultipleTransactions.ts
+var import_jsontokens8 = require("jsontokens");
+var signMultipleTransactions = async (options) => {
+  const provider = await getProviderOrThrow(options.getProvider);
+  const { psbts } = options.payload;
+  if (!psbts || !psbts.length) {
+    throw new Error("psbts array is required");
+  }
+  if (psbts.length > 100) {
+    throw new Error("psbts array must contain less than 100 psbts");
+  }
+  try {
+    const request2 = (0, import_jsontokens8.createUnsecuredToken)(options.payload);
+    const response = await provider.signMultipleTransactions(request2);
+    options.onFinish?.(response);
+  } catch (error) {
+    console.error("[Connect] Error during sign Multiple transactions request", error);
+    options.onCancel?.();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AddressPurpose,
+  AddressType,
+  BaseAdapter,
+  BitcoinNetworkType,
+  DefaultAdaptersInfo,
+  MessageSigningProtocols,
+  RpcErrorCode,
+  RpcIdSchema,
+  SatsConnectAdapter,
+  accountChangeEventName,
+  accountChangeSchema,
+  addListener,
+  addressSchema,
+  connectMethodName,
+  connectParamsSchema,
+  connectRequestMessageSchema,
+  connectResultSchema,
+  createInscription,
+  createRepeatInscriptions,
+  defaultAdapters,
+  disconnectEventName,
+  disconnectMethodName,
+  disconnectParamsSchema,
+  disconnectRequestMessageSchema,
+  disconnectResultSchema,
+  disconnectSchema,
+  getAccountMethodName,
+  getAccountParamsSchema,
+  getAccountRequestMessageSchema,
+  getAccountResultSchema,
+  getAccountsMethodName,
+  getAccountsParamsSchema,
+  getAccountsRequestMessageSchema,
+  getAccountsResultSchema,
+  getAddress,
+  getAddressesMethodName,
+  getAddressesParamsSchema,
+  getAddressesRequestMessageSchema,
+  getAddressesResultSchema,
+  getBalanceMethodName,
+  getBalanceParamsSchema,
+  getBalanceRequestMessageSchema,
+  getBalanceResultSchema,
+  getCapabilities,
+  getCurrentPermissionsMethodName,
+  getCurrentPermissionsParamsSchema,
+  getCurrentPermissionsRequestMessageSchema,
+  getCurrentPermissionsResultSchema,
+  getDefaultProvider,
+  getInfoMethodName,
+  getInfoParamsSchema,
+  getInfoRequestMessageSchema,
+  getInfoResultSchema,
+  getInscriptionsMethodName,
+  getInscriptionsParamsSchema,
+  getInscriptionsRequestMessageSchema,
+  getInscriptionsResultSchema,
+  getProviderById,
+  getProviderOrThrow,
+  getProviders,
+  getSupportedWallets,
+  getWalletTypeMethodName,
+  getWalletTypeParamsSchema,
+  getWalletTypeRequestMessageSchema,
+  getWalletTypeResultSchema,
+  isProviderInstalled,
+  networkChangeEventName,
+  networkChangeSchema,
+  permissionTemplate,
+  removeDefaultProvider,
+  renouncePermissionsMethodName,
+  renouncePermissionsParamsSchema,
+  renouncePermissionsRequestMessageSchema,
+  renouncePermissionsResultSchema,
+  request,
+  requestPermissionsMethodName,
+  requestPermissionsParamsSchema,
+  requestPermissionsRequestMessageSchema,
+  requestPermissionsResultSchema,
+  rpcErrorResponseMessageSchema,
+  rpcRequestMessageSchema,
+  rpcResponseMessageSchema,
+  rpcSuccessResponseMessageSchema,
+  runesEtchMethodName,
+  runesEtchParamsSchema,
+  runesEtchRequestMessageSchema,
+  runesEtchResultSchema,
+  runesGetBalanceMethodName,
+  runesGetBalanceParamsSchema,
+  runesGetBalanceRequestMessageSchema,
+  runesGetBalanceResultSchema,
+  runesMintMethodName,
+  runesMintParamsSchema,
+  runesMintRequestMessageSchema,
+  runesMintResultSchema,
+  runesTransferMethodName,
+  runesTransferParamsSchema,
+  runesTransferRequestMessageSchema,
+  runesTransferResultSchema,
+  sendBtcTransaction,
+  sendInscriptionsMethodName,
+  sendInscriptionsParamsSchema,
+  sendInscriptionsRequestMessageSchema,
+  sendInscriptionsResultSchema,
+  sendTransferMethodName,
+  sendTransferParamsSchema,
+  sendTransferRequestMessageSchema,
+  sendTransferResultSchema,
+  setDefaultProvider,
+  signMessage,
+  signMessageMethodName,
+  signMessageParamsSchema,
+  signMessageRequestMessageSchema,
+  signMessageResultSchema,
+  signMultipleTransactions,
+  signPsbtMethodName,
+  signPsbtParamsSchema,
+  signPsbtRequestMessageSchema,
+  signPsbtResultSchema,
+  signTransaction,
+  stxCallContractMethodName,
+  stxCallContractParamsSchema,
+  stxCallContractRequestMessageSchema,
+  stxCallContractResultSchema,
+  stxDeployContractMethodName,
+  stxDeployContractParamsSchema,
+  stxDeployContractRequestMessageSchema,
+  stxDeployContractResultSchema,
+  stxGetAccountsMethodName,
+  stxGetAccountsParamsSchema,
+  stxGetAccountsRequestMessageSchema,
+  stxGetAccountsResultSchema,
+  stxGetAddressesMethodName,
+  stxGetAddressesParamsSchema,
+  stxGetAddressesRequestMessageSchema,
+  stxGetAddressesResultSchema,
+  stxSignMessageMethodName,
+  stxSignMessageParamsSchema,
+  stxSignMessageRequestMessageSchema,
+  stxSignMessageResultSchema,
+  stxSignStructuredMessageMethodName,
+  stxSignStructuredMessageParamsSchema,
+  stxSignStructuredMessageRequestMessageSchema,
+  stxSignStructuredMessageResultSchema,
+  stxSignTransactionMethodName,
+  stxSignTransactionParamsSchema,
+  stxSignTransactionRequestMessageSchema,
+  stxSignTransactionResultSchema,
+  stxTransferStxMethodName,
+  stxTransferStxParamsSchema,
+  stxTransferStxRequestMessageSchema,
+  stxTransferStxResultSchema,
+  walletEventSchema,
+  walletTypeSchema,
+  walletTypes
+});
+/*! Bundled license information:
+
+@noble/hashes/esm/utils.js:
+  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+*/