@sats-connect/core 0.14.1 → 0.16.0-2dd02aa

package/dist/index.mjs

@@ -1,5 +1,5 @@
 // src/request/index.ts
-import * as v41 from "valibot";
+import * as v48 from "valibot";
 
 // src/provider/types.ts
 import * as v4 from "valibot";
@@ -242,889 +242,961 @@ var sanitizeAddressPurposeRequest = (method, params) => {
   return { method, params };
 };
 
-// src/request/types/btcMethods.ts
-import * as v6 from "valibot";
+// src/request/types/btcMethods/common.ts
+var MessageSigningProtocols = /* @__PURE__ */ ((MessageSigningProtocols2) => {
+  MessageSigningProtocols2["ECDSA"] = "ECDSA";
+  MessageSigningProtocols2["BIP322"] = "BIP322";
+  return MessageSigningProtocols2;
+})(MessageSigningProtocols || {});
 
-// src/request/types/walletMethods.ts
+// src/request/types/btcMethods/getAccounts.ts
 import * as v5 from "valibot";
-var accountActionsSchema = v5.object({
-  read: v5.optional(v5.boolean())
+var getAccountsMethodName = "getAccounts";
+var getAccountsParamsSchema = v5.object({
+  /**
+   * The purposes for which to generate addresses. See
+   * {@linkcode AddressPurpose} for available purposes.
+   */
+  purposes: v5.array(v5.enum(AddressPurpose)),
+  /**
+   * A message to be displayed to the user in the request prompt.
+   */
+  message: v5.optional(v5.string())
 });
-var walletActionsSchema = v5.object({
-  readNetwork: v5.optional(v5.boolean())
+var getAccountsResultSchema = v5.array(
+  v5.object({
+    ...addressSchema.entries,
+    ...v5.object({
+      walletType: walletTypeSchema
+    }).entries
+  })
+);
+var getAccountsRequestMessageSchema = v5.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v5.object({
+    method: v5.literal(getAccountsMethodName),
+    params: getAccountsParamsSchema,
+    id: v5.string()
+  }).entries
+});
+
+// src/request/types/btcMethods/getAddresses.ts
+import * as v7 from "valibot";
+
+// src/request/types/walletMethods.ts
+import * as v6 from "valibot";
+var accountActionsSchema = v6.object({
+  read: v6.optional(v6.boolean())
 });
-var accountPermissionSchema = v5.object({
-  type: v5.literal("account"),
-  resourceId: v5.string(),
-  clientId: v5.string(),
+var walletActionsSchema = v6.object({
+  readNetwork: v6.optional(v6.boolean())
+});
+var accountPermissionSchema = v6.object({
+  type: v6.literal("account"),
+  resourceId: v6.string(),
+  clientId: v6.string(),
   actions: accountActionsSchema
 });
-var walletPermissionSchema = v5.object({
-  type: v5.literal("wallet"),
-  resourceId: v5.string(),
-  clientId: v5.string(),
+var walletPermissionSchema = v6.object({
+  type: v6.literal("wallet"),
+  resourceId: v6.string(),
+  clientId: v6.string(),
   actions: walletActionsSchema
 });
-var PermissionRequestParams = v5.variant("type", [
-  v5.object({
-    ...v5.omit(accountPermissionSchema, ["clientId"]).entries
+var PermissionRequestParams = v6.variant("type", [
+  v6.object({
+    ...v6.omit(accountPermissionSchema, ["clientId"]).entries
   }),
-  v5.object({
-    ...v5.omit(walletPermissionSchema, ["clientId"]).entries
+  v6.object({
+    ...v6.omit(walletPermissionSchema, ["clientId"]).entries
   })
 ]);
-var permission = v5.variant("type", [accountPermissionSchema, walletPermissionSchema]);
+var permission = v6.variant("type", [accountPermissionSchema, walletPermissionSchema]);
 var requestPermissionsMethodName = "wallet_requestPermissions";
-var requestPermissionsParamsSchema = v5.nullish(v5.array(PermissionRequestParams));
-var requestPermissionsResultSchema = v5.literal(true);
-var requestPermissionsRequestMessageSchema = v5.object({
+var requestPermissionsParamsSchema = v6.nullish(v6.array(PermissionRequestParams));
+var requestPermissionsResultSchema = v6.literal(true);
+var requestPermissionsRequestMessageSchema = v6.object({
   ...rpcRequestMessageSchema.entries,
-  ...v5.object({
-    method: v5.literal(requestPermissionsMethodName),
+  ...v6.object({
+    method: v6.literal(requestPermissionsMethodName),
     params: requestPermissionsParamsSchema,
-    id: v5.string()
+    id: v6.string()
   }).entries
 });
 var renouncePermissionsMethodName = "wallet_renouncePermissions";
-var renouncePermissionsParamsSchema = v5.nullish(v5.null());
-var renouncePermissionsResultSchema = v5.nullish(v5.null());
-var renouncePermissionsRequestMessageSchema = v5.object({
+var renouncePermissionsParamsSchema = v6.nullish(v6.null());
+var renouncePermissionsResultSchema = v6.nullish(v6.null());
+var renouncePermissionsRequestMessageSchema = v6.object({
   ...rpcRequestMessageSchema.entries,
-  ...v5.object({
-    method: v5.literal(renouncePermissionsMethodName),
+  ...v6.object({
+    method: v6.literal(renouncePermissionsMethodName),
     params: renouncePermissionsParamsSchema,
-    id: v5.string()
+    id: v6.string()
   }).entries
 });
 var disconnectMethodName = "wallet_disconnect";
-var disconnectParamsSchema = v5.nullish(v5.null());
-var disconnectResultSchema = v5.nullish(v5.null());
-var disconnectRequestMessageSchema = v5.object({
+var disconnectParamsSchema = v6.nullish(v6.null());
+var disconnectResultSchema = v6.nullish(v6.null());
+var disconnectRequestMessageSchema = v6.object({
   ...rpcRequestMessageSchema.entries,
-  ...v5.object({
-    method: v5.literal(disconnectMethodName),
+  ...v6.object({
+    method: v6.literal(disconnectMethodName),
     params: disconnectParamsSchema,
-    id: v5.string()
+    id: v6.string()
   }).entries
 });
 var getWalletTypeMethodName = "wallet_getWalletType";
-var getWalletTypeParamsSchema = v5.nullish(v5.null());
+var getWalletTypeParamsSchema = v6.nullish(v6.null());
 var getWalletTypeResultSchema = walletTypeSchema;
-var getWalletTypeRequestMessageSchema = v5.object({
+var getWalletTypeRequestMessageSchema = v6.object({
   ...rpcRequestMessageSchema.entries,
-  ...v5.object({
-    method: v5.literal(getWalletTypeMethodName),
+  ...v6.object({
+    method: v6.literal(getWalletTypeMethodName),
     params: getWalletTypeParamsSchema,
-    id: v5.string()
+    id: v6.string()
   }).entries
 });
 var getCurrentPermissionsMethodName = "wallet_getCurrentPermissions";
-var getCurrentPermissionsParamsSchema = v5.nullish(v5.null());
-var getCurrentPermissionsResultSchema = v5.array(permission);
-var getCurrentPermissionsRequestMessageSchema = v5.object({
+var getCurrentPermissionsParamsSchema = v6.nullish(v6.null());
+var getCurrentPermissionsResultSchema = v6.array(permission);
+var getCurrentPermissionsRequestMessageSchema = v6.object({
   ...rpcRequestMessageSchema.entries,
-  ...v5.object({
-    method: v5.literal(getCurrentPermissionsMethodName),
+  ...v6.object({
+    method: v6.literal(getCurrentPermissionsMethodName),
     params: getCurrentPermissionsParamsSchema,
-    id: v5.string()
+    id: v6.string()
   }).entries
 });
 var getNetworkMethodName = "wallet_getNetwork";
-var getNetworkParamsSchema = v5.nullish(v5.null());
-var getNetworkResultSchema = v5.object({
-  bitcoin: v5.object({
-    name: v5.enum(BitcoinNetworkType)
+var getNetworkParamsSchema = v6.nullish(v6.null());
+var getNetworkResultSchema = v6.object({
+  bitcoin: v6.object({
+    name: v6.enum(BitcoinNetworkType)
   }),
-  stacks: v5.object({
-    name: v5.enum(StacksNetworkType)
+  stacks: v6.object({
+    name: v6.enum(StacksNetworkType)
   }),
-  spark: v5.object({
-    name: v5.enum(SparkNetworkType)
+  spark: v6.object({
+    name: v6.enum(SparkNetworkType)
   })
 });
-var getNetworkRequestMessageSchema = v5.object({
+var getNetworkRequestMessageSchema = v6.object({
   ...rpcRequestMessageSchema.entries,
-  ...v5.object({
-    method: v5.literal(getNetworkMethodName),
+  ...v6.object({
+    method: v6.literal(getNetworkMethodName),
     params: getNetworkParamsSchema,
-    id: v5.string()
+    id: v6.string()
   }).entries
 });
 var changeNetworkMethodName = "wallet_changeNetwork";
-var changeNetworkParamsSchema = v5.object({
-  name: v5.enum(BitcoinNetworkType)
+var changeNetworkParamsSchema = v6.object({
+  name: v6.enum(BitcoinNetworkType)
 });
-var changeNetworkResultSchema = v5.nullish(v5.null());
-var changeNetworkRequestMessageSchema = v5.object({
+var changeNetworkResultSchema = v6.nullish(v6.null());
+var changeNetworkRequestMessageSchema = v6.object({
   ...rpcRequestMessageSchema.entries,
-  ...v5.object({
-    method: v5.literal(changeNetworkMethodName),
+  ...v6.object({
+    method: v6.literal(changeNetworkMethodName),
     params: changeNetworkParamsSchema,
-    id: v5.string()
+    id: v6.string()
   }).entries
 });
 var changeNetworkByIdMethodName = "wallet_changeNetworkById";
-var changeNetworkByIdParamsSchema = v5.object({
-  id: v5.string()
+var changeNetworkByIdParamsSchema = v6.object({
+  id: v6.string()
 });
-var changeNetworkByIdResultSchema = v5.nullish(v5.null());
-var changeNetworkByIdRequestMessageSchema = v5.object({
+var changeNetworkByIdResultSchema = v6.nullish(v6.null());
+var changeNetworkByIdRequestMessageSchema = v6.object({
   ...rpcRequestMessageSchema.entries,
-  ...v5.object({
-    method: v5.literal(changeNetworkByIdMethodName),
+  ...v6.object({
+    method: v6.literal(changeNetworkByIdMethodName),
     params: changeNetworkByIdParamsSchema,
-    id: v5.string()
+    id: v6.string()
   }).entries
 });
 var getAccountMethodName = "wallet_getAccount";
-var getAccountParamsSchema = v5.nullish(v5.null());
-var getAccountResultSchema = v5.object({
-  id: v5.string(),
-  addresses: v5.array(addressSchema),
+var getAccountParamsSchema = v6.nullish(v6.null());
+var getAccountResultSchema = v6.object({
+  id: v6.string(),
+  addresses: v6.array(addressSchema),
   walletType: walletTypeSchema,
   network: getNetworkResultSchema
 });
-var getAccountRequestMessageSchema = v5.object({
+var getAccountRequestMessageSchema = v6.object({
   ...rpcRequestMessageSchema.entries,
-  ...v5.object({
-    method: v5.literal(getAccountMethodName),
+  ...v6.object({
+    method: v6.literal(getAccountMethodName),
     params: getAccountParamsSchema,
-    id: v5.string()
+    id: v6.string()
   }).entries
 });
 var connectMethodName = "wallet_connect";
-var connectParamsSchema = v5.nullish(
-  v5.object({
-    permissions: v5.optional(v5.array(PermissionRequestParams)),
-    addresses: v5.optional(v5.array(v5.enum(AddressPurpose))),
-    message: v5.optional(
-      v5.pipe(v5.string(), v5.maxLength(80, "The message must not exceed 80 characters."))
+var connectParamsSchema = v6.nullish(
+  v6.object({
+    permissions: v6.optional(v6.array(PermissionRequestParams)),
+    addresses: v6.optional(v6.array(v6.enum(AddressPurpose))),
+    message: v6.optional(
+      v6.pipe(v6.string(), v6.maxLength(80, "The message must not exceed 80 characters."))
     ),
-    network: v5.optional(v5.enum(BitcoinNetworkType))
+    network: v6.optional(v6.enum(BitcoinNetworkType))
   })
 );
-var connectResultSchema = v5.object({
-  id: v5.string(),
-  addresses: v5.array(addressSchema),
+var connectResultSchema = v6.object({
+  id: v6.string(),
+  addresses: v6.array(addressSchema),
   walletType: walletTypeSchema,
   network: getNetworkResultSchema
 });
-var connectRequestMessageSchema = v5.object({
+var connectRequestMessageSchema = v6.object({
   ...rpcRequestMessageSchema.entries,
-  ...v5.object({
-    method: v5.literal(connectMethodName),
+  ...v6.object({
+    method: v6.literal(connectMethodName),
     params: connectParamsSchema,
-    id: v5.string()
+    id: v6.string()
   }).entries
 });
 var addNetworkMethodName = "wallet_addNetwork";
-var addNetworkParamsSchema = v5.variant("chain", [
-  v5.object({
-    chain: v5.literal("bitcoin"),
-    type: v5.enum(BitcoinNetworkType),
-    name: v5.string(),
-    rpcUrl: v5.string(),
-    rpcFallbackUrl: v5.optional(v5.string()),
-    indexerUrl: v5.optional(v5.string()),
-    blockExplorerUrl: v5.optional(v5.string()),
-    switch: v5.optional(v5.boolean())
+var addNetworkParamsSchema = v6.variant("chain", [
+  v6.object({
+    chain: v6.literal("bitcoin"),
+    type: v6.enum(BitcoinNetworkType),
+    name: v6.string(),
+    rpcUrl: v6.string(),
+    rpcFallbackUrl: v6.optional(v6.string()),
+    indexerUrl: v6.optional(v6.string()),
+    blockExplorerUrl: v6.optional(v6.string()),
+    switch: v6.optional(v6.boolean())
   }),
-  v5.object({
-    chain: v5.literal("stacks"),
-    name: v5.string(),
-    type: v5.enum(StacksNetworkType),
-    rpcUrl: v5.string(),
-    blockExplorerUrl: v5.optional(v5.string()),
-    switch: v5.optional(v5.boolean())
+  v6.object({
+    chain: v6.literal("stacks"),
+    name: v6.string(),
+    type: v6.enum(StacksNetworkType),
+    rpcUrl: v6.string(),
+    blockExplorerUrl: v6.optional(v6.string()),
+    switch: v6.optional(v6.boolean())
   }),
-  v5.object({
-    chain: v5.literal("starknet"),
-    name: v5.string(),
-    type: v5.enum(StarknetNetworkType),
-    rpcUrl: v5.string(),
-    blockExplorerUrl: v5.optional(v5.string()),
-    switch: v5.optional(v5.boolean())
+  v6.object({
+    chain: v6.literal("starknet"),
+    name: v6.string(),
+    type: v6.enum(StarknetNetworkType),
+    rpcUrl: v6.string(),
+    blockExplorerUrl: v6.optional(v6.string()),
+    switch: v6.optional(v6.boolean())
   })
 ]);
-var addNetworkRequestMessageSchema = v5.object({
+var addNetworkRequestMessageSchema = v6.object({
   ...rpcRequestMessageSchema.entries,
-  ...v5.object({
-    method: v5.literal(addNetworkMethodName),
+  ...v6.object({
+    method: v6.literal(addNetworkMethodName),
     params: addNetworkParamsSchema,
-    id: v5.string()
+    id: v6.string()
   }).entries
 });
-var addNetworkResultSchema = v5.object({
-  id: v5.string()
+var addNetworkResultSchema = v6.object({
+  id: v6.string()
 });
 
-// src/request/types/btcMethods.ts
+// src/request/types/btcMethods/getAddresses.ts
+var getAddressesMethodName = "getAddresses";
+var getAddressesParamsSchema = v7.object({
+  /**
+   * The purposes for which to generate addresses. See
+   * {@linkcode AddressPurpose} for available purposes.
+   */
+  purposes: v7.array(v7.enum(AddressPurpose)),
+  /**
+   * A message to be displayed to the user in the request prompt.
+   */
+  message: v7.optional(v7.string())
+});
+var getAddressesResultSchema = v7.object({
+  /**
+   * The addresses generated for the given purposes.
+   */
+  addresses: v7.array(addressSchema),
+  network: getNetworkResultSchema
+});
+var getAddressesRequestMessageSchema = v7.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v7.object({
+    method: v7.literal(getAddressesMethodName),
+    params: getAddressesParamsSchema,
+    id: v7.string()
+  }).entries
+});
+
+// src/request/types/btcMethods/getBalance.ts
+import * as v8 from "valibot";
+var getBalanceMethodName = "getBalance";
+var getBalanceParamsSchema = v8.nullish(v8.null());
+var getBalanceResultSchema = v8.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: v8.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: v8.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: v8.string()
+});
+var getBalanceRequestMessageSchema = v8.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v8.object({
+    method: v8.literal(getBalanceMethodName),
+    id: v8.string()
+  }).entries
+});
+
+// src/request/types/btcMethods/getInfo.ts
+import * as v9 from "valibot";
 var ProviderPlatform = /* @__PURE__ */ ((ProviderPlatform2) => {
   ProviderPlatform2["Web"] = "web";
   ProviderPlatform2["Mobile"] = "mobile";
   return ProviderPlatform2;
 })(ProviderPlatform || {});
 var getInfoMethodName = "getInfo";
-var getInfoParamsSchema = v6.nullish(v6.null());
-var getInfoResultSchema = v6.object({
+var getInfoParamsSchema = v9.nullish(v9.null());
+var getInfoResultSchema = v9.object({
   /**
    * Version of the wallet.
    */
-  version: v6.string(),
+  version: v9.string(),
   /**
    * The platform the wallet is running on (web or mobile).
    */
-  platform: v6.optional(v6.enum(ProviderPlatform)),
+  platform: v9.optional(v9.enum(ProviderPlatform)),
   /**
    * [WBIP](https://wbips.netlify.app/wbips/WBIP002) methods supported by the wallet.
    */
-  methods: v6.optional(v6.array(v6.string())),
+  methods: v9.optional(v9.array(v9.string())),
   /**
    * List of WBIP standards supported by the wallet. Not currently used.
    */
-  supports: v6.array(v6.string())
+  supports: v9.array(v9.string())
 });
-var getInfoRequestMessageSchema = v6.object({
+var getInfoRequestMessageSchema = v9.object({
   ...rpcRequestMessageSchema.entries,
-  ...v6.object({
-    method: v6.literal(getInfoMethodName),
+  ...v9.object({
+    method: v9.literal(getInfoMethodName),
     params: getInfoParamsSchema,
-    id: v6.string()
+    id: v9.string()
   }).entries
 });
-var getAddressesMethodName = "getAddresses";
-var getAddressesParamsSchema = v6.object({
-  /**
-   * The purposes for which to generate addresses. See
-   * {@linkcode AddressPurpose} for available purposes.
-   */
-  purposes: v6.array(v6.enum(AddressPurpose)),
+
+// src/request/types/btcMethods/sendTransfer.ts
+import * as v10 from "valibot";
+var sendTransferMethodName = "sendTransfer";
+var sendTransferParamsSchema = v10.object({
   /**
-   * A message to be displayed to the user in the request prompt.
+   * Array of recipients to send to.
+   * The amount to send to each recipient is in satoshis.
    */
-  message: v6.optional(v6.string())
+  recipients: v10.array(
+    v10.object({
+      address: v10.string(),
+      amount: v10.number()
+    })
+  )
 });
-var getAddressesResultSchema = v6.object({
+var sendTransferResultSchema = v10.object({
   /**
-   * The addresses generated for the given purposes.
+   * The transaction id as a hex-encoded string.
    */
-  addresses: v6.array(addressSchema),
-  network: getNetworkResultSchema
+  txid: v10.string()
 });
-var getAddressesRequestMessageSchema = v6.object({
+var sendTransferRequestMessageSchema = v10.object({
   ...rpcRequestMessageSchema.entries,
-  ...v6.object({
-    method: v6.literal(getAddressesMethodName),
-    params: getAddressesParamsSchema,
-    id: v6.string()
+  ...v10.object({
+    method: v10.literal(sendTransferMethodName),
+    params: sendTransferParamsSchema,
+    id: v10.string()
   }).entries
 });
+
+// src/request/types/btcMethods/signMessage.ts
+import * as v11 from "valibot";
 var signMessageMethodName = "signMessage";
-var MessageSigningProtocols = /* @__PURE__ */ ((MessageSigningProtocols2) => {
-  MessageSigningProtocols2["ECDSA"] = "ECDSA";
-  MessageSigningProtocols2["BIP322"] = "BIP322";
-  return MessageSigningProtocols2;
-})(MessageSigningProtocols || {});
-var signMessageParamsSchema = v6.object({
+var signMessageParamsSchema = v11.object({
   /**
    * The address used for signing.
    **/
-  address: v6.string(),
+  address: v11.string(),
   /**
    * The message to sign.
    **/
-  message: v6.string(),
+  message: v11.string(),
   /**
    * The protocol to use for signing the message.
    */
-  protocol: v6.optional(v6.enum(MessageSigningProtocols))
+  protocol: v11.optional(v11.enum(MessageSigningProtocols))
 });
-var signMessageResultSchema = v6.object({
+var signMessageResultSchema = v11.object({
   /**
    * The signature of the message.
    */
-  signature: v6.string(),
+  signature: v11.string(),
   /**
    * hash of the message.
    */
-  messageHash: v6.string(),
+  messageHash: v11.string(),
   /**
    * The address used for signing.
    */
-  address: v6.string(),
+  address: v11.string(),
   /**
    * The protocol to use for signing the message.
    */
-  protocol: v6.enum(MessageSigningProtocols)
+  protocol: v11.enum(MessageSigningProtocols)
 });
-var signMessageRequestMessageSchema = v6.object({
+var signMessageRequestMessageSchema = v11.object({
   ...rpcRequestMessageSchema.entries,
-  ...v6.object({
-    method: v6.literal(signMessageMethodName),
+  ...v11.object({
+    method: v11.literal(signMessageMethodName),
     params: signMessageParamsSchema,
-    id: v6.string()
+    id: v11.string()
   }).entries
 });
-var sendTransferMethodName = "sendTransfer";
-var sendTransferParamsSchema = v6.object({
-  /**
-   * Array of recipients to send to.
-   * The amount to send to each recipient is in satoshis.
-   */
-  recipients: v6.array(
-    v6.object({
-      address: v6.string(),
-      amount: v6.number()
-    })
-  )
-});
-var sendTransferResultSchema = v6.object({
-  /**
-   * The transaction id as a hex-encoded string.
-   */
-  txid: v6.string()
-});
-var sendTransferRequestMessageSchema = v6.object({
+
+// src/request/types/btcMethods/signMultipleMessages.ts
+import * as v12 from "valibot";
+var signMultipleMessagesMethodName = "signMultipleMessages";
+var signMultipleMessagesParamsSchema = v12.array(
+  v12.object({
+    /**
+     * The address used for signing.
+     **/
+    address: v12.string(),
+    /**
+     * The message to sign.
+     **/
+    message: v12.string(),
+    /**
+     * The protocol to use for signing the message.
+     */
+    protocol: v12.optional(v12.enum(MessageSigningProtocols))
+  })
+);
+var signMultipleMessagesResultSchema = v12.array(
+  v12.object({
+    /**
+     * The signature of the message.
+     */
+    signature: v12.string(),
+    /**
+     * The original message which was signed.
+     */
+    message: v12.string(),
+    /**
+     * Hash of the message.
+     */
+    messageHash: v12.string(),
+    /**
+     * The address used for signing.
+     */
+    address: v12.string(),
+    /**
+     * The protocol to use for signing the message.
+     */
+    protocol: v12.enum(MessageSigningProtocols)
+  })
+);
+var signMultipleMessagesRequestMessageSchema = v12.object({
   ...rpcRequestMessageSchema.entries,
-  ...v6.object({
-    method: v6.literal(sendTransferMethodName),
-    params: sendTransferParamsSchema,
-    id: v6.string()
+  ...v12.object({
+    method: v12.literal(signMultipleMessagesMethodName),
+    params: signMultipleMessagesParamsSchema,
+    id: v12.string()
   }).entries
 });
+
+// src/request/types/btcMethods/signPSBT.ts
+import * as v13 from "valibot";
 var signPsbtMethodName = "signPsbt";
-var signPsbtParamsSchema = v6.object({
+var signPsbtParamsSchema = v13.object({
   /**
    * The base64 encoded PSBT to sign.
    */
-  psbt: v6.string(),
+  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: v6.optional(v6.record(v6.string(), v6.array(v6.number()))),
+  signInputs: v13.optional(v13.record(v13.string(), v13.array(v13.number()))),
   /**
    * Whether to broadcast the transaction after signing.
    **/
-  broadcast: v6.optional(v6.boolean())
+  broadcast: v13.optional(v13.boolean())
 });
-var signPsbtResultSchema = v6.object({
+var signPsbtResultSchema = v13.object({
   /**
    * The base64 encoded PSBT after signing.
    */
-  psbt: v6.string(),
+  psbt: v13.string(),
   /**
    * The transaction id as a hex-encoded string.
    * This is only returned if the transaction was broadcast.
    **/
-  txid: v6.optional(v6.string())
+  txid: v13.optional(v13.string())
 });
-var signPsbtRequestMessageSchema = v6.object({
+var signPsbtRequestMessageSchema = v13.object({
   ...rpcRequestMessageSchema.entries,
-  ...v6.object({
-    method: v6.literal(signPsbtMethodName),
+  ...v13.object({
+    method: v13.literal(signPsbtMethodName),
     params: signPsbtParamsSchema,
-    id: v6.string()
-  }).entries
-});
-var getAccountsMethodName = "getAccounts";
-var getAccountsParamsSchema = v6.object({
-  /**
-   * The purposes for which to generate addresses. See
-   * {@linkcode AddressPurpose} for available purposes.
-   */
-  purposes: v6.array(v6.enum(AddressPurpose)),
-  /**
-   * A message to be displayed to the user in the request prompt.
-   */
-  message: v6.optional(v6.string())
-});
-var getAccountsResultSchema = v6.array(
-  v6.object({
-    ...addressSchema.entries,
-    ...v6.object({
-      walletType: walletTypeSchema
-    }).entries
-  })
-);
-var getAccountsRequestMessageSchema = v6.object({
-  ...rpcRequestMessageSchema.entries,
-  ...v6.object({
-    method: v6.literal(getAccountsMethodName),
-    params: getAccountsParamsSchema,
-    id: v6.string()
-  }).entries
-});
-var getBalanceMethodName = "getBalance";
-var getBalanceParamsSchema = v6.nullish(v6.null());
-var getBalanceResultSchema = v6.object({
-  /**
-   * The confirmed balance of the wallet in sats. Using a string due to chrome
-   * messages not supporting bigint
-   * (https://issues.chromium.org/issues/40116184).
-   */
-  confirmed: v6.string(),
-  /**
-   * The unconfirmed balance of the wallet in sats. Using a string due to chrome
-   * messages not supporting bigint
-   * (https://issues.chromium.org/issues/40116184).
-   */
-  unconfirmed: v6.string(),
-  /**
-   * The total balance (both confirmed and unconfrimed UTXOs) of the wallet in
-   * sats. Using a string due to chrome messages not supporting bigint
-   * (https://issues.chromium.org/issues/40116184).
-   */
-  total: v6.string()
-});
-var getBalanceRequestMessageSchema = v6.object({
-  ...rpcRequestMessageSchema.entries,
-  ...v6.object({
-    method: v6.literal(getBalanceMethodName),
-    id: v6.string()
+    id: v13.string()
   }).entries
 });
 
 // src/request/types/ordinalsMethods.ts
-import * as v7 from "valibot";
+import * as v14 from "valibot";
 var getInscriptionsMethodName = "ord_getInscriptions";
-var getInscriptionsParamsSchema = v7.object({
-  offset: v7.number(),
-  limit: v7.number()
-});
-var getInscriptionsResultSchema = v7.object({
-  total: v7.number(),
-  limit: v7.number(),
-  offset: v7.number(),
-  inscriptions: v7.array(
-    v7.object({
-      inscriptionId: v7.string(),
-      inscriptionNumber: v7.string(),
-      address: v7.string(),
-      collectionName: v7.optional(v7.string()),
-      postage: v7.string(),
-      contentLength: v7.string(),
-      contentType: v7.string(),
-      timestamp: v7.number(),
-      offset: v7.number(),
-      genesisTransaction: v7.string(),
-      output: v7.string()
+var getInscriptionsParamsSchema = v14.object({
+  offset: v14.number(),
+  limit: v14.number()
+});
+var getInscriptionsResultSchema = v14.object({
+  total: v14.number(),
+  limit: v14.number(),
+  offset: v14.number(),
+  inscriptions: v14.array(
+    v14.object({
+      inscriptionId: v14.string(),
+      inscriptionNumber: v14.string(),
+      address: v14.string(),
+      collectionName: v14.optional(v14.string()),
+      postage: v14.string(),
+      contentLength: v14.string(),
+      contentType: v14.string(),
+      timestamp: v14.number(),
+      offset: v14.number(),
+      genesisTransaction: v14.string(),
+      output: v14.string()
     })
   )
 });
-var getInscriptionsRequestMessageSchema = v7.object({
+var getInscriptionsRequestMessageSchema = v14.object({
   ...rpcRequestMessageSchema.entries,
-  ...v7.object({
-    method: v7.literal(getInscriptionsMethodName),
+  ...v14.object({
+    method: v14.literal(getInscriptionsMethodName),
     params: getInscriptionsParamsSchema,
-    id: v7.string()
+    id: v14.string()
   }).entries
 });
 var sendInscriptionsMethodName = "ord_sendInscriptions";
-var sendInscriptionsParamsSchema = v7.object({
-  transfers: v7.array(
-    v7.object({
-      address: v7.string(),
-      inscriptionId: v7.string()
+var sendInscriptionsParamsSchema = v14.object({
+  transfers: v14.array(
+    v14.object({
+      address: v14.string(),
+      inscriptionId: v14.string()
     })
   )
 });
-var sendInscriptionsResultSchema = v7.object({
-  txid: v7.string()
+var sendInscriptionsResultSchema = v14.object({
+  txid: v14.string()
 });
-var sendInscriptionsRequestMessageSchema = v7.object({
+var sendInscriptionsRequestMessageSchema = v14.object({
   ...rpcRequestMessageSchema.entries,
-  ...v7.object({
-    method: v7.literal(sendInscriptionsMethodName),
+  ...v14.object({
+    method: v14.literal(sendInscriptionsMethodName),
     params: sendInscriptionsParamsSchema,
-    id: v7.string()
+    id: v14.string()
   }).entries
 });
 
 // src/request/types/runesMethods/etch.ts
-import * as v8 from "valibot";
+import * as v15 from "valibot";
 var runesEtchMethodName = "runes_etch";
-var etchTermsSchema = v8.object({
-  amount: v8.string(),
-  cap: v8.string(),
-  heightStart: v8.optional(v8.string()),
-  heightEnd: v8.optional(v8.string()),
-  offsetStart: v8.optional(v8.string()),
-  offsetEnd: v8.optional(v8.string())
-});
-var inscriptionDetailsSchema = v8.object({
-  contentType: v8.string(),
-  contentBase64: v8.string()
-});
-var runesEtchParamsSchema = v8.object({
-  runeName: v8.string(),
-  divisibility: v8.optional(v8.number()),
-  symbol: v8.optional(v8.string()),
-  premine: v8.optional(v8.string()),
-  isMintable: v8.boolean(),
-  delegateInscriptionId: v8.optional(v8.string()),
-  destinationAddress: v8.string(),
-  refundAddress: v8.string(),
-  feeRate: v8.number(),
-  appServiceFee: v8.optional(v8.number()),
-  appServiceFeeAddress: v8.optional(v8.string()),
-  terms: v8.optional(etchTermsSchema),
-  inscriptionDetails: v8.optional(inscriptionDetailsSchema),
-  network: v8.optional(v8.enum(BitcoinNetworkType))
-});
-var runesEtchResultSchema = v8.object({
-  orderId: v8.string(),
-  fundTransactionId: v8.string(),
-  fundingAddress: v8.string()
-});
-var runesEtchRequestMessageSchema = v8.object({
+var etchTermsSchema = v15.object({
+  amount: v15.string(),
+  cap: v15.string(),
+  heightStart: v15.optional(v15.string()),
+  heightEnd: v15.optional(v15.string()),
+  offsetStart: v15.optional(v15.string()),
+  offsetEnd: v15.optional(v15.string())
+});
+var inscriptionDetailsSchema = v15.object({
+  contentType: v15.string(),
+  contentBase64: v15.string()
+});
+var runesEtchParamsSchema = v15.object({
+  runeName: v15.string(),
+  divisibility: v15.optional(v15.number()),
+  symbol: v15.optional(v15.string()),
+  premine: v15.optional(v15.string()),
+  isMintable: v15.boolean(),
+  delegateInscriptionId: v15.optional(v15.string()),
+  destinationAddress: v15.string(),
+  refundAddress: v15.string(),
+  feeRate: v15.number(),
+  appServiceFee: v15.optional(v15.number()),
+  appServiceFeeAddress: v15.optional(v15.string()),
+  terms: v15.optional(etchTermsSchema),
+  inscriptionDetails: v15.optional(inscriptionDetailsSchema),
+  network: v15.optional(v15.enum(BitcoinNetworkType))
+});
+var runesEtchResultSchema = v15.object({
+  orderId: v15.string(),
+  fundTransactionId: v15.string(),
+  fundingAddress: v15.string()
+});
+var runesEtchRequestMessageSchema = v15.object({
   ...rpcRequestMessageSchema.entries,
-  ...v8.object({
-    method: v8.literal(runesEtchMethodName),
+  ...v15.object({
+    method: v15.literal(runesEtchMethodName),
     params: runesEtchParamsSchema,
-    id: v8.string()
+    id: v15.string()
   }).entries
 });
 
 // src/request/types/runesMethods/getBalance.ts
-import * as v9 from "valibot";
+import * as v16 from "valibot";
 var runesGetBalanceMethodName = "runes_getBalance";
-var runesGetBalanceParamsSchema = v9.nullish(v9.null());
-var runesGetBalanceResultSchema = v9.object({
-  balances: v9.array(
-    v9.object({
-      runeName: v9.string(),
-      amount: v9.string(),
-      divisibility: v9.number(),
-      symbol: v9.string(),
-      inscriptionId: v9.nullish(v9.string()),
-      spendableBalance: v9.string()
+var runesGetBalanceParamsSchema = v16.nullish(v16.null());
+var runesGetBalanceResultSchema = v16.object({
+  balances: v16.array(
+    v16.object({
+      runeName: v16.string(),
+      amount: v16.string(),
+      divisibility: v16.number(),
+      symbol: v16.string(),
+      inscriptionId: v16.nullish(v16.string()),
+      spendableBalance: v16.string()
     })
   )
 });
-var runesGetBalanceRequestMessageSchema = v9.object({
+var runesGetBalanceRequestMessageSchema = v16.object({
   ...rpcRequestMessageSchema.entries,
-  ...v9.object({
-    method: v9.literal(runesGetBalanceMethodName),
+  ...v16.object({
+    method: v16.literal(runesGetBalanceMethodName),
     params: runesGetBalanceParamsSchema,
-    id: v9.string()
+    id: v16.string()
   }).entries
 });
 
 // src/request/types/runesMethods/mint.ts
-import * as v10 from "valibot";
+import * as v17 from "valibot";
 var runesMintMethodName = "runes_mint";
-var runesMintParamsSchema = v10.object({
-  appServiceFee: v10.optional(v10.number()),
-  appServiceFeeAddress: v10.optional(v10.string()),
-  destinationAddress: v10.string(),
-  feeRate: v10.number(),
-  refundAddress: v10.string(),
-  repeats: v10.number(),
-  runeName: v10.string(),
-  network: v10.optional(v10.enum(BitcoinNetworkType))
-});
-var runesMintResultSchema = v10.object({
-  orderId: v10.string(),
-  fundTransactionId: v10.string(),
-  fundingAddress: v10.string()
-});
-var runesMintRequestMessageSchema = v10.object({
+var runesMintParamsSchema = v17.object({
+  appServiceFee: v17.optional(v17.number()),
+  appServiceFeeAddress: v17.optional(v17.string()),
+  destinationAddress: v17.string(),
+  feeRate: v17.number(),
+  refundAddress: v17.string(),
+  repeats: v17.number(),
+  runeName: v17.string(),
+  network: v17.optional(v17.enum(BitcoinNetworkType))
+});
+var runesMintResultSchema = v17.object({
+  orderId: v17.string(),
+  fundTransactionId: v17.string(),
+  fundingAddress: v17.string()
+});
+var runesMintRequestMessageSchema = v17.object({
   ...rpcRequestMessageSchema.entries,
-  ...v10.object({
-    method: v10.literal(runesMintMethodName),
+  ...v17.object({
+    method: v17.literal(runesMintMethodName),
     params: runesMintParamsSchema,
-    id: v10.string()
+    id: v17.string()
   }).entries
 });
 
 // src/request/types/runesMethods/transfer.ts
-import * as v11 from "valibot";
+import * as v18 from "valibot";
 var runesTransferMethodName = "runes_transfer";
-var runesTransferParamsSchema = v11.object({
-  recipients: v11.array(
-    v11.object({
-      runeName: v11.string(),
-      amount: v11.string(),
-      address: v11.string()
+var runesTransferParamsSchema = v18.object({
+  recipients: v18.array(
+    v18.object({
+      runeName: v18.string(),
+      amount: v18.string(),
+      address: v18.string()
     })
   )
 });
-var runesTransferResultSchema = v11.object({
-  txid: v11.string()
+var runesTransferResultSchema = v18.object({
+  txid: v18.string()
 });
-var runesTransferRequestMessageSchema = v11.object({
+var runesTransferRequestMessageSchema = v18.object({
   ...rpcRequestMessageSchema.entries,
-  ...v11.object({
-    method: v11.literal(runesTransferMethodName),
+  ...v18.object({
+    method: v18.literal(runesTransferMethodName),
     params: runesTransferParamsSchema,
-    id: v11.string()
+    id: v18.string()
   }).entries
 });
 
 // src/request/types/sparkMethods/flashnetMethods/clawbackFunds.ts
-import * as v12 from "valibot";
+import * as v19 from "valibot";
 var sparkFlashnetClawbackFundsMethodName = "spark_flashnet_clawbackFunds";
-var sparkFlashnetClawbackFundsParamsSchema = v12.object({
-  sparkTransferId: v12.string(),
-  lpIdentityPublicKey: v12.string()
-});
-var sparkFlashnetClawbackFundsResultSchema = v12.object({
-  requestId: v12.string(),
-  accepted: v12.boolean(),
-  internalRequestId: v12.optional(v12.string()),
-  sparkStatusTrackingId: v12.optional(v12.string()),
-  error: v12.optional(v12.string())
-});
-var sparkFlashnetClawbackFundsRequestMessageSchema = v12.object({
+var sparkFlashnetClawbackFundsParamsSchema = v19.object({
+  sparkTransferId: v19.string(),
+  lpIdentityPublicKey: v19.string()
+});
+var sparkFlashnetClawbackFundsResultSchema = v19.object({
+  requestId: v19.string(),
+  accepted: v19.boolean(),
+  internalRequestId: v19.optional(v19.string()),
+  sparkStatusTrackingId: v19.optional(v19.string()),
+  error: v19.optional(v19.string())
+});
+var sparkFlashnetClawbackFundsRequestMessageSchema = v19.object({
   ...rpcRequestMessageSchema.entries,
-  ...v12.object({
-    method: v12.literal(sparkFlashnetClawbackFundsMethodName),
+  ...v19.object({
+    method: v19.literal(sparkFlashnetClawbackFundsMethodName),
     params: sparkFlashnetClawbackFundsParamsSchema,
-    id: v12.string()
+    id: v19.string()
   }).entries
 });
 
 // src/request/types/sparkMethods/flashnetMethods/executeRouteSwap.ts
-import * as v13 from "valibot";
+import * as v20 from "valibot";
 var sparkFlashnetExecuteRouteSwapMethodName = "spark_flashnet_executeRouteSwap";
-var sparkFlashnetExecuteRouteSwapParamsSchema = v13.object({
-  hops: v13.array(
-    v13.object({
-      poolId: v13.string(),
-      assetInAddress: v13.string(),
-      assetOutAddress: v13.string(),
-      hopIntegratorFeeRateBps: v13.optional(v13.number())
+var sparkFlashnetExecuteRouteSwapParamsSchema = v20.object({
+  hops: v20.array(
+    v20.object({
+      poolId: v20.string(),
+      assetInAddress: v20.string(),
+      assetOutAddress: v20.string(),
+      hopIntegratorFeeRateBps: v20.optional(v20.number())
     })
   ),
-  initialAssetAddress: v13.string(),
-  inputAmount: v13.string(),
-  maxRouteSlippageBps: v13.string(),
-  minAmountOut: v13.optional(v13.string()),
-  integratorFeeRateBps: v13.optional(v13.number()),
-  integratorPublicKey: v13.optional(v13.string())
-});
-var sparkFlashnetExecuteRouteSwapResultSchema = v13.object({
-  requestId: v13.string(),
-  accepted: v13.boolean(),
-  outputAmount: v13.string(),
-  executionPrice: v13.string(),
-  finalOutboundTransferId: v13.string(),
-  error: v13.optional(v13.string())
-});
-var sparkFlashnetExecuteRouteSwapRequestMessageSchema = v13.object({
+  initialAssetAddress: v20.string(),
+  inputAmount: v20.string(),
+  maxRouteSlippageBps: v20.string(),
+  minAmountOut: v20.optional(v20.string()),
+  integratorFeeRateBps: v20.optional(v20.number()),
+  integratorPublicKey: v20.optional(v20.string())
+});
+var sparkFlashnetExecuteRouteSwapResultSchema = v20.object({
+  requestId: v20.string(),
+  accepted: v20.boolean(),
+  outputAmount: v20.string(),
+  executionPrice: v20.string(),
+  finalOutboundTransferId: v20.string(),
+  error: v20.optional(v20.string())
+});
+var sparkFlashnetExecuteRouteSwapRequestMessageSchema = v20.object({
   ...rpcRequestMessageSchema.entries,
-  ...v13.object({
-    method: v13.literal(sparkFlashnetExecuteRouteSwapMethodName),
+  ...v20.object({
+    method: v20.literal(sparkFlashnetExecuteRouteSwapMethodName),
     params: sparkFlashnetExecuteRouteSwapParamsSchema,
-    id: v13.string()
+    id: v20.string()
   }).entries
 });
 
 // src/request/types/sparkMethods/flashnetMethods/executeSwap.ts
-import * as v14 from "valibot";
+import * as v21 from "valibot";
 var sparkFlashnetExecuteSwapMethodName = "spark_flashnet_executeSwap";
-var sparkFlashnetExecuteSwapParamsSchema = v14.object({
-  poolId: v14.string(),
-  assetInAddress: v14.string(),
-  assetOutAddress: v14.string(),
-  amountIn: v14.string(),
-  maxSlippageBps: v14.number(),
-  minAmountOut: v14.optional(v14.string()),
-  integratorFeeRateBps: v14.optional(v14.number()),
-  integratorPublicKey: v14.optional(v14.string())
-});
-var sparkFlashnetExecuteSwapResultSchema = v14.object({
-  requestId: v14.string(),
-  accepted: v14.boolean(),
-  amountOut: v14.optional(v14.string()),
-  feeAmount: v14.optional(v14.string()),
-  executionPrice: v14.optional(v14.string()),
-  assetOutAddress: v14.optional(v14.string()),
-  assetInAddress: v14.optional(v14.string()),
-  outboundTransferId: v14.optional(v14.string()),
-  error: v14.optional(v14.string())
-});
-var sparkFlashnetExecuteSwapRequestMessageSchema = v14.object({
+var sparkFlashnetExecuteSwapParamsSchema = v21.object({
+  poolId: v21.string(),
+  assetInAddress: v21.string(),
+  assetOutAddress: v21.string(),
+  amountIn: v21.string(),
+  maxSlippageBps: v21.number(),
+  minAmountOut: v21.optional(v21.string()),
+  integratorFeeRateBps: v21.optional(v21.number()),
+  integratorPublicKey: v21.optional(v21.string())
+});
+var sparkFlashnetExecuteSwapResultSchema = v21.object({
+  requestId: v21.string(),
+  accepted: v21.boolean(),
+  amountOut: v21.optional(v21.string()),
+  feeAmount: v21.optional(v21.string()),
+  executionPrice: v21.optional(v21.string()),
+  assetOutAddress: v21.optional(v21.string()),
+  assetInAddress: v21.optional(v21.string()),
+  outboundTransferId: v21.optional(v21.string()),
+  error: v21.optional(v21.string())
+});
+var sparkFlashnetExecuteSwapRequestMessageSchema = v21.object({
   ...rpcRequestMessageSchema.entries,
-  ...v14.object({
-    method: v14.literal(sparkFlashnetExecuteSwapMethodName),
+  ...v21.object({
+    method: v21.literal(sparkFlashnetExecuteSwapMethodName),
     params: sparkFlashnetExecuteSwapParamsSchema,
-    id: v14.string()
+    id: v21.string()
   }).entries
 });
 
 // src/request/types/sparkMethods/flashnetMethods/getClawbackEligibleTransfers.ts
-import * as v15 from "valibot";
+import * as v22 from "valibot";
 var sparkGetClawbackEligibleTransfersMethodName = "spark_flashnet_getClawbackEligibleTransfers";
-var sparkGetClawbackEligibleTransfersParamsSchema = v15.nullish(v15.null());
-var sparkGetClawbackEligibleTransfersResultSchema = v15.object({
-  eligibleTransfers: v15.array(
-    v15.object({
-      txId: v15.string(),
-      createdAt: v15.string(),
-      lpIdentityPublicKey: v15.string()
+var sparkGetClawbackEligibleTransfersParamsSchema = v22.nullish(v22.null());
+var sparkGetClawbackEligibleTransfersResultSchema = v22.object({
+  eligibleTransfers: v22.array(
+    v22.object({
+      txId: v22.string(),
+      createdAt: v22.string(),
+      lpIdentityPublicKey: v22.string()
     })
   )
 });
-var sparkGetClawbackEligibleTransfersRequestMessageSchema = v15.object({
+var sparkGetClawbackEligibleTransfersRequestMessageSchema = v22.object({
   ...rpcRequestMessageSchema.entries,
-  ...v15.object({
-    method: v15.literal(sparkGetClawbackEligibleTransfersMethodName),
+  ...v22.object({
+    method: v22.literal(sparkGetClawbackEligibleTransfersMethodName),
     params: sparkGetClawbackEligibleTransfersParamsSchema,
-    id: v15.string()
+    id: v22.string()
   }).entries
 });
 
 // src/request/types/sparkMethods/flashnetMethods/getJwt.ts
-import * as v16 from "valibot";
+import * as v23 from "valibot";
 var sparkFlashnetGetJwtMethodName = "spark_flashnet_getJwt";
-var sparkFlashnetGetJwtParamsSchema = v16.null();
-var sparkFlashnetGetJwtResultSchema = v16.object({
+var sparkFlashnetGetJwtParamsSchema = v23.null();
+var sparkFlashnetGetJwtResultSchema = v23.object({
   /**
    * The JWT token for authenticated requests to the Flashnet API.
    */
-  jwt: v16.string()
+  jwt: v23.string()
 });
-var sparkFlashnetGetJwtRequestMessageSchema = v16.object({
+var sparkFlashnetGetJwtRequestMessageSchema = v23.object({
   ...rpcRequestMessageSchema.entries,
-  ...v16.object({
-    method: v16.literal(sparkFlashnetGetJwtMethodName),
+  ...v23.object({
+    method: v23.literal(sparkFlashnetGetJwtMethodName),
     params: sparkFlashnetGetJwtParamsSchema,
-    id: v16.string()
+    id: v23.string()
   }).entries
 });
 
 // src/request/types/sparkMethods/flashnetMethods/intents/addLiquidity.ts
-import * as v17 from "valibot";
-var sparkFlashnetAddLiquidityIntentSchema = v17.object({
-  type: v17.literal("addLiquidity"),
-  data: v17.object({
-    userPublicKey: v17.string(),
-    poolId: v17.string(),
-    assetAAmount: v17.string(),
-    assetBAmount: v17.string(),
-    assetAMinAmountIn: v17.string(),
-    assetBMinAmountIn: v17.string(),
-    assetATransferId: v17.string(),
-    assetBTransferId: v17.string(),
-    nonce: v17.string()
+import * as v24 from "valibot";
+var sparkFlashnetAddLiquidityIntentSchema = v24.object({
+  type: v24.literal("addLiquidity"),
+  data: v24.object({
+    userPublicKey: v24.string(),
+    poolId: v24.string(),
+    assetAAmount: v24.string(),
+    assetBAmount: v24.string(),
+    assetAMinAmountIn: v24.string(),
+    assetBMinAmountIn: v24.string(),
+    assetATransferId: v24.string(),
+    assetBTransferId: v24.string(),
+    nonce: v24.string()
   })
 });
 
 // src/request/types/sparkMethods/flashnetMethods/intents/clawback.ts
-import * as v18 from "valibot";
-var sparkFlashnetClawbackIntentSchema = v18.object({
-  type: v18.literal("clawback"),
-  data: v18.object({
-    senderPublicKey: v18.string(),
-    sparkTransferId: v18.string(),
-    lpIdentityPublicKey: v18.string(),
-    nonce: v18.string()
+import * as v25 from "valibot";
+var sparkFlashnetClawbackIntentSchema = v25.object({
+  type: v25.literal("clawback"),
+  data: v25.object({
+    senderPublicKey: v25.string(),
+    sparkTransferId: v25.string(),
+    lpIdentityPublicKey: v25.string(),
+    nonce: v25.string()
   })
 });
 
 // src/request/types/sparkMethods/flashnetMethods/intents/confirmInitialDeposit.ts
-import * as v19 from "valibot";
-var sparkFlashnetConfirmInitialDepositIntentSchema = v19.object({
-  type: v19.literal("confirmInitialDeposit"),
-  data: v19.object({
-    poolId: v19.string(),
-    assetASparkTransferId: v19.string(),
-    poolOwnerPublicKey: v19.string(),
-    nonce: v19.string()
+import * as v26 from "valibot";
+var sparkFlashnetConfirmInitialDepositIntentSchema = v26.object({
+  type: v26.literal("confirmInitialDeposit"),
+  data: v26.object({
+    poolId: v26.string(),
+    assetASparkTransferId: v26.string(),
+    poolOwnerPublicKey: v26.string(),
+    nonce: v26.string()
   })
 });
 
 // src/request/types/sparkMethods/flashnetMethods/intents/createConstantProductPool.ts
-import * as v20 from "valibot";
-var sparkFlashnetCreateConstantProductPoolIntentSchema = v20.object({
-  type: v20.literal("createConstantProductPool"),
-  data: v20.object({
-    poolOwnerPublicKey: v20.string(),
-    assetAAddress: v20.string(),
-    assetBAddress: v20.string(),
-    lpFeeRateBps: v20.union([v20.number(), v20.string()]),
-    totalHostFeeRateBps: v20.union([v20.number(), v20.string()]),
-    nonce: v20.string()
+import * as v27 from "valibot";
+var sparkFlashnetCreateConstantProductPoolIntentSchema = v27.object({
+  type: v27.literal("createConstantProductPool"),
+  data: v27.object({
+    poolOwnerPublicKey: v27.string(),
+    assetAAddress: v27.string(),
+    assetBAddress: v27.string(),
+    lpFeeRateBps: v27.union([v27.number(), v27.string()]),
+    totalHostFeeRateBps: v27.union([v27.number(), v27.string()]),
+    nonce: v27.string()
   })
 });
 
 // src/request/types/sparkMethods/flashnetMethods/intents/createSingleSidedPool.ts
-import * as v21 from "valibot";
-var sparkFlashnetCreateSingleSidedPoolIntentSchema = v21.object({
-  type: v21.literal("createSingleSidedPool"),
-  data: v21.object({
-    assetAAddress: v21.string(),
-    assetBAddress: v21.string(),
-    assetAInitialReserve: v21.string(),
-    virtualReserveA: v21.union([v21.number(), v21.string()]),
-    virtualReserveB: v21.union([v21.number(), v21.string()]),
-    threshold: v21.union([v21.number(), v21.string()]),
-    lpFeeRateBps: v21.union([v21.number(), v21.string()]),
-    totalHostFeeRateBps: v21.union([v21.number(), v21.string()]),
-    poolOwnerPublicKey: v21.string(),
-    nonce: v21.string()
+import * as v28 from "valibot";
+var sparkFlashnetCreateSingleSidedPoolIntentSchema = v28.object({
+  type: v28.literal("createSingleSidedPool"),
+  data: v28.object({
+    assetAAddress: v28.string(),
+    assetBAddress: v28.string(),
+    assetAInitialReserve: v28.string(),
+    virtualReserveA: v28.union([v28.number(), v28.string()]),
+    virtualReserveB: v28.union([v28.number(), v28.string()]),
+    threshold: v28.union([v28.number(), v28.string()]),
+    lpFeeRateBps: v28.union([v28.number(), v28.string()]),
+    totalHostFeeRateBps: v28.union([v28.number(), v28.string()]),
+    poolOwnerPublicKey: v28.string(),
+    nonce: v28.string()
   })
 });
 
 // src/request/types/sparkMethods/flashnetMethods/intents/removeLiquidity.ts
-import * as v22 from "valibot";
-var sparkFlashnetRemoveLiquidityIntentSchema = v22.object({
-  type: v22.literal("removeLiquidity"),
-  data: v22.object({
-    userPublicKey: v22.string(),
-    poolId: v22.string(),
-    lpTokensToRemove: v22.string(),
-    nonce: v22.string()
+import * as v29 from "valibot";
+var sparkFlashnetRemoveLiquidityIntentSchema = v29.object({
+  type: v29.literal("removeLiquidity"),
+  data: v29.object({
+    userPublicKey: v29.string(),
+    poolId: v29.string(),
+    lpTokensToRemove: v29.string(),
+    nonce: v29.string()
   })
 });
 
 // src/request/types/sparkMethods/flashnetMethods/intents/routeSwap.ts
-import * as v23 from "valibot";
-var sparkFlashnetRouteSwapIntentSchema = v23.object({
-  type: v23.literal("executeRouteSwap"),
-  data: v23.object({
-    userPublicKey: v23.string(),
-    initialSparkTransferId: v23.string(),
-    hops: v23.array(
-      v23.object({
-        poolId: v23.string(),
-        inputAssetAddress: v23.string(),
-        outputAssetAddress: v23.string(),
-        hopIntegratorFeeRateBps: v23.optional(v23.union([v23.number(), v23.string()]))
+import * as v30 from "valibot";
+var sparkFlashnetRouteSwapIntentSchema = v30.object({
+  type: v30.literal("executeRouteSwap"),
+  data: v30.object({
+    userPublicKey: v30.string(),
+    initialSparkTransferId: v30.string(),
+    hops: v30.array(
+      v30.object({
+        poolId: v30.string(),
+        inputAssetAddress: v30.string(),
+        outputAssetAddress: v30.string(),
+        hopIntegratorFeeRateBps: v30.optional(v30.union([v30.number(), v30.string()]))
       })
     ),
-    inputAmount: v23.string(),
-    maxRouteSlippageBps: v23.union([v23.number(), v23.string()]),
-    minAmountOut: v23.string(),
-    defaultIntegratorFeeRateBps: v23.optional(v23.union([v23.number(), v23.string()])),
-    nonce: v23.string()
+    inputAmount: v30.string(),
+    maxRouteSlippageBps: v30.union([v30.number(), v30.string()]),
+    minAmountOut: v30.string(),
+    defaultIntegratorFeeRateBps: v30.optional(v30.union([v30.number(), v30.string()])),
+    nonce: v30.string()
   })
 });
 
 // src/request/types/sparkMethods/flashnetMethods/intents/swap.ts
-import * as v24 from "valibot";
-var sparkFlashnetSwapIntentSchema = v24.object({
-  type: v24.literal("executeSwap"),
-  data: v24.object({
-    userPublicKey: v24.string(),
-    poolId: v24.string(),
-    transferId: v24.string(),
-    assetInAddress: v24.string(),
-    assetOutAddress: v24.string(),
-    amountIn: v24.string(),
-    maxSlippageBps: v24.union([v24.number(), v24.string()]),
-    minAmountOut: v24.string(),
-    totalIntegratorFeeRateBps: v24.optional(v24.union([v24.number(), v24.string()])),
-    nonce: v24.string()
+import * as v31 from "valibot";
+var sparkFlashnetSwapIntentSchema = v31.object({
+  type: v31.literal("executeSwap"),
+  data: v31.object({
+    userPublicKey: v31.string(),
+    poolId: v31.string(),
+    transferId: v31.string(),
+    assetInAddress: v31.string(),
+    assetOutAddress: v31.string(),
+    amountIn: v31.string(),
+    maxSlippageBps: v31.union([v31.number(), v31.string()]),
+    minAmountOut: v31.string(),
+    totalIntegratorFeeRateBps: v31.optional(v31.union([v31.number(), v31.string()])),
+    nonce: v31.string()
   })
 });
 
 // src/request/types/sparkMethods/flashnetMethods/signIntent.ts
-import * as v25 from "valibot";
+import * as v32 from "valibot";
 var sparkFlashnetSignIntentMethodName = "spark_flashnet_signIntent";
-var sparkFlashnetSignIntentParamsSchema = v25.union([
+var sparkFlashnetSignIntentParamsSchema = v32.union([
   sparkFlashnetSwapIntentSchema,
   sparkFlashnetRouteSwapIntentSchema,
   sparkFlashnetAddLiquidityIntentSchema,
@@ -1134,109 +1206,109 @@ var sparkFlashnetSignIntentParamsSchema = v25.union([
   sparkFlashnetCreateSingleSidedPoolIntentSchema,
   sparkFlashnetRemoveLiquidityIntentSchema
 ]);
-var sparkFlashnetSignIntentResultSchema = v25.object({
+var sparkFlashnetSignIntentResultSchema = v32.object({
   /**
    * The signed intent as a hex string.
    */
-  signature: v25.string()
+  signature: v32.string()
 });
-var sparkFlashnetSignIntentRequestMessageSchema = v25.object({
+var sparkFlashnetSignIntentRequestMessageSchema = v32.object({
   ...rpcRequestMessageSchema.entries,
-  ...v25.object({
-    method: v25.literal(sparkFlashnetSignIntentMethodName),
+  ...v32.object({
+    method: v32.literal(sparkFlashnetSignIntentMethodName),
     params: sparkFlashnetSignIntentParamsSchema,
-    id: v25.string()
+    id: v32.string()
   }).entries
 });
 
 // src/request/types/sparkMethods/flashnetMethods/signStructuredMessage.ts
-import * as v26 from "valibot";
+import * as v33 from "valibot";
 var sparkFlashnetSignStructuredMessageMethodName = "spark_flashnet_signStructuredMessage";
-var sparkFlashnetSignStructuredMessageParamsSchema = v26.object({
-  message: v26.string()
+var sparkFlashnetSignStructuredMessageParamsSchema = v33.object({
+  message: v33.string()
 });
-var sparkFlashnetSignStructuredMessageResultSchema = v26.object({
-  message: v26.string(),
-  signature: v26.string()
+var sparkFlashnetSignStructuredMessageResultSchema = v33.object({
+  message: v33.string(),
+  signature: v33.string()
 });
-var sparkFlashnetSignStructuredMessageRequestMessageSchema = v26.object({
+var sparkFlashnetSignStructuredMessageRequestMessageSchema = v33.object({
   ...rpcRequestMessageSchema.entries,
-  ...v26.object({
-    method: v26.literal(sparkFlashnetSignStructuredMessageMethodName),
+  ...v33.object({
+    method: v33.literal(sparkFlashnetSignStructuredMessageMethodName),
     params: sparkFlashnetSignStructuredMessageParamsSchema,
-    id: v26.string()
+    id: v33.string()
   }).entries
 });
 
 // src/request/types/sparkMethods/getAddresses.ts
-import * as v27 from "valibot";
+import * as v34 from "valibot";
 var sparkGetAddressesMethodName = "spark_getAddresses";
-var sparkGetAddressesParamsSchema = v27.nullish(
-  v27.object({
+var sparkGetAddressesParamsSchema = v34.nullish(
+  v34.object({
     /**
      * A message to be displayed to the user in the request prompt.
      */
-    message: v27.optional(v27.string())
+    message: v34.optional(v34.string())
   })
 );
-var sparkGetAddressesResultSchema = v27.object({
+var sparkGetAddressesResultSchema = v34.object({
   /**
    * The addresses generated for the given purposes.
    */
-  addresses: v27.array(addressSchema),
+  addresses: v34.array(addressSchema),
   network: getNetworkResultSchema
 });
-var sparkGetAddressesRequestMessageSchema = v27.object({
+var sparkGetAddressesRequestMessageSchema = v34.object({
   ...rpcRequestMessageSchema.entries,
-  ...v27.object({
-    method: v27.literal(sparkGetAddressesMethodName),
+  ...v34.object({
+    method: v34.literal(sparkGetAddressesMethodName),
     params: sparkGetAddressesParamsSchema,
-    id: v27.string()
+    id: v34.string()
   }).entries
 });
 
 // src/request/types/sparkMethods/getBalance.ts
-import * as v28 from "valibot";
+import * as v35 from "valibot";
 var sparkGetBalanceMethodName = "spark_getBalance";
-var sparkGetBalanceParamsSchema = v28.nullish(v28.null());
-var sparkGetBalanceResultSchema = v28.object({
+var sparkGetBalanceParamsSchema = v35.nullish(v35.null());
+var sparkGetBalanceResultSchema = v35.object({
   /**
    * The Spark Bitcoin address balance in sats in string form.
    */
-  balance: v28.string(),
-  tokenBalances: v28.array(
-    v28.object({
+  balance: v35.string(),
+  tokenBalances: v35.array(
+    v35.object({
       /* The address balance of the token in string form as it can overflow a js number */
-      balance: v28.string(),
-      tokenMetadata: v28.object({
-        tokenIdentifier: v28.string(),
-        tokenName: v28.string(),
-        tokenTicker: v28.string(),
-        decimals: v28.number(),
-        maxSupply: v28.string()
+      balance: v35.string(),
+      tokenMetadata: v35.object({
+        tokenIdentifier: v35.string(),
+        tokenName: v35.string(),
+        tokenTicker: v35.string(),
+        decimals: v35.number(),
+        maxSupply: v35.string()
       })
     })
   )
 });
-var sparkGetBalanceRequestMessageSchema = v28.object({
+var sparkGetBalanceRequestMessageSchema = v35.object({
   ...rpcRequestMessageSchema.entries,
-  ...v28.object({
-    method: v28.literal(sparkGetBalanceMethodName),
+  ...v35.object({
+    method: v35.literal(sparkGetBalanceMethodName),
     params: sparkGetBalanceParamsSchema,
-    id: v28.string()
+    id: v35.string()
   }).entries
 });
 
 // src/request/types/sparkMethods/signMessage.ts
-import * as v29 from "valibot";
+import * as v36 from "valibot";
 var sparkSignMessageMethodName = "spark_signMessage";
-var sparkSignMessageParamsSchema = v29.object({
+var sparkSignMessageParamsSchema = v36.object({
   /**
    * The message to sign. The message should only consist of valid UTF-8 characters.
    */
-  message: v29.string()
+  message: v36.string()
 });
-var sparkSignMessageResultSchema = v29.object({
+var sparkSignMessageResultSchema = v36.object({
   /**
    * The signature, encoded in base64, of the message hash.
    *
@@ -1244,98 +1316,98 @@ var sparkSignMessageResultSchema = v29.object({
    * and the resulting byte array is hashed with SHA256 before signing
    * with the private key.
    */
-  signature: v29.string()
+  signature: v36.string()
 });
-var sparkSignMessageRequestMessageSchema = v29.object({
+var sparkSignMessageRequestMessageSchema = v36.object({
   ...rpcRequestMessageSchema.entries,
-  ...v29.object({
-    method: v29.literal(sparkSignMessageMethodName),
+  ...v36.object({
+    method: v36.literal(sparkSignMessageMethodName),
     params: sparkSignMessageParamsSchema,
-    id: v29.string()
+    id: v36.string()
   }).entries
 });
 
 // src/request/types/sparkMethods/transfer.ts
-import * as v30 from "valibot";
+import * as v37 from "valibot";
 var sparkTransferMethodName = "spark_transfer";
-var sparkTransferParamsSchema = v30.object({
+var sparkTransferParamsSchema = v37.object({
   /**
    * Amount of SATS to transfer as a string or number.
    */
-  amountSats: v30.union([v30.number(), v30.string()]),
+  amountSats: v37.union([v37.number(), v37.string()]),
   /**
    * The recipient's spark address.
    */
-  receiverSparkAddress: v30.string()
+  receiverSparkAddress: v37.string()
 });
-var sparkTransferResultSchema = v30.object({
+var sparkTransferResultSchema = v37.object({
   /**
    * The ID of the transaction.
    */
-  id: v30.string()
+  id: v37.string()
 });
-var sparkTransferRequestMessageSchema = v30.object({
+var sparkTransferRequestMessageSchema = v37.object({
   ...rpcRequestMessageSchema.entries,
-  ...v30.object({
-    method: v30.literal(sparkTransferMethodName),
+  ...v37.object({
+    method: v37.literal(sparkTransferMethodName),
     params: sparkTransferParamsSchema,
-    id: v30.string()
+    id: v37.string()
   }).entries
 });
 
 // src/request/types/sparkMethods/transferToken.ts
-import * as v31 from "valibot";
+import * as v38 from "valibot";
 var sparkTransferTokenMethodName = "spark_transferToken";
-var sparkTransferTokenParamsSchema = v31.object({
+var sparkTransferTokenParamsSchema = v38.object({
   /**
    * Amount of units of the token to transfer as a string or number.
    */
-  tokenAmount: v31.union([v31.number(), v31.string()]),
+  tokenAmount: v38.union([v38.number(), v38.string()]),
   /**
    * The Bech32m token identifier.
    */
-  tokenIdentifier: v31.string(),
+  tokenIdentifier: v38.string(),
   /**
    * The recipient's spark address.
    */
-  receiverSparkAddress: v31.string()
+  receiverSparkAddress: v38.string()
 });
-var sparkTransferTokenResultSchema = v31.object({
+var sparkTransferTokenResultSchema = v38.object({
   /**
    * The ID of the transaction.
    */
-  id: v31.string()
+  id: v38.string()
 });
-var sparkTransferTokenRequestMessageSchema = v31.object({
+var sparkTransferTokenRequestMessageSchema = v38.object({
   ...rpcRequestMessageSchema.entries,
-  ...v31.object({
-    method: v31.literal(sparkTransferTokenMethodName),
+  ...v38.object({
+    method: v38.literal(sparkTransferTokenMethodName),
     params: sparkTransferTokenParamsSchema,
-    id: v31.string()
+    id: v38.string()
   }).entries
 });
 
 // src/request/types/stxMethods/callContract.ts
-import * as v32 from "valibot";
+import * as v39 from "valibot";
 var stxCallContractMethodName = "stx_callContract";
-var stxCallContractParamsSchema = v32.object({
+var stxCallContractParamsSchema = v39.object({
   /**
    * The contract principal.
    *
    * E.g. `"SPKE...GD5C.my-contract"`
    */
-  contract: v32.string(),
+  contract: v39.string(),
   /**
    * The name of the function to call.
    *
    * Note: spec changes ongoing,
    * https://github.com/stacksgov/sips/pull/166#pullrequestreview-1914236999
    */
-  functionName: v32.string(),
+  functionName: v39.string(),
   /**
    * @deprecated in favor of `functionArgs` for @stacks/connect compatibility
    */
-  arguments: v32.optional(v32.array(v32.string())),
+  arguments: v39.optional(v39.array(v39.string())),
   /**
    * The function's arguments. The arguments are expected to be hex-encoded
    * strings of Clarity values.
@@ -1350,274 +1422,274 @@ var stxCallContractParamsSchema = v32.object({
    * const hexArgs = functionArgs.map(cvToHex);
    * ```
    */
-  functionArgs: v32.optional(v32.array(v32.string())),
+  functionArgs: v39.optional(v39.array(v39.string())),
   /**
    * The post conditions to apply to the contract call.
    */
-  postConditions: v32.optional(v32.array(v32.string())),
+  postConditions: v39.optional(v39.array(v39.string())),
   /**
    * The mode to apply to the post conditions.
    */
-  postConditionMode: v32.optional(v32.union([v32.literal("allow"), v32.literal("deny")]))
+  postConditionMode: v39.optional(v39.union([v39.literal("allow"), v39.literal("deny")]))
 });
-var stxCallContractResultSchema = v32.object({
+var stxCallContractResultSchema = v39.object({
   /**
    * The ID of the transaction.
    */
-  txid: v32.string(),
+  txid: v39.string(),
   /**
    * A Stacks transaction as a hex-encoded string.
    */
-  transaction: v32.string()
+  transaction: v39.string()
 });
-var stxCallContractRequestMessageSchema = v32.object({
+var stxCallContractRequestMessageSchema = v39.object({
   ...rpcRequestMessageSchema.entries,
-  ...v32.object({
-    method: v32.literal(stxCallContractMethodName),
+  ...v39.object({
+    method: v39.literal(stxCallContractMethodName),
     params: stxCallContractParamsSchema,
-    id: v32.string()
+    id: v39.string()
   }).entries
 });
 
 // src/request/types/stxMethods/deployContract.ts
-import * as v33 from "valibot";
+import * as v40 from "valibot";
 var stxDeployContractMethodName = "stx_deployContract";
-var stxDeployContractParamsSchema = v33.object({
+var stxDeployContractParamsSchema = v40.object({
   /**
    * Name of the contract.
    */
-  name: v33.string(),
+  name: v40.string(),
   /**
    * The source code of the Clarity contract.
    */
-  clarityCode: v33.string(),
+  clarityCode: v40.string(),
   /**
    * The version of the Clarity contract.
    */
-  clarityVersion: v33.optional(v33.number()),
+  clarityVersion: v40.optional(v40.number()),
   /**
    * The post conditions to apply to the contract call.
    */
-  postConditions: v33.optional(v33.array(v33.string())),
+  postConditions: v40.optional(v40.array(v40.string())),
   /**
    * The mode to apply to the post conditions.
    */
-  postConditionMode: v33.optional(v33.union([v33.literal("allow"), v33.literal("deny")]))
+  postConditionMode: v40.optional(v40.union([v40.literal("allow"), v40.literal("deny")]))
 });
-var stxDeployContractResultSchema = v33.object({
+var stxDeployContractResultSchema = v40.object({
   /**
    * The ID of the transaction.
    */
-  txid: v33.string(),
+  txid: v40.string(),
   /**
    * A Stacks transaction as a hex-encoded string.
    */
-  transaction: v33.string()
+  transaction: v40.string()
 });
-var stxDeployContractRequestMessageSchema = v33.object({
+var stxDeployContractRequestMessageSchema = v40.object({
   ...rpcRequestMessageSchema.entries,
-  ...v33.object({
-    method: v33.literal(stxDeployContractMethodName),
+  ...v40.object({
+    method: v40.literal(stxDeployContractMethodName),
     params: stxDeployContractParamsSchema,
-    id: v33.string()
+    id: v40.string()
   }).entries
 });
 
 // src/request/types/stxMethods/getAccounts.ts
-import * as v34 from "valibot";
+import * as v41 from "valibot";
 var stxGetAccountsMethodName = "stx_getAccounts";
-var stxGetAccountsParamsSchema = v34.nullish(v34.null());
-var stxGetAccountsResultSchema = v34.object({
+var stxGetAccountsParamsSchema = v41.nullish(v41.null());
+var stxGetAccountsResultSchema = v41.object({
   /**
    * The addresses generated for the given purposes.
    */
-  addresses: v34.array(
-    v34.object({
-      address: v34.string(),
-      publicKey: v34.string(),
-      gaiaHubUrl: v34.string(),
-      gaiaAppKey: v34.string()
+  addresses: v41.array(
+    v41.object({
+      address: v41.string(),
+      publicKey: v41.string(),
+      gaiaHubUrl: v41.string(),
+      gaiaAppKey: v41.string()
     })
   ),
   network: getNetworkResultSchema
 });
-var stxGetAccountsRequestMessageSchema = v34.object({
+var stxGetAccountsRequestMessageSchema = v41.object({
   ...rpcRequestMessageSchema.entries,
-  ...v34.object({
-    method: v34.literal(stxGetAccountsMethodName),
+  ...v41.object({
+    method: v41.literal(stxGetAccountsMethodName),
     params: stxGetAccountsParamsSchema,
-    id: v34.string()
+    id: v41.string()
   }).entries
 });
 
 // src/request/types/stxMethods/getAddresses.ts
-import * as v35 from "valibot";
+import * as v42 from "valibot";
 var stxGetAddressesMethodName = "stx_getAddresses";
-var stxGetAddressesParamsSchema = v35.nullish(
-  v35.object({
+var stxGetAddressesParamsSchema = v42.nullish(
+  v42.object({
     /**
      * A message to be displayed to the user in the request prompt.
      */
-    message: v35.optional(v35.string())
+    message: v42.optional(v42.string())
   })
 );
-var stxGetAddressesResultSchema = v35.object({
+var stxGetAddressesResultSchema = v42.object({
   /**
    * The addresses generated for the given purposes.
    */
-  addresses: v35.array(addressSchema),
+  addresses: v42.array(addressSchema),
   network: getNetworkResultSchema
 });
-var stxGetAddressesRequestMessageSchema = v35.object({
+var stxGetAddressesRequestMessageSchema = v42.object({
   ...rpcRequestMessageSchema.entries,
-  ...v35.object({
-    method: v35.literal(stxGetAddressesMethodName),
+  ...v42.object({
+    method: v42.literal(stxGetAddressesMethodName),
     params: stxGetAddressesParamsSchema,
-    id: v35.string()
+    id: v42.string()
   }).entries
 });
 
 // src/request/types/stxMethods/signMessage.ts
-import * as v36 from "valibot";
+import * as v43 from "valibot";
 var stxSignMessageMethodName = "stx_signMessage";
-var stxSignMessageParamsSchema = v36.object({
+var stxSignMessageParamsSchema = v43.object({
   /**
    * The message to sign.
    */
-  message: v36.string()
+  message: v43.string()
 });
-var stxSignMessageResultSchema = v36.object({
+var stxSignMessageResultSchema = v43.object({
   /**
    * The signature of the message.
    */
-  signature: v36.string(),
+  signature: v43.string(),
   /**
    * The public key used to sign the message.
    */
-  publicKey: v36.string()
+  publicKey: v43.string()
 });
-var stxSignMessageRequestMessageSchema = v36.object({
+var stxSignMessageRequestMessageSchema = v43.object({
   ...rpcRequestMessageSchema.entries,
-  ...v36.object({
-    method: v36.literal(stxSignMessageMethodName),
+  ...v43.object({
+    method: v43.literal(stxSignMessageMethodName),
     params: stxSignMessageParamsSchema,
-    id: v36.string()
+    id: v43.string()
   }).entries
 });
 
 // src/request/types/stxMethods/signStructuredMessage.ts
-import * as v37 from "valibot";
+import * as v44 from "valibot";
 var stxSignStructuredMessageMethodName = "stx_signStructuredMessage";
-var stxSignStructuredMessageParamsSchema = v37.object({
+var stxSignStructuredMessageParamsSchema = v44.object({
   /**
    * The domain to be signed.
    */
-  domain: v37.string(),
+  domain: v44.string(),
   /**
    * Message payload to be signed.
    */
-  message: v37.string(),
+  message: v44.string(),
   /**
    * The public key to sign the message with.
    */
-  publicKey: v37.optional(v37.string())
+  publicKey: v44.optional(v44.string())
 });
-var stxSignStructuredMessageResultSchema = v37.object({
+var stxSignStructuredMessageResultSchema = v44.object({
   /**
    * Signature of the message.
    */
-  signature: v37.string(),
+  signature: v44.string(),
   /**
    * Public key as hex-encoded string.
    */
-  publicKey: v37.string()
+  publicKey: v44.string()
 });
-var stxSignStructuredMessageRequestMessageSchema = v37.object({
+var stxSignStructuredMessageRequestMessageSchema = v44.object({
   ...rpcRequestMessageSchema.entries,
-  ...v37.object({
-    method: v37.literal(stxSignStructuredMessageMethodName),
+  ...v44.object({
+    method: v44.literal(stxSignStructuredMessageMethodName),
     params: stxSignStructuredMessageParamsSchema,
-    id: v37.string()
+    id: v44.string()
   }).entries
 });
 
 // src/request/types/stxMethods/signTransaction.ts
-import * as v38 from "valibot";
+import * as v45 from "valibot";
 var stxSignTransactionMethodName = "stx_signTransaction";
-var stxSignTransactionParamsSchema = v38.object({
+var stxSignTransactionParamsSchema = v45.object({
   /**
    * The transaction to sign as a hex-encoded string.
    */
-  transaction: v38.string(),
+  transaction: v45.string(),
   /**
    * The public key to sign the transaction with. The wallet may use any key
    * when not provided.
    */
-  pubkey: v38.optional(v38.string()),
+  pubkey: v45.optional(v45.string()),
   /**
    * Whether to broadcast the transaction after signing. Defaults to `true`.
    */
-  broadcast: v38.optional(v38.boolean())
+  broadcast: v45.optional(v45.boolean())
 });
-var stxSignTransactionResultSchema = v38.object({
+var stxSignTransactionResultSchema = v45.object({
   /**
    * The signed transaction as a hex-encoded string.
    */
-  transaction: v38.string()
+  transaction: v45.string()
 });
-var stxSignTransactionRequestMessageSchema = v38.object({
+var stxSignTransactionRequestMessageSchema = v45.object({
   ...rpcRequestMessageSchema.entries,
-  ...v38.object({
-    method: v38.literal(stxSignTransactionMethodName),
+  ...v45.object({
+    method: v45.literal(stxSignTransactionMethodName),
     params: stxSignTransactionParamsSchema,
-    id: v38.string()
+    id: v45.string()
   }).entries
 });
 
 // src/request/types/stxMethods/signTransactions.ts
-import * as v39 from "valibot";
+import * as v46 from "valibot";
 var stxSignTransactionsMethodName = "stx_signTransactions";
-var stxSignTransactionsParamsSchema = v39.object({
+var stxSignTransactionsParamsSchema = v46.object({
   /**
    * The transactions to sign as hex-encoded strings.
    */
-  transactions: v39.pipe(
-    v39.array(
-      v39.pipe(
-        v39.string(),
-        v39.check((hex) => {
+  transactions: v46.pipe(
+    v46.array(
+      v46.pipe(
+        v46.string(),
+        v46.check((hex) => {
           return true;
         }, "Invalid hex-encoded Stacks transaction.")
       )
     ),
-    v39.minLength(1)
+    v46.minLength(1)
   ),
   /**
    * Whether the signed transactions should be broadcast after signing. Defaults
    * to `true`.
    */
-  broadcast: v39.optional(v39.boolean())
+  broadcast: v46.optional(v46.boolean())
 });
-var stxSignTransactionsResultSchema = v39.object({
+var stxSignTransactionsResultSchema = v46.object({
   /**
    * The signed transactions as hex-encoded strings, in the same order as in the
    * sign request.
    */
-  transactions: v39.array(v39.string())
+  transactions: v46.array(v46.string())
 });
-var stxSignTransactionsRequestMessageSchema = v39.object({
+var stxSignTransactionsRequestMessageSchema = v46.object({
   ...rpcRequestMessageSchema.entries,
-  ...v39.object({
-    method: v39.literal(stxSignTransactionsMethodName),
+  ...v46.object({
+    method: v46.literal(stxSignTransactionsMethodName),
     params: stxSignTransactionsParamsSchema,
-    id: v39.string()
+    id: v46.string()
   }).entries
 });
 
 // src/request/types/stxMethods/transferStx.ts
-import * as v40 from "valibot";
+import * as v47 from "valibot";
 var stxTransferStxMethodName = "stx_transferStx";
-var stxTransferStxParamsSchema = v40.object({
+var stxTransferStxParamsSchema = v47.object({
   /**
    * Amount of STX tokens to transfer in microstacks as a string. Anything
    * parseable by `BigInt` is acceptable.
@@ -1630,23 +1702,23 @@ var stxTransferStxParamsSchema = v40.object({
    * const amount3 = '1234';
    * ```
    */
-  amount: v40.union([v40.number(), v40.string()]),
+  amount: v47.union([v47.number(), v47.string()]),
   /**
    * The recipient's principal.
    */
-  recipient: v40.string(),
+  recipient: v47.string(),
   /**
    * A string representing the memo.
    */
-  memo: v40.optional(v40.string()),
+  memo: v47.optional(v47.string()),
   /**
    * Version of parameter format.
    */
-  version: v40.optional(v40.string()),
+  version: v47.optional(v47.string()),
   /**
    * The mode of the post conditions.
    */
-  postConditionMode: v40.optional(v40.number()),
+  postConditionMode: v47.optional(v47.number()),
   /**
    * A hex-encoded string representing the post conditions.
    *
@@ -1659,29 +1731,29 @@ var stxTransferStxParamsSchema = v40.object({
    * const hexPostCondition = serializePostCondition(postCondition).toString('hex');
    * ```
    */
-  postConditions: v40.optional(v40.array(v40.string())),
+  postConditions: v47.optional(v47.array(v47.string())),
   /**
    * The public key to sign the transaction with. The wallet may use any key
    * when not provided.
    */
-  pubkey: v40.optional(v40.string())
+  pubkey: v47.optional(v47.string())
 });
-var stxTransferStxResultSchema = v40.object({
+var stxTransferStxResultSchema = v47.object({
   /**
    * The ID of the transaction.
    */
-  txid: v40.string(),
+  txid: v47.string(),
   /**
    * A Stacks transaction as a hex-encoded string.
    */
-  transaction: v40.string()
+  transaction: v47.string()
 });
-var stxTransferStxRequestMessageSchema = v40.object({
+var stxTransferStxRequestMessageSchema = v47.object({
   ...rpcRequestMessageSchema.entries,
-  ...v40.object({
-    method: v40.literal(stxTransferStxMethodName),
+  ...v47.object({
+    method: v47.literal(stxTransferStxMethodName),
     params: stxTransferStxParamsSchema,
-    id: v40.string()
+    id: v47.string()
   }).entries
 });
 
@@ -1689,13 +1761,13 @@ var stxTransferStxRequestMessageSchema = v40.object({
 var cache = {};
 var requestInternal = async (provider, method, params) => {
   const response = await provider.request(method, params);
-  if (v41.is(rpcErrorResponseMessageSchema, response)) {
+  if (v48.is(rpcErrorResponseMessageSchema, response)) {
     return {
       status: "error",
       error: response.error
     };
   }
-  if (v41.is(rpcSuccessResponseMessageSchema, response)) {
+  if (v48.is(rpcSuccessResponseMessageSchema, response)) {
     return {
       status: "success",
       result: response.result
@@ -2877,6 +2949,10 @@ export {
   signMessageParamsSchema,
   signMessageRequestMessageSchema,
   signMessageResultSchema,
+  signMultipleMessagesMethodName,
+  signMultipleMessagesParamsSchema,
+  signMultipleMessagesRequestMessageSchema,
+  signMultipleMessagesResultSchema,
   signMultipleTransactions,
   signPsbtMethodName,
   signPsbtParamsSchema,