@sats-connect/core 0.4.0-590a696 → 0.4.0-68f1213

package/dist/index.js

@@ -0,0 +1,2199 @@
+"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,
+  TransferRunesResultSchema: () => TransferRunesResultSchema,
+  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,
+  getInscriptionsResultSchema: () => getInscriptionsResultSchema,
+  getInscriptionsSchema: () => getInscriptionsSchema,
+  getProviderById: () => getProviderById,
+  getProviderOrThrow: () => getProviderOrThrow,
+  getProviders: () => getProviders,
+  getRunesBalanceMethodName: () => getRunesBalanceMethodName,
+  getRunesBalanceParamsSchema: () => getRunesBalanceParamsSchema,
+  getRunesBalanceRequestMessageSchema: () => getRunesBalanceRequestMessageSchema,
+  getRunesBalanceResultSchema: () => getRunesBalanceResultSchema,
+  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,
+  sendBtcTransaction: () => sendBtcTransaction,
+  sendInscriptionsMethodName: () => sendInscriptionsMethodName,
+  sendInscriptionsParamsSchema: () => sendInscriptionsParamsSchema,
+  sendInscriptionsResultSchema: () => sendInscriptionsResultSchema,
+  sendInscriptionsSchema: () => sendInscriptionsSchema,
+  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,
+  transferRunesMethodName: () => transferRunesMethodName,
+  transferRunesParamsSchema: () => transferRunesParamsSchema,
+  transferRunesRequestSchema: () => transferRunesRequestSchema,
+  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 ambientProviders = getProviders();
+  const { xverse, ...defaultProviders } = DefaultAdaptersInfo;
+  const allProviders = [...ambientProviders, ...Object.values(defaultProviders)];
+  const wallets = allProviders.map((provider) => {
+    {
+      return {
+        ...provider,
+        isInstalled: isProviderInstalled(provider.id)
+      };
+    }
+  });
+  return wallets;
+}
+
+// src/types.ts
+var v2 = __toESM(require("valibot"));
+var BitcoinNetworkType = /* @__PURE__ */ ((BitcoinNetworkType3) => {
+  BitcoinNetworkType3["Mainnet"] = "Mainnet";
+  BitcoinNetworkType3["Testnet"] = "Testnet";
+  BitcoinNetworkType3["Signet"] = "Signet";
+  return BitcoinNetworkType3;
+})(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: 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 v17 = __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 code of the Clarity contract.
+   */
+  codeBody: v4.string(),
+  /**
+   * The version of the Clarity contract.
+   */
+  version: 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())),
+  allowedSignHash: v13.optional(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 v14 = __toESM(require("valibot"));
+var import_xverse_core = require("@secretkeylabs/xverse-core");
+var permissionTemplate = v14.variant("type", [
+  v14.object({
+    ...v14.omit(import_xverse_core.permissions.resources.account.accountPermissionSchema, ["clientId", "actions"]).entries,
+    actions: v14.partial(import_xverse_core.permissions.resources.account.accountActionsSchema)
+  }),
+  v14.object({
+    ...v14.omit(import_xverse_core.permissions.resources.wallet.walletPermissionSchema, ["clientId"]).entries,
+    actions: v14.partial(import_xverse_core.permissions.resources.wallet.walletActionsSchema)
+  })
+]);
+var requestPermissionsMethodName = "wallet_requestPermissions";
+var requestPermissionsParamsSchema = v14.nullish(v14.array(permissionTemplate));
+var requestPermissionsResultSchema = v14.literal(true);
+var requestPermissionsRequestMessageSchema = v14.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v14.object({
+    method: v14.literal(requestPermissionsMethodName),
+    params: requestPermissionsParamsSchema,
+    id: v14.string()
+  }).entries
+});
+var renouncePermissionsMethodName = "wallet_renouncePermissions";
+var renouncePermissionsParamsSchema = v14.nullish(v14.null());
+var renouncePermissionsResultSchema = v14.nullish(v14.null());
+var renouncePermissionsRequestMessageSchema = v14.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v14.object({
+    method: v14.literal(renouncePermissionsMethodName),
+    params: renouncePermissionsParamsSchema,
+    id: v14.string()
+  }).entries
+});
+var disconnectMethodName = "wallet_disconnect";
+var disconnectParamsSchema = v14.nullish(v14.null());
+var disconnectResultSchema = v14.nullish(v14.null());
+var disconnectRequestMessageSchema = v14.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v14.object({
+    method: v14.literal(disconnectMethodName),
+    params: disconnectParamsSchema,
+    id: v14.string()
+  }).entries
+});
+var getWalletTypeMethodName = "wallet_getWalletType";
+var getWalletTypeParamsSchema = v14.nullish(v14.null());
+var getWalletTypeResultSchema = walletTypeSchema;
+var getWalletTypeRequestMessageSchema = v14.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v14.object({
+    method: v14.literal(getWalletTypeMethodName),
+    params: getWalletTypeParamsSchema,
+    id: v14.string()
+  }).entries
+});
+var getCurrentPermissionsMethodName = "wallet_getCurrentPermissions";
+var getCurrentPermissionsParamsSchema = v14.nullish(v14.null());
+var getCurrentPermissionsResultSchema = v14.array(import_xverse_core.permissions.store.permission);
+var getCurrentPermissionsRequestMessageSchema = v14.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v14.object({
+    method: v14.literal(getCurrentPermissionsMethodName),
+    params: getCurrentPermissionsParamsSchema,
+    id: v14.string()
+  }).entries
+});
+var getAccountMethodName = "wallet_getAccount";
+var getAccountParamsSchema = v14.nullish(v14.null());
+var getAccountResultSchema = v14.object({
+  id: import_xverse_core.permissions.utils.account.accountIdSchema,
+  addresses: v14.array(addressSchema),
+  walletType: walletTypeSchema
+});
+var getAccountRequestMessageSchema = v14.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v14.object({
+    method: v14.literal(getAccountMethodName),
+    params: getAccountParamsSchema,
+    id: v14.string()
+  }).entries
+});
+var connectMethodName = "wallet_connect";
+var connectParamsSchema = v14.nullish(
+  v14.object({
+    permissions: v14.optional(v14.array(permissionTemplate))
+  })
+);
+var connectResultSchema = getAccountResultSchema;
+var connectRequestMessageSchema = v14.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v14.object({
+    method: v14.literal(connectMethodName),
+    params: connectParamsSchema,
+    id: v14.string()
+  }).entries
+});
+
+// src/request/types/runesMethods.ts
+var v15 = __toESM(require("valibot"));
+var getRunesBalanceMethodName = "runes_getBalance";
+var getRunesBalanceParamsSchema = v15.nullish(v15.null());
+var getRunesBalanceResultSchema = v15.object({
+  balances: v15.array(
+    v15.object({
+      runeName: v15.string(),
+      amount: v15.string(),
+      divisibility: v15.number(),
+      symbol: v15.string(),
+      inscriptionId: v15.nullish(v15.string())
+    })
+  )
+});
+var getRunesBalanceRequestMessageSchema = v15.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v15.object({
+    method: v15.literal(getRunesBalanceMethodName),
+    params: getRunesBalanceParamsSchema,
+    id: v15.string()
+  }).entries
+});
+var transferRunesMethodName = "runes_transfer";
+var transferRunesParamsSchema = v15.object({
+  recipients: v15.array(
+    v15.object({
+      runeName: v15.string(),
+      amount: v15.string(),
+      address: v15.string()
+    })
+  )
+});
+var transferRunesRequestSchema = v15.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v15.object({
+    method: v15.literal(transferRunesMethodName),
+    params: transferRunesParamsSchema,
+    id: v15.string()
+  }).entries
+});
+var TransferRunesResultSchema = v15.object({
+  txid: v15.string()
+});
+
+// src/request/types/ordinalsMethods.ts
+var v16 = __toESM(require("valibot"));
+var getInscriptionsMethodName = "ord_getInscriptions";
+var getInscriptionsParamsSchema = v16.object({
+  offset: v16.number(),
+  limit: v16.number()
+});
+var getInscriptionsResultSchema = v16.object({
+  total: v16.number(),
+  limit: v16.number(),
+  offset: v16.number(),
+  inscriptions: v16.array(
+    v16.object({
+      inscriptionId: v16.string(),
+      inscriptionNumber: v16.string(),
+      address: v16.string(),
+      collectionName: v16.optional(v16.string()),
+      postage: v16.string(),
+      contentLength: v16.string(),
+      contentType: v16.string(),
+      timestamp: v16.number(),
+      offset: v16.number(),
+      genesisTransaction: v16.string(),
+      output: v16.string()
+    })
+  )
+});
+var getInscriptionsSchema = v16.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v16.object({
+    method: v16.literal(getInscriptionsMethodName),
+    params: getInscriptionsParamsSchema,
+    id: v16.string()
+  }).entries
+});
+var sendInscriptionsMethodName = "ord_sendInscriptions";
+var sendInscriptionsParamsSchema = v16.object({
+  transfers: v16.array(
+    v16.object({
+      address: v16.string(),
+      inscriptionId: v16.string()
+    })
+  )
+});
+var sendInscriptionsResultSchema = v16.object({
+  txid: v16.string()
+});
+var sendInscriptionsSchema = v16.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v16.object({
+    method: v16.literal(sendInscriptionsMethodName),
+    params: sendInscriptionsParamsSchema,
+    id: v16.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 (v17.is(rpcErrorResponseMessageSchema, response)) {
+    return {
+      status: "error",
+      error: response.error
+    };
+  }
+  if (v17.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,PHN2ZyB3aWR0aD0iMTAyIiBoZWlnaHQ9IjEwMiIgdmlld0JveD0iMCAwIDEwMiAxMDIiIGZpbGw9Im5vbmUiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+CjxnIGlkPSJJY29uX0FydCAoRWRpdCBNZSkiPgo8cmVjdCB3aWR0aD0iMTAyIiBoZWlnaHQ9IjEwMiIgZmlsbD0iIzE4MTgxOCIvPgo8ZyBpZD0iTG9nby9FbWJsZW0iIGNsaXAtcGF0aD0idXJsKCNjbGlwMF8yMF8xMjIzKSI+CjxwYXRoIGlkPSJWZWN0b3IiIGQ9Ik03NC42NTQyIDczLjg4ODNWNjUuMjMxMkM3NC42NTQyIDY0Ljg4OCA3NC41MTc3IDY0LjU2MDYgNzQuMjc0NSA2NC4zMTc0TDM3LjQzOTcgMjcuNDgyNUMzNy4xOTY1IDI3LjIzOTIgMzYuODY5MSAyNy4xMDI4IDM2LjUyNTggMjcuMTAyOEgyNy44NjlDMjcuNDQxNiAyNy4xMDI4IDI3LjA5MzggMjcuNDUwNiAyNy4wOTM4IDI3Ljg3OFYzNS45MjExQzI3LjA5MzggMzYuMjY0NCAyNy4yMzAyIDM2LjU5MTcgMjcuNDczNCAzNi44MzVMNDAuNjk1MiA1MC4wNTY3QzQwLjk5NzUgNTAuMzU5MSA0MC45OTc1IDUwLjg1MDEgNDAuNjk1MiA1MS4xNTI0TDI3LjMyMTEgNjQuNTI2NUMyNy4xNzU2IDY0LjY3MiAyNy4wOTM4IDY0Ljg2OTggMjcuMDkzOCA2NS4wNzQ0VjczLjg4ODNDMjcuMDkzOCA3NC4zMTUzIDI3LjQ0MTYgNzQuNjYzNSAyNy44NjkgNzQuNjYzNUg0Mi4zMzQyQzQyLjc2MTYgNzQuNjYzNSA0My4xMDk0IDc0LjMxNTMgNDMuMTA5NCA3My44ODgzVjY4LjY5NThDNDMuMTA5NCA2OC40OTEyIDQzLjE5MTIgNjguMjkzNSA0My4zMzY4IDY4LjE0NzlMNTAuNTExNCA2MC45NzMzQzUwLjgxMzggNjAuNjcwOSA1MS4zMDQ4IDYwLjY3MDkgNTEuNjA3MiA2MC45NzMzTDY0LjkxOTggNzQuMjg2MUM2NS4xNjMxIDc0LjUyOTMgNjUuNDkwNCA3NC42NjU4IDY1LjgzMzcgNzQuNjY1OEg3My44NzY3Qzc0LjMwNDIgNzQuNjY1OCA3NC42NTE5IDc0LjMxNzYgNzQuNjUxOSA3My44OTA2TDc0LjY1NDIgNzMuODg4M1oiIGZpbGw9IndoaXRlIi8+CjxwYXRoIGlkPSJWZWN0b3JfMiIgZD0iTTU1LjM1OCAzOC41NjcySDYyLjYwMzFDNjMuMDMyOCAzOC41NjcyIDYzLjM4MjkgMzguOTE3MyA2My4zODI5IDM5LjM0NjlWNDYuNTkyMUM2My4zODI5IDQ3LjI4NzcgNjQuMjI0IDQ3LjYzNTUgNjQuNzE1MSA0Ny4xNDIyTDc0LjY1NDEgMzcuMTg3M0M3NC43OTk0IDM3LjA0MTggNzQuODgxNiAzNi44NDQgNzQuODgxNiAzNi42MzcxVjI3LjkxODlDNzQuODgxNiAyNy40ODkyIDc0LjUzMzQgMjcuMTM5MSA3NC4xMDE3IDI3LjEzOTFMNjUuMjUzOCAyNy4xMjc3QzY1LjA0NyAyNy4xMjc3IDY0Ljg0OTIgMjcuMjA5NiA2NC43MDE0IDI3LjM1NTFMNTQuODA1NiAzNy4yMzVDNTQuMzE0NSAzNy43MjYgNTQuNjYyMyAzOC41NjcyIDU1LjM1NTcgMzguNTY3Mkg1NS4zNThaIiBmaWxsPSIjRUU3QTMwIi8+CjwvZz4KPC9nPgo8ZGVmcz4KPGNsaXBQYXRoIGlkPSJjbGlwMF8yMF8xMjIzIj4KPHJlY3Qgd2lkdGg9IjQ3LjgxMjUiIGhlaWdodD0iNDcuODEyNSIgZmlsbD0id2hpdGUiIHRyYW5zZm9ybT0idHJhbnNsYXRlKDI3LjA5MzggMjcuMDkzOCkiLz4KPC9jbGlwUGF0aD4KPC9kZWZzPgo8L3N2Zz4K"
+  },
+  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,
+  TransferRunesResultSchema,
+  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,
+  getInscriptionsResultSchema,
+  getInscriptionsSchema,
+  getProviderById,
+  getProviderOrThrow,
+  getProviders,
+  getRunesBalanceMethodName,
+  getRunesBalanceParamsSchema,
+  getRunesBalanceRequestMessageSchema,
+  getRunesBalanceResultSchema,
+  getSupportedWallets,
+  getWalletTypeMethodName,
+  getWalletTypeParamsSchema,
+  getWalletTypeRequestMessageSchema,
+  getWalletTypeResultSchema,
+  isProviderInstalled,
+  networkChangeEventName,
+  networkChangeSchema,
+  permissionTemplate,
+  removeDefaultProvider,
+  renouncePermissionsMethodName,
+  renouncePermissionsParamsSchema,
+  renouncePermissionsRequestMessageSchema,
+  renouncePermissionsResultSchema,
+  request,
+  requestPermissionsMethodName,
+  requestPermissionsParamsSchema,
+  requestPermissionsRequestMessageSchema,
+  requestPermissionsResultSchema,
+  rpcErrorResponseMessageSchema,
+  rpcRequestMessageSchema,
+  rpcResponseMessageSchema,
+  rpcSuccessResponseMessageSchema,
+  sendBtcTransaction,
+  sendInscriptionsMethodName,
+  sendInscriptionsParamsSchema,
+  sendInscriptionsResultSchema,
+  sendInscriptionsSchema,
+  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,
+  transferRunesMethodName,
+  transferRunesParamsSchema,
+  transferRunesRequestSchema,
+  walletEventSchema,
+  walletTypeSchema,
+  walletTypes
+});