@sats-connect/core 0.14.0-8ca2d84 → 0.14.0-dcc11ec

package/dist/index.js

@@ -121,6 +121,14 @@ __export(index_exports, {
   isProviderInstalled: () => isProviderInstalled,
   networkChangeEventName: () => networkChangeEventName,
   networkChangeSchema: () => networkChangeSchema,
+  openBridgeMethodName: () => openBridgeMethodName,
+  openBridgeParamsSchema: () => openBridgeParamsSchema,
+  openBridgeRequestMessageSchema: () => openBridgeRequestMessageSchema,
+  openBridgeResultSchema: () => openBridgeResultSchema,
+  openBuyMethodName: () => openBuyMethodName,
+  openBuyParamsSchema: () => openBuyParamsSchema,
+  openBuyRequestMessageSchema: () => openBuyRequestMessageSchema,
+  openBuyResultSchema: () => openBuyResultSchema,
   openReceiveMethodName: () => openReceiveMethodName,
   openReceiveParamsSchema: () => openReceiveParamsSchema,
   openReceiveRequestMessageSchema: () => openReceiveRequestMessageSchema,
@@ -278,7 +286,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/request/index.ts
-var v53 = __toESM(require("valibot"));
+var v55 = __toESM(require("valibot"));
 
 // src/provider/types.ts
 var v4 = __toESM(require("valibot"));
@@ -522,7 +530,7 @@ var sanitizeAddressPurposeRequest = (method, params) => {
 };
 
 // src/request/types/btcMethods.ts
-var v18 = __toESM(require("valibot"));
+var v20 = __toESM(require("valibot"));
 
 // src/request/types/walletMethods/addNetwork.ts
 var v5 = __toESM(require("valibot"));
@@ -744,50 +752,83 @@ var getWalletTypeRequestMessageSchema = v14.object({
   }).entries
 });
 
-// src/request/types/walletMethods/openReceive.ts
+// src/request/types/walletMethods/openBridge.ts
 var v15 = __toESM(require("valibot"));
-var openReceiveMethodName = "wallet_openReceive";
-var openReceiveParamsSchema = v15.object({
-  address: v15.string()
+var openBridgeMethodName = "wallet_openBridge";
+var openBridgeParamsSchema = v15.object({
+  fromAsset: v15.string(),
+  toAsset: v15.string()
 });
-var openReceiveResultSchema = v15.nullish(v15.null());
-var openReceiveRequestMessageSchema = v15.object({
+var openBridgeResultSchema = v15.nullish(v15.null());
+var openBridgeRequestMessageSchema = v15.object({
   ...rpcRequestMessageSchema.entries,
   ...v15.object({
-    method: v15.literal(openReceiveMethodName),
-    params: openReceiveParamsSchema,
+    method: v15.literal(openBridgeMethodName),
+    params: openBridgeParamsSchema,
     id: v15.string()
   }).entries
 });
 
-// src/request/types/walletMethods/renouncePermissions.ts
+// src/request/types/walletMethods/openBuy.ts
 var v16 = __toESM(require("valibot"));
-var renouncePermissionsMethodName = "wallet_renouncePermissions";
-var renouncePermissionsParamsSchema = v16.nullish(v16.null());
-var renouncePermissionsResultSchema = v16.nullish(v16.null());
-var renouncePermissionsRequestMessageSchema = v16.object({
+var openBuyMethodName = "wallet_openBuy";
+var openBuyParamsSchema = v16.object({
+  asset: v16.string()
+});
+var openBuyResultSchema = v16.nullish(v16.null());
+var openBuyRequestMessageSchema = v16.object({
   ...rpcRequestMessageSchema.entries,
   ...v16.object({
-    method: v16.literal(renouncePermissionsMethodName),
-    params: renouncePermissionsParamsSchema,
+    method: v16.literal(openBuyMethodName),
+    params: openBuyParamsSchema,
     id: v16.string()
   }).entries
 });
 
-// src/request/types/walletMethods/requestPermissions.ts
+// src/request/types/walletMethods/openReceive.ts
 var v17 = __toESM(require("valibot"));
-var requestPermissionsMethodName = "wallet_requestPermissions";
-var requestPermissionsParamsSchema = v17.nullish(v17.array(PermissionRequestParams));
-var requestPermissionsResultSchema = v17.literal(true);
-var requestPermissionsRequestMessageSchema = v17.object({
+var openReceiveMethodName = "wallet_openReceive";
+var openReceiveParamsSchema = v17.object({
+  address: v17.string()
+});
+var openReceiveResultSchema = addressSchema;
+var openReceiveRequestMessageSchema = v17.object({
   ...rpcRequestMessageSchema.entries,
   ...v17.object({
-    method: v17.literal(requestPermissionsMethodName),
-    params: requestPermissionsParamsSchema,
+    method: v17.literal(openReceiveMethodName),
+    params: openReceiveParamsSchema,
     id: v17.string()
   }).entries
 });
 
+// src/request/types/walletMethods/renouncePermissions.ts
+var v18 = __toESM(require("valibot"));
+var renouncePermissionsMethodName = "wallet_renouncePermissions";
+var renouncePermissionsParamsSchema = v18.nullish(v18.null());
+var renouncePermissionsResultSchema = v18.nullish(v18.null());
+var renouncePermissionsRequestMessageSchema = v18.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v18.object({
+    method: v18.literal(renouncePermissionsMethodName),
+    params: renouncePermissionsParamsSchema,
+    id: v18.string()
+  }).entries
+});
+
+// src/request/types/walletMethods/requestPermissions.ts
+var v19 = __toESM(require("valibot"));
+var requestPermissionsMethodName = "wallet_requestPermissions";
+var requestPermissionsParamsSchema = v19.nullish(v19.array(PermissionRequestParams));
+var requestPermissionsResultSchema = v19.literal(true);
+var requestPermissionsRequestMessageSchema = v19.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v19.object({
+    method: v19.literal(requestPermissionsMethodName),
+    params: requestPermissionsParamsSchema,
+    id: v19.string()
+  }).entries
+});
+
 // src/request/types/btcMethods.ts
 var ProviderPlatform = /* @__PURE__ */ ((ProviderPlatform2) => {
   ProviderPlatform2["Web"] = "web";
@@ -795,58 +836,58 @@ var ProviderPlatform = /* @__PURE__ */ ((ProviderPlatform2) => {
   return ProviderPlatform2;
 })(ProviderPlatform || {});
 var getInfoMethodName = "getInfo";
-var getInfoParamsSchema = v18.nullish(v18.null());
-var getInfoResultSchema = v18.object({
+var getInfoParamsSchema = v20.nullish(v20.null());
+var getInfoResultSchema = v20.object({
   /**
    * Version of the wallet.
    */
-  version: v18.string(),
+  version: v20.string(),
   /**
    * The platform the wallet is running on (web or mobile).
    */
-  platform: v18.optional(v18.enum(ProviderPlatform)),
+  platform: v20.optional(v20.enum(ProviderPlatform)),
   /**
    * [WBIP](https://wbips.netlify.app/wbips/WBIP002) methods supported by the wallet.
    */
-  methods: v18.optional(v18.array(v18.string())),
+  methods: v20.optional(v20.array(v20.string())),
   /**
    * List of WBIP standards supported by the wallet. Not currently used.
    */
-  supports: v18.array(v18.string())
+  supports: v20.array(v20.string())
 });
-var getInfoRequestMessageSchema = v18.object({
+var getInfoRequestMessageSchema = v20.object({
   ...rpcRequestMessageSchema.entries,
-  ...v18.object({
-    method: v18.literal(getInfoMethodName),
+  ...v20.object({
+    method: v20.literal(getInfoMethodName),
     params: getInfoParamsSchema,
-    id: v18.string()
+    id: v20.string()
   }).entries
 });
 var getAddressesMethodName = "getAddresses";
-var getAddressesParamsSchema = v18.object({
+var getAddressesParamsSchema = v20.object({
   /**
    * The purposes for which to generate addresses. See
    * {@linkcode AddressPurpose} for available purposes.
    */
-  purposes: v18.array(v18.enum(AddressPurpose)),
+  purposes: v20.array(v20.enum(AddressPurpose)),
   /**
    * A message to be displayed to the user in the request prompt.
    */
-  message: v18.optional(v18.string())
+  message: v20.optional(v20.string())
 });
-var getAddressesResultSchema = v18.object({
+var getAddressesResultSchema = v20.object({
   /**
    * The addresses generated for the given purposes.
    */
-  addresses: v18.array(addressSchema),
+  addresses: v20.array(addressSchema),
   network: getNetworkResultSchema
 });
-var getAddressesRequestMessageSchema = v18.object({
+var getAddressesRequestMessageSchema = v20.object({
   ...rpcRequestMessageSchema.entries,
-  ...v18.object({
-    method: v18.literal(getAddressesMethodName),
+  ...v20.object({
+    method: v20.literal(getAddressesMethodName),
     params: getAddressesParamsSchema,
-    id: v18.string()
+    id: v20.string()
   }).entries
 });
 var signMessageMethodName = "signMessage";
@@ -855,606 +896,606 @@ var MessageSigningProtocols = /* @__PURE__ */ ((MessageSigningProtocols2) => {
   MessageSigningProtocols2["BIP322"] = "BIP322";
   return MessageSigningProtocols2;
 })(MessageSigningProtocols || {});
-var signMessageParamsSchema = v18.object({
+var signMessageParamsSchema = v20.object({
   /**
    * The address used for signing.
    **/
-  address: v18.string(),
+  address: v20.string(),
   /**
    * The message to sign.
    **/
-  message: v18.string(),
+  message: v20.string(),
   /**
    * The protocol to use for signing the message.
    */
-  protocol: v18.optional(v18.enum(MessageSigningProtocols))
+  protocol: v20.optional(v20.enum(MessageSigningProtocols))
 });
-var signMessageResultSchema = v18.object({
+var signMessageResultSchema = v20.object({
   /**
    * The signature of the message.
    */
-  signature: v18.string(),
+  signature: v20.string(),
   /**
    * hash of the message.
    */
-  messageHash: v18.string(),
+  messageHash: v20.string(),
   /**
    * The address used for signing.
    */
-  address: v18.string(),
+  address: v20.string(),
   /**
    * The protocol to use for signing the message.
    */
-  protocol: v18.enum(MessageSigningProtocols)
+  protocol: v20.enum(MessageSigningProtocols)
 });
-var signMessageRequestMessageSchema = v18.object({
+var signMessageRequestMessageSchema = v20.object({
   ...rpcRequestMessageSchema.entries,
-  ...v18.object({
-    method: v18.literal(signMessageMethodName),
+  ...v20.object({
+    method: v20.literal(signMessageMethodName),
     params: signMessageParamsSchema,
-    id: v18.string()
+    id: v20.string()
   }).entries
 });
 var sendTransferMethodName = "sendTransfer";
-var sendTransferParamsSchema = v18.object({
+var sendTransferParamsSchema = v20.object({
   /**
    * Array of recipients to send to.
    * The amount to send to each recipient is in satoshis.
    */
-  recipients: v18.array(
-    v18.object({
-      address: v18.string(),
-      amount: v18.number()
+  recipients: v20.array(
+    v20.object({
+      address: v20.string(),
+      amount: v20.number()
     })
   )
 });
-var sendTransferResultSchema = v18.object({
+var sendTransferResultSchema = v20.object({
   /**
    * The transaction id as a hex-encoded string.
    */
-  txid: v18.string()
+  txid: v20.string()
 });
-var sendTransferRequestMessageSchema = v18.object({
+var sendTransferRequestMessageSchema = v20.object({
   ...rpcRequestMessageSchema.entries,
-  ...v18.object({
-    method: v18.literal(sendTransferMethodName),
+  ...v20.object({
+    method: v20.literal(sendTransferMethodName),
     params: sendTransferParamsSchema,
-    id: v18.string()
+    id: v20.string()
   }).entries
 });
 var signPsbtMethodName = "signPsbt";
-var signPsbtParamsSchema = v18.object({
+var signPsbtParamsSchema = v20.object({
   /**
    * The base64 encoded PSBT to sign.
    */
-  psbt: v18.string(),
+  psbt: v20.string(),
   /**
    * The inputs to sign.
    * The key is the address and the value is an array of indexes of the inputs to sign.
    */
-  signInputs: v18.optional(v18.record(v18.string(), v18.array(v18.number()))),
+  signInputs: v20.optional(v20.record(v20.string(), v20.array(v20.number()))),
   /**
    * Whether to broadcast the transaction after signing.
    **/
-  broadcast: v18.optional(v18.boolean())
+  broadcast: v20.optional(v20.boolean())
 });
-var signPsbtResultSchema = v18.object({
+var signPsbtResultSchema = v20.object({
   /**
    * The base64 encoded PSBT after signing.
    */
-  psbt: v18.string(),
+  psbt: v20.string(),
   /**
    * The transaction id as a hex-encoded string.
    * This is only returned if the transaction was broadcast.
    **/
-  txid: v18.optional(v18.string())
+  txid: v20.optional(v20.string())
 });
-var signPsbtRequestMessageSchema = v18.object({
+var signPsbtRequestMessageSchema = v20.object({
   ...rpcRequestMessageSchema.entries,
-  ...v18.object({
-    method: v18.literal(signPsbtMethodName),
+  ...v20.object({
+    method: v20.literal(signPsbtMethodName),
     params: signPsbtParamsSchema,
-    id: v18.string()
+    id: v20.string()
   }).entries
 });
 var getAccountsMethodName = "getAccounts";
-var getAccountsParamsSchema = v18.object({
+var getAccountsParamsSchema = v20.object({
   /**
    * The purposes for which to generate addresses. See
    * {@linkcode AddressPurpose} for available purposes.
    */
-  purposes: v18.array(v18.enum(AddressPurpose)),
+  purposes: v20.array(v20.enum(AddressPurpose)),
   /**
    * A message to be displayed to the user in the request prompt.
    */
-  message: v18.optional(v18.string())
+  message: v20.optional(v20.string())
 });
-var getAccountsResultSchema = v18.array(
-  v18.object({
+var getAccountsResultSchema = v20.array(
+  v20.object({
     ...addressSchema.entries,
-    ...v18.object({
+    ...v20.object({
       walletType: walletTypeSchema
     }).entries
   })
 );
-var getAccountsRequestMessageSchema = v18.object({
+var getAccountsRequestMessageSchema = v20.object({
   ...rpcRequestMessageSchema.entries,
-  ...v18.object({
-    method: v18.literal(getAccountsMethodName),
+  ...v20.object({
+    method: v20.literal(getAccountsMethodName),
     params: getAccountsParamsSchema,
-    id: v18.string()
+    id: v20.string()
   }).entries
 });
 var getBalanceMethodName = "getBalance";
-var getBalanceParamsSchema = v18.nullish(v18.null());
-var getBalanceResultSchema = v18.object({
+var getBalanceParamsSchema = v20.nullish(v20.null());
+var getBalanceResultSchema = v20.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: v18.string(),
+  confirmed: v20.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: v18.string(),
+  unconfirmed: v20.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: v18.string()
+  total: v20.string()
 });
-var getBalanceRequestMessageSchema = v18.object({
+var getBalanceRequestMessageSchema = v20.object({
   ...rpcRequestMessageSchema.entries,
-  ...v18.object({
-    method: v18.literal(getBalanceMethodName),
-    id: v18.string()
+  ...v20.object({
+    method: v20.literal(getBalanceMethodName),
+    id: v20.string()
   }).entries
 });
 
 // src/request/types/ordinalsMethods.ts
-var v19 = __toESM(require("valibot"));
+var v21 = __toESM(require("valibot"));
 var getInscriptionsMethodName = "ord_getInscriptions";
-var getInscriptionsParamsSchema = v19.object({
-  offset: v19.number(),
-  limit: v19.number()
-});
-var getInscriptionsResultSchema = v19.object({
-  total: v19.number(),
-  limit: v19.number(),
-  offset: v19.number(),
-  inscriptions: v19.array(
-    v19.object({
-      inscriptionId: v19.string(),
-      inscriptionNumber: v19.string(),
-      address: v19.string(),
-      collectionName: v19.optional(v19.string()),
-      postage: v19.string(),
-      contentLength: v19.string(),
-      contentType: v19.string(),
-      timestamp: v19.number(),
-      offset: v19.number(),
-      genesisTransaction: v19.string(),
-      output: v19.string()
+var getInscriptionsParamsSchema = v21.object({
+  offset: v21.number(),
+  limit: v21.number()
+});
+var getInscriptionsResultSchema = v21.object({
+  total: v21.number(),
+  limit: v21.number(),
+  offset: v21.number(),
+  inscriptions: v21.array(
+    v21.object({
+      inscriptionId: v21.string(),
+      inscriptionNumber: v21.string(),
+      address: v21.string(),
+      collectionName: v21.optional(v21.string()),
+      postage: v21.string(),
+      contentLength: v21.string(),
+      contentType: v21.string(),
+      timestamp: v21.number(),
+      offset: v21.number(),
+      genesisTransaction: v21.string(),
+      output: v21.string()
     })
   )
 });
-var getInscriptionsRequestMessageSchema = v19.object({
+var getInscriptionsRequestMessageSchema = v21.object({
   ...rpcRequestMessageSchema.entries,
-  ...v19.object({
-    method: v19.literal(getInscriptionsMethodName),
+  ...v21.object({
+    method: v21.literal(getInscriptionsMethodName),
     params: getInscriptionsParamsSchema,
-    id: v19.string()
+    id: v21.string()
   }).entries
 });
 var sendInscriptionsMethodName = "ord_sendInscriptions";
-var sendInscriptionsParamsSchema = v19.object({
-  transfers: v19.array(
-    v19.object({
-      address: v19.string(),
-      inscriptionId: v19.string()
+var sendInscriptionsParamsSchema = v21.object({
+  transfers: v21.array(
+    v21.object({
+      address: v21.string(),
+      inscriptionId: v21.string()
     })
   )
 });
-var sendInscriptionsResultSchema = v19.object({
-  txid: v19.string()
+var sendInscriptionsResultSchema = v21.object({
+  txid: v21.string()
 });
-var sendInscriptionsRequestMessageSchema = v19.object({
+var sendInscriptionsRequestMessageSchema = v21.object({
   ...rpcRequestMessageSchema.entries,
-  ...v19.object({
-    method: v19.literal(sendInscriptionsMethodName),
+  ...v21.object({
+    method: v21.literal(sendInscriptionsMethodName),
     params: sendInscriptionsParamsSchema,
-    id: v19.string()
+    id: v21.string()
   }).entries
 });
 
 // src/request/types/runesMethods/etch.ts
-var v20 = __toESM(require("valibot"));
+var v22 = __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({
+var etchTermsSchema = v22.object({
+  amount: v22.string(),
+  cap: v22.string(),
+  heightStart: v22.optional(v22.string()),
+  heightEnd: v22.optional(v22.string()),
+  offsetStart: v22.optional(v22.string()),
+  offsetEnd: v22.optional(v22.string())
+});
+var inscriptionDetailsSchema = v22.object({
+  contentType: v22.string(),
+  contentBase64: v22.string()
+});
+var runesEtchParamsSchema = v22.object({
+  runeName: v22.string(),
+  divisibility: v22.optional(v22.number()),
+  symbol: v22.optional(v22.string()),
+  premine: v22.optional(v22.string()),
+  isMintable: v22.boolean(),
+  delegateInscriptionId: v22.optional(v22.string()),
+  destinationAddress: v22.string(),
+  refundAddress: v22.string(),
+  feeRate: v22.number(),
+  appServiceFee: v22.optional(v22.number()),
+  appServiceFeeAddress: v22.optional(v22.string()),
+  terms: v22.optional(etchTermsSchema),
+  inscriptionDetails: v22.optional(inscriptionDetailsSchema),
+  network: v22.optional(v22.enum(BitcoinNetworkType))
+});
+var runesEtchResultSchema = v22.object({
+  orderId: v22.string(),
+  fundTransactionId: v22.string(),
+  fundingAddress: v22.string()
+});
+var runesEtchRequestMessageSchema = v22.object({
   ...rpcRequestMessageSchema.entries,
-  ...v20.object({
-    method: v20.literal(runesEtchMethodName),
+  ...v22.object({
+    method: v22.literal(runesEtchMethodName),
     params: runesEtchParamsSchema,
-    id: v20.string()
+    id: v22.string()
   }).entries
 });
 
 // src/request/types/runesMethods/getBalance.ts
-var v21 = __toESM(require("valibot"));
+var v23 = __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()),
-      spendableBalance: v21.string()
+var runesGetBalanceParamsSchema = v23.nullish(v23.null());
+var runesGetBalanceResultSchema = v23.object({
+  balances: v23.array(
+    v23.object({
+      runeName: v23.string(),
+      amount: v23.string(),
+      divisibility: v23.number(),
+      symbol: v23.string(),
+      inscriptionId: v23.nullish(v23.string()),
+      spendableBalance: v23.string()
     })
   )
 });
-var runesGetBalanceRequestMessageSchema = v21.object({
+var runesGetBalanceRequestMessageSchema = v23.object({
   ...rpcRequestMessageSchema.entries,
-  ...v21.object({
-    method: v21.literal(runesGetBalanceMethodName),
+  ...v23.object({
+    method: v23.literal(runesGetBalanceMethodName),
     params: runesGetBalanceParamsSchema,
-    id: v21.string()
+    id: v23.string()
   }).entries
 });
 
 // src/request/types/runesMethods/mint.ts
-var v22 = __toESM(require("valibot"));
+var v24 = __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({
+var runesMintParamsSchema = v24.object({
+  appServiceFee: v24.optional(v24.number()),
+  appServiceFeeAddress: v24.optional(v24.string()),
+  destinationAddress: v24.string(),
+  feeRate: v24.number(),
+  refundAddress: v24.string(),
+  repeats: v24.number(),
+  runeName: v24.string(),
+  network: v24.optional(v24.enum(BitcoinNetworkType))
+});
+var runesMintResultSchema = v24.object({
+  orderId: v24.string(),
+  fundTransactionId: v24.string(),
+  fundingAddress: v24.string()
+});
+var runesMintRequestMessageSchema = v24.object({
   ...rpcRequestMessageSchema.entries,
-  ...v22.object({
-    method: v22.literal(runesMintMethodName),
+  ...v24.object({
+    method: v24.literal(runesMintMethodName),
     params: runesMintParamsSchema,
-    id: v22.string()
+    id: v24.string()
   }).entries
 });
 
 // src/request/types/runesMethods/transfer.ts
-var v23 = __toESM(require("valibot"));
+var v25 = __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 runesTransferParamsSchema = v25.object({
+  recipients: v25.array(
+    v25.object({
+      runeName: v25.string(),
+      amount: v25.string(),
+      address: v25.string()
     })
   )
 });
-var runesTransferResultSchema = v23.object({
-  txid: v23.string()
+var runesTransferResultSchema = v25.object({
+  txid: v25.string()
 });
-var runesTransferRequestMessageSchema = v23.object({
+var runesTransferRequestMessageSchema = v25.object({
   ...rpcRequestMessageSchema.entries,
-  ...v23.object({
-    method: v23.literal(runesTransferMethodName),
+  ...v25.object({
+    method: v25.literal(runesTransferMethodName),
     params: runesTransferParamsSchema,
-    id: v23.string()
+    id: v25.string()
   }).entries
 });
 
 // src/request/types/sparkMethods/flashnetMethods/clawbackFunds.ts
-var v24 = __toESM(require("valibot"));
+var v26 = __toESM(require("valibot"));
 var sparkFlashnetClawbackFundsMethodName = "spark_flashnet_clawbackFunds";
-var sparkFlashnetClawbackFundsParamsSchema = v24.object({
-  sparkTransferId: v24.string(),
-  lpIdentityPublicKey: v24.string()
-});
-var sparkFlashnetClawbackFundsResultSchema = v24.object({
-  requestId: v24.string(),
-  accepted: v24.boolean(),
-  internalRequestId: v24.optional(v24.string()),
-  sparkStatusTrackingId: v24.optional(v24.string()),
-  error: v24.optional(v24.string())
-});
-var sparkFlashnetClawbackFundsRequestMessageSchema = v24.object({
+var sparkFlashnetClawbackFundsParamsSchema = v26.object({
+  sparkTransferId: v26.string(),
+  lpIdentityPublicKey: v26.string()
+});
+var sparkFlashnetClawbackFundsResultSchema = v26.object({
+  requestId: v26.string(),
+  accepted: v26.boolean(),
+  internalRequestId: v26.optional(v26.string()),
+  sparkStatusTrackingId: v26.optional(v26.string()),
+  error: v26.optional(v26.string())
+});
+var sparkFlashnetClawbackFundsRequestMessageSchema = v26.object({
   ...rpcRequestMessageSchema.entries,
-  ...v24.object({
-    method: v24.literal(sparkFlashnetClawbackFundsMethodName),
+  ...v26.object({
+    method: v26.literal(sparkFlashnetClawbackFundsMethodName),
     params: sparkFlashnetClawbackFundsParamsSchema,
-    id: v24.string()
+    id: v26.string()
   }).entries
 });
 
 // src/request/types/sparkMethods/flashnetMethods/executeRouteSwap.ts
-var v25 = __toESM(require("valibot"));
+var v27 = __toESM(require("valibot"));
 var sparkFlashnetExecuteRouteSwapMethodName = "spark_flashnet_executeRouteSwap";
-var sparkFlashnetExecuteRouteSwapParamsSchema = v25.object({
-  hops: v25.array(
-    v25.object({
-      poolId: v25.string(),
-      assetInAddress: v25.string(),
-      assetOutAddress: v25.string(),
-      hopIntegratorFeeRateBps: v25.optional(v25.number())
+var sparkFlashnetExecuteRouteSwapParamsSchema = v27.object({
+  hops: v27.array(
+    v27.object({
+      poolId: v27.string(),
+      assetInAddress: v27.string(),
+      assetOutAddress: v27.string(),
+      hopIntegratorFeeRateBps: v27.optional(v27.number())
     })
   ),
-  initialAssetAddress: v25.string(),
-  inputAmount: v25.string(),
-  maxRouteSlippageBps: v25.string(),
-  minAmountOut: v25.optional(v25.string()),
-  integratorFeeRateBps: v25.optional(v25.number()),
-  integratorPublicKey: v25.optional(v25.string())
-});
-var sparkFlashnetExecuteRouteSwapResultSchema = v25.object({
-  requestId: v25.string(),
-  accepted: v25.boolean(),
-  outputAmount: v25.string(),
-  executionPrice: v25.string(),
-  finalOutboundTransferId: v25.string(),
-  error: v25.optional(v25.string())
-});
-var sparkFlashnetExecuteRouteSwapRequestMessageSchema = v25.object({
+  initialAssetAddress: v27.string(),
+  inputAmount: v27.string(),
+  maxRouteSlippageBps: v27.string(),
+  minAmountOut: v27.optional(v27.string()),
+  integratorFeeRateBps: v27.optional(v27.number()),
+  integratorPublicKey: v27.optional(v27.string())
+});
+var sparkFlashnetExecuteRouteSwapResultSchema = v27.object({
+  requestId: v27.string(),
+  accepted: v27.boolean(),
+  outputAmount: v27.string(),
+  executionPrice: v27.string(),
+  finalOutboundTransferId: v27.string(),
+  error: v27.optional(v27.string())
+});
+var sparkFlashnetExecuteRouteSwapRequestMessageSchema = v27.object({
   ...rpcRequestMessageSchema.entries,
-  ...v25.object({
-    method: v25.literal(sparkFlashnetExecuteRouteSwapMethodName),
+  ...v27.object({
+    method: v27.literal(sparkFlashnetExecuteRouteSwapMethodName),
     params: sparkFlashnetExecuteRouteSwapParamsSchema,
-    id: v25.string()
+    id: v27.string()
   }).entries
 });
 
 // src/request/types/sparkMethods/flashnetMethods/executeSwap.ts
-var v26 = __toESM(require("valibot"));
+var v28 = __toESM(require("valibot"));
 var sparkFlashnetExecuteSwapMethodName = "spark_flashnet_executeSwap";
-var sparkFlashnetExecuteSwapParamsSchema = v26.object({
-  poolId: v26.string(),
-  assetInAddress: v26.string(),
-  assetOutAddress: v26.string(),
-  amountIn: v26.string(),
-  maxSlippageBps: v26.number(),
-  minAmountOut: v26.optional(v26.string()),
-  integratorFeeRateBps: v26.optional(v26.number()),
-  integratorPublicKey: v26.optional(v26.string())
-});
-var sparkFlashnetExecuteSwapResultSchema = v26.object({
-  requestId: v26.string(),
-  accepted: v26.boolean(),
-  amountOut: v26.optional(v26.string()),
-  feeAmount: v26.optional(v26.string()),
-  executionPrice: v26.optional(v26.string()),
-  assetOutAddress: v26.optional(v26.string()),
-  assetInAddress: v26.optional(v26.string()),
-  outboundTransferId: v26.optional(v26.string()),
-  error: v26.optional(v26.string())
-});
-var sparkFlashnetExecuteSwapRequestMessageSchema = v26.object({
+var sparkFlashnetExecuteSwapParamsSchema = v28.object({
+  poolId: v28.string(),
+  assetInAddress: v28.string(),
+  assetOutAddress: v28.string(),
+  amountIn: v28.string(),
+  maxSlippageBps: v28.number(),
+  minAmountOut: v28.optional(v28.string()),
+  integratorFeeRateBps: v28.optional(v28.number()),
+  integratorPublicKey: v28.optional(v28.string())
+});
+var sparkFlashnetExecuteSwapResultSchema = v28.object({
+  requestId: v28.string(),
+  accepted: v28.boolean(),
+  amountOut: v28.optional(v28.string()),
+  feeAmount: v28.optional(v28.string()),
+  executionPrice: v28.optional(v28.string()),
+  assetOutAddress: v28.optional(v28.string()),
+  assetInAddress: v28.optional(v28.string()),
+  outboundTransferId: v28.optional(v28.string()),
+  error: v28.optional(v28.string())
+});
+var sparkFlashnetExecuteSwapRequestMessageSchema = v28.object({
   ...rpcRequestMessageSchema.entries,
-  ...v26.object({
-    method: v26.literal(sparkFlashnetExecuteSwapMethodName),
+  ...v28.object({
+    method: v28.literal(sparkFlashnetExecuteSwapMethodName),
     params: sparkFlashnetExecuteSwapParamsSchema,
-    id: v26.string()
+    id: v28.string()
   }).entries
 });
 
 // src/request/types/sparkMethods/flashnetMethods/getClawbackEligibleTransfers.ts
-var v27 = __toESM(require("valibot"));
+var v29 = __toESM(require("valibot"));
 var sparkGetClawbackEligibleTransfersMethodName = "spark_flashnet_getClawbackEligibleTransfers";
-var sparkGetClawbackEligibleTransfersParamsSchema = v27.nullish(v27.null());
-var sparkGetClawbackEligibleTransfersResultSchema = v27.object({
-  eligibleTransfers: v27.array(
-    v27.object({
-      txId: v27.string(),
-      createdAt: v27.string(),
-      lpIdentityPublicKey: v27.string()
+var sparkGetClawbackEligibleTransfersParamsSchema = v29.nullish(v29.null());
+var sparkGetClawbackEligibleTransfersResultSchema = v29.object({
+  eligibleTransfers: v29.array(
+    v29.object({
+      txId: v29.string(),
+      createdAt: v29.string(),
+      lpIdentityPublicKey: v29.string()
     })
   )
 });
-var sparkGetClawbackEligibleTransfersRequestMessageSchema = v27.object({
+var sparkGetClawbackEligibleTransfersRequestMessageSchema = v29.object({
   ...rpcRequestMessageSchema.entries,
-  ...v27.object({
-    method: v27.literal(sparkGetClawbackEligibleTransfersMethodName),
+  ...v29.object({
+    method: v29.literal(sparkGetClawbackEligibleTransfersMethodName),
     params: sparkGetClawbackEligibleTransfersParamsSchema,
-    id: v27.string()
+    id: v29.string()
   }).entries
 });
 
 // src/request/types/sparkMethods/flashnetMethods/getJwt.ts
-var v28 = __toESM(require("valibot"));
+var v30 = __toESM(require("valibot"));
 var sparkFlashnetGetJwtMethodName = "spark_flashnet_getJwt";
-var sparkFlashnetGetJwtParamsSchema = v28.null();
-var sparkFlashnetGetJwtResultSchema = v28.object({
+var sparkFlashnetGetJwtParamsSchema = v30.null();
+var sparkFlashnetGetJwtResultSchema = v30.object({
   /**
    * The JWT token for authenticated requests to the Flashnet API.
    */
-  jwt: v28.string()
+  jwt: v30.string()
 });
-var sparkFlashnetGetJwtRequestMessageSchema = v28.object({
+var sparkFlashnetGetJwtRequestMessageSchema = v30.object({
   ...rpcRequestMessageSchema.entries,
-  ...v28.object({
-    method: v28.literal(sparkFlashnetGetJwtMethodName),
+  ...v30.object({
+    method: v30.literal(sparkFlashnetGetJwtMethodName),
     params: sparkFlashnetGetJwtParamsSchema,
-    id: v28.string()
+    id: v30.string()
   }).entries
 });
 
 // src/request/types/sparkMethods/flashnetMethods/intents/addLiquidity.ts
-var v29 = __toESM(require("valibot"));
-var sparkFlashnetAddLiquidityIntentSchema = v29.object({
-  type: v29.literal("addLiquidity"),
-  data: v29.object({
-    userPublicKey: v29.string(),
-    poolId: v29.string(),
-    assetAAmount: v29.string(),
-    assetBAmount: v29.string(),
-    assetAMinAmountIn: v29.string(),
-    assetBMinAmountIn: v29.string(),
-    assetATransferId: v29.string(),
-    assetBTransferId: v29.string(),
-    nonce: v29.string()
-  })
-});
-
-// src/request/types/sparkMethods/flashnetMethods/intents/clawback.ts
-var v30 = __toESM(require("valibot"));
-var sparkFlashnetClawbackIntentSchema = v30.object({
-  type: v30.literal("clawback"),
-  data: v30.object({
-    senderPublicKey: v30.string(),
-    sparkTransferId: v30.string(),
-    lpIdentityPublicKey: v30.string(),
-    nonce: v30.string()
-  })
-});
-
-// src/request/types/sparkMethods/flashnetMethods/intents/confirmInitialDeposit.ts
 var v31 = __toESM(require("valibot"));
-var sparkFlashnetConfirmInitialDepositIntentSchema = v31.object({
-  type: v31.literal("confirmInitialDeposit"),
+var sparkFlashnetAddLiquidityIntentSchema = v31.object({
+  type: v31.literal("addLiquidity"),
   data: v31.object({
+    userPublicKey: v31.string(),
     poolId: v31.string(),
-    assetASparkTransferId: v31.string(),
-    poolOwnerPublicKey: v31.string(),
+    assetAAmount: v31.string(),
+    assetBAmount: v31.string(),
+    assetAMinAmountIn: v31.string(),
+    assetBMinAmountIn: v31.string(),
+    assetATransferId: v31.string(),
+    assetBTransferId: v31.string(),
     nonce: v31.string()
   })
 });
 
-// src/request/types/sparkMethods/flashnetMethods/intents/createConstantProductPool.ts
+// src/request/types/sparkMethods/flashnetMethods/intents/clawback.ts
 var v32 = __toESM(require("valibot"));
-var sparkFlashnetCreateConstantProductPoolIntentSchema = v32.object({
-  type: v32.literal("createConstantProductPool"),
+var sparkFlashnetClawbackIntentSchema = v32.object({
+  type: v32.literal("clawback"),
   data: v32.object({
-    poolOwnerPublicKey: v32.string(),
-    assetAAddress: v32.string(),
-    assetBAddress: v32.string(),
-    lpFeeRateBps: v32.union([v32.number(), v32.string()]),
-    totalHostFeeRateBps: v32.union([v32.number(), v32.string()]),
+    senderPublicKey: v32.string(),
+    sparkTransferId: v32.string(),
+    lpIdentityPublicKey: v32.string(),
     nonce: v32.string()
   })
 });
 
-// src/request/types/sparkMethods/flashnetMethods/intents/createSingleSidedPool.ts
+// src/request/types/sparkMethods/flashnetMethods/intents/confirmInitialDeposit.ts
 var v33 = __toESM(require("valibot"));
-var sparkFlashnetCreateSingleSidedPoolIntentSchema = v33.object({
-  type: v33.literal("createSingleSidedPool"),
+var sparkFlashnetConfirmInitialDepositIntentSchema = v33.object({
+  type: v33.literal("confirmInitialDeposit"),
   data: v33.object({
-    assetAAddress: v33.string(),
-    assetBAddress: v33.string(),
-    assetAInitialReserve: v33.string(),
-    virtualReserveA: v33.union([v33.number(), v33.string()]),
-    virtualReserveB: v33.union([v33.number(), v33.string()]),
-    threshold: v33.union([v33.number(), v33.string()]),
-    lpFeeRateBps: v33.union([v33.number(), v33.string()]),
-    totalHostFeeRateBps: v33.union([v33.number(), v33.string()]),
+    poolId: v33.string(),
+    assetASparkTransferId: v33.string(),
     poolOwnerPublicKey: v33.string(),
     nonce: v33.string()
   })
 });
 
-// src/request/types/sparkMethods/flashnetMethods/intents/removeLiquidity.ts
+// src/request/types/sparkMethods/flashnetMethods/intents/createConstantProductPool.ts
 var v34 = __toESM(require("valibot"));
-var sparkFlashnetRemoveLiquidityIntentSchema = v34.object({
-  type: v34.literal("removeLiquidity"),
+var sparkFlashnetCreateConstantProductPoolIntentSchema = v34.object({
+  type: v34.literal("createConstantProductPool"),
   data: v34.object({
-    userPublicKey: v34.string(),
-    poolId: v34.string(),
-    lpTokensToRemove: v34.string(),
+    poolOwnerPublicKey: v34.string(),
+    assetAAddress: v34.string(),
+    assetBAddress: v34.string(),
+    lpFeeRateBps: v34.union([v34.number(), v34.string()]),
+    totalHostFeeRateBps: v34.union([v34.number(), v34.string()]),
     nonce: v34.string()
   })
 });
 
-// src/request/types/sparkMethods/flashnetMethods/intents/routeSwap.ts
+// src/request/types/sparkMethods/flashnetMethods/intents/createSingleSidedPool.ts
 var v35 = __toESM(require("valibot"));
-var sparkFlashnetRouteSwapIntentSchema = v35.object({
-  type: v35.literal("executeRouteSwap"),
+var sparkFlashnetCreateSingleSidedPoolIntentSchema = v35.object({
+  type: v35.literal("createSingleSidedPool"),
   data: v35.object({
-    userPublicKey: v35.string(),
-    initialSparkTransferId: v35.string(),
-    hops: v35.array(
-      v35.object({
-        poolId: v35.string(),
-        inputAssetAddress: v35.string(),
-        outputAssetAddress: v35.string(),
-        hopIntegratorFeeRateBps: v35.optional(v35.union([v35.number(), v35.string()]))
-      })
-    ),
-    inputAmount: v35.string(),
-    maxRouteSlippageBps: v35.union([v35.number(), v35.string()]),
-    minAmountOut: v35.string(),
-    defaultIntegratorFeeRateBps: v35.optional(v35.union([v35.number(), v35.string()])),
+    assetAAddress: v35.string(),
+    assetBAddress: v35.string(),
+    assetAInitialReserve: v35.string(),
+    virtualReserveA: v35.union([v35.number(), v35.string()]),
+    virtualReserveB: v35.union([v35.number(), v35.string()]),
+    threshold: v35.union([v35.number(), v35.string()]),
+    lpFeeRateBps: v35.union([v35.number(), v35.string()]),
+    totalHostFeeRateBps: v35.union([v35.number(), v35.string()]),
+    poolOwnerPublicKey: v35.string(),
     nonce: v35.string()
   })
 });
 
-// src/request/types/sparkMethods/flashnetMethods/intents/swap.ts
+// src/request/types/sparkMethods/flashnetMethods/intents/removeLiquidity.ts
 var v36 = __toESM(require("valibot"));
-var sparkFlashnetSwapIntentSchema = v36.object({
-  type: v36.literal("executeSwap"),
+var sparkFlashnetRemoveLiquidityIntentSchema = v36.object({
+  type: v36.literal("removeLiquidity"),
   data: v36.object({
     userPublicKey: v36.string(),
     poolId: v36.string(),
-    transferId: v36.string(),
-    assetInAddress: v36.string(),
-    assetOutAddress: v36.string(),
-    amountIn: v36.string(),
-    maxSlippageBps: v36.union([v36.number(), v36.string()]),
-    minAmountOut: v36.string(),
-    totalIntegratorFeeRateBps: v36.optional(v36.union([v36.number(), v36.string()])),
+    lpTokensToRemove: v36.string(),
     nonce: v36.string()
   })
 });
 
-// src/request/types/sparkMethods/flashnetMethods/signIntent.ts
+// src/request/types/sparkMethods/flashnetMethods/intents/routeSwap.ts
 var v37 = __toESM(require("valibot"));
+var sparkFlashnetRouteSwapIntentSchema = v37.object({
+  type: v37.literal("executeRouteSwap"),
+  data: v37.object({
+    userPublicKey: v37.string(),
+    initialSparkTransferId: v37.string(),
+    hops: v37.array(
+      v37.object({
+        poolId: v37.string(),
+        inputAssetAddress: v37.string(),
+        outputAssetAddress: v37.string(),
+        hopIntegratorFeeRateBps: v37.optional(v37.union([v37.number(), v37.string()]))
+      })
+    ),
+    inputAmount: v37.string(),
+    maxRouteSlippageBps: v37.union([v37.number(), v37.string()]),
+    minAmountOut: v37.string(),
+    defaultIntegratorFeeRateBps: v37.optional(v37.union([v37.number(), v37.string()])),
+    nonce: v37.string()
+  })
+});
+
+// src/request/types/sparkMethods/flashnetMethods/intents/swap.ts
+var v38 = __toESM(require("valibot"));
+var sparkFlashnetSwapIntentSchema = v38.object({
+  type: v38.literal("executeSwap"),
+  data: v38.object({
+    userPublicKey: v38.string(),
+    poolId: v38.string(),
+    transferId: v38.string(),
+    assetInAddress: v38.string(),
+    assetOutAddress: v38.string(),
+    amountIn: v38.string(),
+    maxSlippageBps: v38.union([v38.number(), v38.string()]),
+    minAmountOut: v38.string(),
+    totalIntegratorFeeRateBps: v38.optional(v38.union([v38.number(), v38.string()])),
+    nonce: v38.string()
+  })
+});
+
+// src/request/types/sparkMethods/flashnetMethods/signIntent.ts
+var v39 = __toESM(require("valibot"));
 var sparkFlashnetSignIntentMethodName = "spark_flashnet_signIntent";
-var sparkFlashnetSignIntentParamsSchema = v37.union([
+var sparkFlashnetSignIntentParamsSchema = v39.union([
   sparkFlashnetSwapIntentSchema,
   sparkFlashnetRouteSwapIntentSchema,
   sparkFlashnetAddLiquidityIntentSchema,
@@ -1464,109 +1505,109 @@ var sparkFlashnetSignIntentParamsSchema = v37.union([
   sparkFlashnetCreateSingleSidedPoolIntentSchema,
   sparkFlashnetRemoveLiquidityIntentSchema
 ]);
-var sparkFlashnetSignIntentResultSchema = v37.object({
+var sparkFlashnetSignIntentResultSchema = v39.object({
   /**
    * The signed intent as a hex string.
    */
-  signature: v37.string()
+  signature: v39.string()
 });
-var sparkFlashnetSignIntentRequestMessageSchema = v37.object({
+var sparkFlashnetSignIntentRequestMessageSchema = v39.object({
   ...rpcRequestMessageSchema.entries,
-  ...v37.object({
-    method: v37.literal(sparkFlashnetSignIntentMethodName),
+  ...v39.object({
+    method: v39.literal(sparkFlashnetSignIntentMethodName),
     params: sparkFlashnetSignIntentParamsSchema,
-    id: v37.string()
+    id: v39.string()
   }).entries
 });
 
 // src/request/types/sparkMethods/flashnetMethods/signStructuredMessage.ts
-var v38 = __toESM(require("valibot"));
+var v40 = __toESM(require("valibot"));
 var sparkFlashnetSignStructuredMessageMethodName = "spark_flashnet_signStructuredMessage";
-var sparkFlashnetSignStructuredMessageParamsSchema = v38.object({
-  message: v38.string()
+var sparkFlashnetSignStructuredMessageParamsSchema = v40.object({
+  message: v40.string()
 });
-var sparkFlashnetSignStructuredMessageResultSchema = v38.object({
-  message: v38.string(),
-  signature: v38.string()
+var sparkFlashnetSignStructuredMessageResultSchema = v40.object({
+  message: v40.string(),
+  signature: v40.string()
 });
-var sparkFlashnetSignStructuredMessageRequestMessageSchema = v38.object({
+var sparkFlashnetSignStructuredMessageRequestMessageSchema = v40.object({
   ...rpcRequestMessageSchema.entries,
-  ...v38.object({
-    method: v38.literal(sparkFlashnetSignStructuredMessageMethodName),
+  ...v40.object({
+    method: v40.literal(sparkFlashnetSignStructuredMessageMethodName),
     params: sparkFlashnetSignStructuredMessageParamsSchema,
-    id: v38.string()
+    id: v40.string()
   }).entries
 });
 
 // src/request/types/sparkMethods/getAddresses.ts
-var v39 = __toESM(require("valibot"));
+var v41 = __toESM(require("valibot"));
 var sparkGetAddressesMethodName = "spark_getAddresses";
-var sparkGetAddressesParamsSchema = v39.nullish(
-  v39.object({
+var sparkGetAddressesParamsSchema = v41.nullish(
+  v41.object({
     /**
      * A message to be displayed to the user in the request prompt.
      */
-    message: v39.optional(v39.string())
+    message: v41.optional(v41.string())
   })
 );
-var sparkGetAddressesResultSchema = v39.object({
+var sparkGetAddressesResultSchema = v41.object({
   /**
    * The addresses generated for the given purposes.
    */
-  addresses: v39.array(addressSchema),
+  addresses: v41.array(addressSchema),
   network: getNetworkResultSchema
 });
-var sparkGetAddressesRequestMessageSchema = v39.object({
+var sparkGetAddressesRequestMessageSchema = v41.object({
   ...rpcRequestMessageSchema.entries,
-  ...v39.object({
-    method: v39.literal(sparkGetAddressesMethodName),
+  ...v41.object({
+    method: v41.literal(sparkGetAddressesMethodName),
     params: sparkGetAddressesParamsSchema,
-    id: v39.string()
+    id: v41.string()
   }).entries
 });
 
 // src/request/types/sparkMethods/getBalance.ts
-var v40 = __toESM(require("valibot"));
+var v42 = __toESM(require("valibot"));
 var sparkGetBalanceMethodName = "spark_getBalance";
-var sparkGetBalanceParamsSchema = v40.nullish(v40.null());
-var sparkGetBalanceResultSchema = v40.object({
+var sparkGetBalanceParamsSchema = v42.nullish(v42.null());
+var sparkGetBalanceResultSchema = v42.object({
   /**
    * The Spark Bitcoin address balance in sats in string form.
    */
-  balance: v40.string(),
-  tokenBalances: v40.array(
-    v40.object({
+  balance: v42.string(),
+  tokenBalances: v42.array(
+    v42.object({
       /* The address balance of the token in string form as it can overflow a js number */
-      balance: v40.string(),
-      tokenMetadata: v40.object({
-        tokenIdentifier: v40.string(),
-        tokenName: v40.string(),
-        tokenTicker: v40.string(),
-        decimals: v40.number(),
-        maxSupply: v40.string()
+      balance: v42.string(),
+      tokenMetadata: v42.object({
+        tokenIdentifier: v42.string(),
+        tokenName: v42.string(),
+        tokenTicker: v42.string(),
+        decimals: v42.number(),
+        maxSupply: v42.string()
       })
     })
   )
 });
-var sparkGetBalanceRequestMessageSchema = v40.object({
+var sparkGetBalanceRequestMessageSchema = v42.object({
   ...rpcRequestMessageSchema.entries,
-  ...v40.object({
-    method: v40.literal(sparkGetBalanceMethodName),
+  ...v42.object({
+    method: v42.literal(sparkGetBalanceMethodName),
     params: sparkGetBalanceParamsSchema,
-    id: v40.string()
+    id: v42.string()
   }).entries
 });
 
 // src/request/types/sparkMethods/signMessage.ts
-var v41 = __toESM(require("valibot"));
+var v43 = __toESM(require("valibot"));
 var sparkSignMessageMethodName = "spark_signMessage";
-var sparkSignMessageParamsSchema = v41.object({
+var sparkSignMessageParamsSchema = v43.object({
   /**
    * The message to sign. The message should only consist of valid UTF-8 characters.
    */
-  message: v41.string()
+  message: v43.string()
 });
-var sparkSignMessageResultSchema = v41.object({
+var sparkSignMessageResultSchema = v43.object({
   /**
    * The signature, encoded in base64, of the message hash.
    *
@@ -1574,98 +1615,98 @@ var sparkSignMessageResultSchema = v41.object({
    * and the resulting byte array is hashed with SHA256 before signing
    * with the private key.
    */
-  signature: v41.string()
+  signature: v43.string()
 });
-var sparkSignMessageRequestMessageSchema = v41.object({
+var sparkSignMessageRequestMessageSchema = v43.object({
   ...rpcRequestMessageSchema.entries,
-  ...v41.object({
-    method: v41.literal(sparkSignMessageMethodName),
+  ...v43.object({
+    method: v43.literal(sparkSignMessageMethodName),
     params: sparkSignMessageParamsSchema,
-    id: v41.string()
+    id: v43.string()
   }).entries
 });
 
 // src/request/types/sparkMethods/transfer.ts
-var v42 = __toESM(require("valibot"));
+var v44 = __toESM(require("valibot"));
 var sparkTransferMethodName = "spark_transfer";
-var sparkTransferParamsSchema = v42.object({
+var sparkTransferParamsSchema = v44.object({
   /**
    * Amount of SATS to transfer as a string or number.
    */
-  amountSats: v42.union([v42.number(), v42.string()]),
+  amountSats: v44.union([v44.number(), v44.string()]),
   /**
    * The recipient's spark address.
    */
-  receiverSparkAddress: v42.string()
+  receiverSparkAddress: v44.string()
 });
-var sparkTransferResultSchema = v42.object({
+var sparkTransferResultSchema = v44.object({
   /**
    * The ID of the transaction.
    */
-  id: v42.string()
+  id: v44.string()
 });
-var sparkTransferRequestMessageSchema = v42.object({
+var sparkTransferRequestMessageSchema = v44.object({
   ...rpcRequestMessageSchema.entries,
-  ...v42.object({
-    method: v42.literal(sparkTransferMethodName),
+  ...v44.object({
+    method: v44.literal(sparkTransferMethodName),
     params: sparkTransferParamsSchema,
-    id: v42.string()
+    id: v44.string()
   }).entries
 });
 
 // src/request/types/sparkMethods/transferToken.ts
-var v43 = __toESM(require("valibot"));
+var v45 = __toESM(require("valibot"));
 var sparkTransferTokenMethodName = "spark_transferToken";
-var sparkTransferTokenParamsSchema = v43.object({
+var sparkTransferTokenParamsSchema = v45.object({
   /**
    * Amount of units of the token to transfer as a string or number.
    */
-  tokenAmount: v43.union([v43.number(), v43.string()]),
+  tokenAmount: v45.union([v45.number(), v45.string()]),
   /**
    * The Bech32m token identifier.
    */
-  tokenIdentifier: v43.string(),
+  tokenIdentifier: v45.string(),
   /**
    * The recipient's spark address.
    */
-  receiverSparkAddress: v43.string()
+  receiverSparkAddress: v45.string()
 });
-var sparkTransferTokenResultSchema = v43.object({
+var sparkTransferTokenResultSchema = v45.object({
   /**
    * The ID of the transaction.
    */
-  id: v43.string()
+  id: v45.string()
 });
-var sparkTransferTokenRequestMessageSchema = v43.object({
+var sparkTransferTokenRequestMessageSchema = v45.object({
   ...rpcRequestMessageSchema.entries,
-  ...v43.object({
-    method: v43.literal(sparkTransferTokenMethodName),
+  ...v45.object({
+    method: v45.literal(sparkTransferTokenMethodName),
     params: sparkTransferTokenParamsSchema,
-    id: v43.string()
+    id: v45.string()
   }).entries
 });
 
 // src/request/types/stxMethods/callContract.ts
-var v44 = __toESM(require("valibot"));
+var v46 = __toESM(require("valibot"));
 var stxCallContractMethodName = "stx_callContract";
-var stxCallContractParamsSchema = v44.object({
+var stxCallContractParamsSchema = v46.object({
   /**
    * The contract principal.
    *
    * E.g. `"SPKE...GD5C.my-contract"`
    */
-  contract: v44.string(),
+  contract: v46.string(),
   /**
    * The name of the function to call.
    *
    * Note: spec changes ongoing,
    * https://github.com/stacksgov/sips/pull/166#pullrequestreview-1914236999
    */
-  functionName: v44.string(),
+  functionName: v46.string(),
   /**
    * @deprecated in favor of `functionArgs` for @stacks/connect compatibility
    */
-  arguments: v44.optional(v44.array(v44.string())),
+  arguments: v46.optional(v46.array(v46.string())),
   /**
    * The function's arguments. The arguments are expected to be hex-encoded
    * strings of Clarity values.
@@ -1680,274 +1721,274 @@ var stxCallContractParamsSchema = v44.object({
    * const hexArgs = functionArgs.map(cvToHex);
    * ```
    */
-  functionArgs: v44.optional(v44.array(v44.string())),
+  functionArgs: v46.optional(v46.array(v46.string())),
   /**
    * The post conditions to apply to the contract call.
    */
-  postConditions: v44.optional(v44.array(v44.string())),
+  postConditions: v46.optional(v46.array(v46.string())),
   /**
    * The mode to apply to the post conditions.
    */
-  postConditionMode: v44.optional(v44.union([v44.literal("allow"), v44.literal("deny")]))
+  postConditionMode: v46.optional(v46.union([v46.literal("allow"), v46.literal("deny")]))
 });
-var stxCallContractResultSchema = v44.object({
+var stxCallContractResultSchema = v46.object({
   /**
    * The ID of the transaction.
    */
-  txid: v44.string(),
+  txid: v46.string(),
   /**
    * A Stacks transaction as a hex-encoded string.
    */
-  transaction: v44.string()
+  transaction: v46.string()
 });
-var stxCallContractRequestMessageSchema = v44.object({
+var stxCallContractRequestMessageSchema = v46.object({
   ...rpcRequestMessageSchema.entries,
-  ...v44.object({
-    method: v44.literal(stxCallContractMethodName),
+  ...v46.object({
+    method: v46.literal(stxCallContractMethodName),
     params: stxCallContractParamsSchema,
-    id: v44.string()
+    id: v46.string()
   }).entries
 });
 
 // src/request/types/stxMethods/deployContract.ts
-var v45 = __toESM(require("valibot"));
+var v47 = __toESM(require("valibot"));
 var stxDeployContractMethodName = "stx_deployContract";
-var stxDeployContractParamsSchema = v45.object({
+var stxDeployContractParamsSchema = v47.object({
   /**
    * Name of the contract.
    */
-  name: v45.string(),
+  name: v47.string(),
   /**
    * The source code of the Clarity contract.
    */
-  clarityCode: v45.string(),
+  clarityCode: v47.string(),
   /**
    * The version of the Clarity contract.
    */
-  clarityVersion: v45.optional(v45.number()),
+  clarityVersion: v47.optional(v47.number()),
   /**
    * The post conditions to apply to the contract call.
    */
-  postConditions: v45.optional(v45.array(v45.string())),
+  postConditions: v47.optional(v47.array(v47.string())),
   /**
    * The mode to apply to the post conditions.
    */
-  postConditionMode: v45.optional(v45.union([v45.literal("allow"), v45.literal("deny")]))
+  postConditionMode: v47.optional(v47.union([v47.literal("allow"), v47.literal("deny")]))
 });
-var stxDeployContractResultSchema = v45.object({
+var stxDeployContractResultSchema = v47.object({
   /**
    * The ID of the transaction.
    */
-  txid: v45.string(),
+  txid: v47.string(),
   /**
    * A Stacks transaction as a hex-encoded string.
    */
-  transaction: v45.string()
+  transaction: v47.string()
 });
-var stxDeployContractRequestMessageSchema = v45.object({
+var stxDeployContractRequestMessageSchema = v47.object({
   ...rpcRequestMessageSchema.entries,
-  ...v45.object({
-    method: v45.literal(stxDeployContractMethodName),
+  ...v47.object({
+    method: v47.literal(stxDeployContractMethodName),
     params: stxDeployContractParamsSchema,
-    id: v45.string()
+    id: v47.string()
   }).entries
 });
 
 // src/request/types/stxMethods/getAccounts.ts
-var v46 = __toESM(require("valibot"));
+var v48 = __toESM(require("valibot"));
 var stxGetAccountsMethodName = "stx_getAccounts";
-var stxGetAccountsParamsSchema = v46.nullish(v46.null());
-var stxGetAccountsResultSchema = v46.object({
+var stxGetAccountsParamsSchema = v48.nullish(v48.null());
+var stxGetAccountsResultSchema = v48.object({
   /**
    * The addresses generated for the given purposes.
    */
-  addresses: v46.array(
-    v46.object({
-      address: v46.string(),
-      publicKey: v46.string(),
-      gaiaHubUrl: v46.string(),
-      gaiaAppKey: v46.string()
+  addresses: v48.array(
+    v48.object({
+      address: v48.string(),
+      publicKey: v48.string(),
+      gaiaHubUrl: v48.string(),
+      gaiaAppKey: v48.string()
     })
   ),
   network: getNetworkResultSchema
 });
-var stxGetAccountsRequestMessageSchema = v46.object({
+var stxGetAccountsRequestMessageSchema = v48.object({
   ...rpcRequestMessageSchema.entries,
-  ...v46.object({
-    method: v46.literal(stxGetAccountsMethodName),
+  ...v48.object({
+    method: v48.literal(stxGetAccountsMethodName),
     params: stxGetAccountsParamsSchema,
-    id: v46.string()
+    id: v48.string()
   }).entries
 });
 
 // src/request/types/stxMethods/getAddresses.ts
-var v47 = __toESM(require("valibot"));
+var v49 = __toESM(require("valibot"));
 var stxGetAddressesMethodName = "stx_getAddresses";
-var stxGetAddressesParamsSchema = v47.nullish(
-  v47.object({
+var stxGetAddressesParamsSchema = v49.nullish(
+  v49.object({
     /**
      * A message to be displayed to the user in the request prompt.
      */
-    message: v47.optional(v47.string())
+    message: v49.optional(v49.string())
   })
 );
-var stxGetAddressesResultSchema = v47.object({
+var stxGetAddressesResultSchema = v49.object({
   /**
    * The addresses generated for the given purposes.
    */
-  addresses: v47.array(addressSchema),
+  addresses: v49.array(addressSchema),
   network: getNetworkResultSchema
 });
-var stxGetAddressesRequestMessageSchema = v47.object({
+var stxGetAddressesRequestMessageSchema = v49.object({
   ...rpcRequestMessageSchema.entries,
-  ...v47.object({
-    method: v47.literal(stxGetAddressesMethodName),
+  ...v49.object({
+    method: v49.literal(stxGetAddressesMethodName),
     params: stxGetAddressesParamsSchema,
-    id: v47.string()
+    id: v49.string()
   }).entries
 });
 
 // src/request/types/stxMethods/signMessage.ts
-var v48 = __toESM(require("valibot"));
+var v50 = __toESM(require("valibot"));
 var stxSignMessageMethodName = "stx_signMessage";
-var stxSignMessageParamsSchema = v48.object({
+var stxSignMessageParamsSchema = v50.object({
   /**
    * The message to sign.
    */
-  message: v48.string()
+  message: v50.string()
 });
-var stxSignMessageResultSchema = v48.object({
+var stxSignMessageResultSchema = v50.object({
   /**
    * The signature of the message.
    */
-  signature: v48.string(),
+  signature: v50.string(),
   /**
    * The public key used to sign the message.
    */
-  publicKey: v48.string()
+  publicKey: v50.string()
 });
-var stxSignMessageRequestMessageSchema = v48.object({
+var stxSignMessageRequestMessageSchema = v50.object({
   ...rpcRequestMessageSchema.entries,
-  ...v48.object({
-    method: v48.literal(stxSignMessageMethodName),
+  ...v50.object({
+    method: v50.literal(stxSignMessageMethodName),
     params: stxSignMessageParamsSchema,
-    id: v48.string()
+    id: v50.string()
   }).entries
 });
 
 // src/request/types/stxMethods/signStructuredMessage.ts
-var v49 = __toESM(require("valibot"));
+var v51 = __toESM(require("valibot"));
 var stxSignStructuredMessageMethodName = "stx_signStructuredMessage";
-var stxSignStructuredMessageParamsSchema = v49.object({
+var stxSignStructuredMessageParamsSchema = v51.object({
   /**
    * The domain to be signed.
    */
-  domain: v49.string(),
+  domain: v51.string(),
   /**
    * Message payload to be signed.
    */
-  message: v49.string(),
+  message: v51.string(),
   /**
    * The public key to sign the message with.
    */
-  publicKey: v49.optional(v49.string())
+  publicKey: v51.optional(v51.string())
 });
-var stxSignStructuredMessageResultSchema = v49.object({
+var stxSignStructuredMessageResultSchema = v51.object({
   /**
    * Signature of the message.
    */
-  signature: v49.string(),
+  signature: v51.string(),
   /**
    * Public key as hex-encoded string.
    */
-  publicKey: v49.string()
+  publicKey: v51.string()
 });
-var stxSignStructuredMessageRequestMessageSchema = v49.object({
+var stxSignStructuredMessageRequestMessageSchema = v51.object({
   ...rpcRequestMessageSchema.entries,
-  ...v49.object({
-    method: v49.literal(stxSignStructuredMessageMethodName),
+  ...v51.object({
+    method: v51.literal(stxSignStructuredMessageMethodName),
     params: stxSignStructuredMessageParamsSchema,
-    id: v49.string()
+    id: v51.string()
   }).entries
 });
 
 // src/request/types/stxMethods/signTransaction.ts
-var v50 = __toESM(require("valibot"));
+var v52 = __toESM(require("valibot"));
 var stxSignTransactionMethodName = "stx_signTransaction";
-var stxSignTransactionParamsSchema = v50.object({
+var stxSignTransactionParamsSchema = v52.object({
   /**
    * The transaction to sign as a hex-encoded string.
    */
-  transaction: v50.string(),
+  transaction: v52.string(),
   /**
    * The public key to sign the transaction with. The wallet may use any key
    * when not provided.
    */
-  pubkey: v50.optional(v50.string()),
+  pubkey: v52.optional(v52.string()),
   /**
    * Whether to broadcast the transaction after signing. Defaults to `true`.
    */
-  broadcast: v50.optional(v50.boolean())
+  broadcast: v52.optional(v52.boolean())
 });
-var stxSignTransactionResultSchema = v50.object({
+var stxSignTransactionResultSchema = v52.object({
   /**
    * The signed transaction as a hex-encoded string.
    */
-  transaction: v50.string()
+  transaction: v52.string()
 });
-var stxSignTransactionRequestMessageSchema = v50.object({
+var stxSignTransactionRequestMessageSchema = v52.object({
   ...rpcRequestMessageSchema.entries,
-  ...v50.object({
-    method: v50.literal(stxSignTransactionMethodName),
+  ...v52.object({
+    method: v52.literal(stxSignTransactionMethodName),
     params: stxSignTransactionParamsSchema,
-    id: v50.string()
+    id: v52.string()
   }).entries
 });
 
 // src/request/types/stxMethods/signTransactions.ts
-var v51 = __toESM(require("valibot"));
+var v53 = __toESM(require("valibot"));
 var stxSignTransactionsMethodName = "stx_signTransactions";
-var stxSignTransactionsParamsSchema = v51.object({
+var stxSignTransactionsParamsSchema = v53.object({
   /**
    * The transactions to sign as hex-encoded strings.
    */
-  transactions: v51.pipe(
-    v51.array(
-      v51.pipe(
-        v51.string(),
-        v51.check((hex) => {
+  transactions: v53.pipe(
+    v53.array(
+      v53.pipe(
+        v53.string(),
+        v53.check((hex) => {
           return true;
         }, "Invalid hex-encoded Stacks transaction.")
       )
     ),
-    v51.minLength(1)
+    v53.minLength(1)
   ),
   /**
    * Whether the signed transactions should be broadcast after signing. Defaults
    * to `true`.
    */
-  broadcast: v51.optional(v51.boolean())
+  broadcast: v53.optional(v53.boolean())
 });
-var stxSignTransactionsResultSchema = v51.object({
+var stxSignTransactionsResultSchema = v53.object({
   /**
    * The signed transactions as hex-encoded strings, in the same order as in the
    * sign request.
    */
-  transactions: v51.array(v51.string())
+  transactions: v53.array(v53.string())
 });
-var stxSignTransactionsRequestMessageSchema = v51.object({
+var stxSignTransactionsRequestMessageSchema = v53.object({
   ...rpcRequestMessageSchema.entries,
-  ...v51.object({
-    method: v51.literal(stxSignTransactionsMethodName),
+  ...v53.object({
+    method: v53.literal(stxSignTransactionsMethodName),
     params: stxSignTransactionsParamsSchema,
-    id: v51.string()
+    id: v53.string()
   }).entries
 });
 
 // src/request/types/stxMethods/transferStx.ts
-var v52 = __toESM(require("valibot"));
+var v54 = __toESM(require("valibot"));
 var stxTransferStxMethodName = "stx_transferStx";
-var stxTransferStxParamsSchema = v52.object({
+var stxTransferStxParamsSchema = v54.object({
   /**
    * Amount of STX tokens to transfer in microstacks as a string. Anything
    * parseable by `BigInt` is acceptable.
@@ -1960,23 +2001,23 @@ var stxTransferStxParamsSchema = v52.object({
    * const amount3 = '1234';
    * ```
    */
-  amount: v52.union([v52.number(), v52.string()]),
+  amount: v54.union([v54.number(), v54.string()]),
   /**
    * The recipient's principal.
    */
-  recipient: v52.string(),
+  recipient: v54.string(),
   /**
    * A string representing the memo.
    */
-  memo: v52.optional(v52.string()),
+  memo: v54.optional(v54.string()),
   /**
    * Version of parameter format.
    */
-  version: v52.optional(v52.string()),
+  version: v54.optional(v54.string()),
   /**
    * The mode of the post conditions.
    */
-  postConditionMode: v52.optional(v52.number()),
+  postConditionMode: v54.optional(v54.number()),
   /**
    * A hex-encoded string representing the post conditions.
    *
@@ -1989,29 +2030,29 @@ var stxTransferStxParamsSchema = v52.object({
    * const hexPostCondition = serializePostCondition(postCondition).toString('hex');
    * ```
    */
-  postConditions: v52.optional(v52.array(v52.string())),
+  postConditions: v54.optional(v54.array(v54.string())),
   /**
    * The public key to sign the transaction with. The wallet may use any key
    * when not provided.
    */
-  pubkey: v52.optional(v52.string())
+  pubkey: v54.optional(v54.string())
 });
-var stxTransferStxResultSchema = v52.object({
+var stxTransferStxResultSchema = v54.object({
   /**
    * The ID of the transaction.
    */
-  txid: v52.string(),
+  txid: v54.string(),
   /**
    * A Stacks transaction as a hex-encoded string.
    */
-  transaction: v52.string()
+  transaction: v54.string()
 });
-var stxTransferStxRequestMessageSchema = v52.object({
+var stxTransferStxRequestMessageSchema = v54.object({
   ...rpcRequestMessageSchema.entries,
-  ...v52.object({
-    method: v52.literal(stxTransferStxMethodName),
+  ...v54.object({
+    method: v54.literal(stxTransferStxMethodName),
     params: stxTransferStxParamsSchema,
-    id: v52.string()
+    id: v54.string()
   }).entries
 });
 
@@ -2019,13 +2060,13 @@ var stxTransferStxRequestMessageSchema = v52.object({
 var cache = {};
 var requestInternal = async (provider, method, params) => {
   const response = await provider.request(method, params);
-  if (v53.is(rpcErrorResponseMessageSchema, response)) {
+  if (v55.is(rpcErrorResponseMessageSchema, response)) {
     return {
       status: "error",
       error: response.error
     };
   }
-  if (v53.is(rpcSuccessResponseMessageSchema, response)) {
+  if (v55.is(rpcSuccessResponseMessageSchema, response)) {
     return {
       status: "success",
       result: response.result
@@ -3162,6 +3203,14 @@ var signMultipleTransactions = async (options) => {
   isProviderInstalled,
   networkChangeEventName,
   networkChangeSchema,
+  openBridgeMethodName,
+  openBridgeParamsSchema,
+  openBridgeRequestMessageSchema,
+  openBridgeResultSchema,
+  openBuyMethodName,
+  openBuyParamsSchema,
+  openBuyRequestMessageSchema,
+  openBuyResultSchema,
   openReceiveMethodName,
   openReceiveParamsSchema,
   openReceiveRequestMessageSchema,