@sats-connect/core 0.8.1 → 0.8.2-6e91f8a

package/dist/index.js

@@ -37,6 +37,7 @@ __export(index_exports, {
   DefaultAdaptersInfo: () => DefaultAdaptersInfo,
   MessageSigningProtocols: () => MessageSigningProtocols,
   PermissionRequestParams: () => PermissionRequestParams,
+  ProviderPlatform: () => ProviderPlatform,
   RpcErrorCode: () => RpcErrorCode,
   RpcIdSchema: () => RpcIdSchema,
   SatsConnectAdapter: () => SatsConnectAdapter,
@@ -172,6 +173,22 @@ __export(index_exports, {
   signPsbtRequestMessageSchema: () => signPsbtRequestMessageSchema,
   signPsbtResultSchema: () => signPsbtResultSchema,
   signTransaction: () => signTransaction,
+  sparkFlashnetAddLiquidityIntentSchema: () => sparkFlashnetAddLiquidityIntentSchema,
+  sparkFlashnetClawbackIntentSchema: () => sparkFlashnetClawbackIntentSchema,
+  sparkFlashnetConfirmInitialDepositIntentSchema: () => sparkFlashnetConfirmInitialDepositIntentSchema,
+  sparkFlashnetCreateConstantProductPoolIntentSchema: () => sparkFlashnetCreateConstantProductPoolIntentSchema,
+  sparkFlashnetCreateSingleSidedPoolIntentSchema: () => sparkFlashnetCreateSingleSidedPoolIntentSchema,
+  sparkFlashnetGetJwtMethodName: () => sparkFlashnetGetJwtMethodName,
+  sparkFlashnetGetJwtParamsSchema: () => sparkFlashnetGetJwtParamsSchema,
+  sparkFlashnetGetJwtRequestMessageSchema: () => sparkFlashnetGetJwtRequestMessageSchema,
+  sparkFlashnetGetJwtResultSchema: () => sparkFlashnetGetJwtResultSchema,
+  sparkFlashnetRemoveLiquidityIntentSchema: () => sparkFlashnetRemoveLiquidityIntentSchema,
+  sparkFlashnetRouteSwapIntentSchema: () => sparkFlashnetRouteSwapIntentSchema,
+  sparkFlashnetSignIntentMethodName: () => sparkFlashnetSignIntentMethodName,
+  sparkFlashnetSignIntentParamsSchema: () => sparkFlashnetSignIntentParamsSchema,
+  sparkFlashnetSignIntentRequestMessageSchema: () => sparkFlashnetSignIntentRequestMessageSchema,
+  sparkFlashnetSignIntentResultSchema: () => sparkFlashnetSignIntentResultSchema,
+  sparkFlashnetSwapIntentSchema: () => sparkFlashnetSwapIntentSchema,
   sparkGetAddressesMethodName: () => sparkGetAddressesMethodName,
   sparkGetAddressesParamsSchema: () => sparkGetAddressesParamsSchema,
   sparkGetAddressesRequestMessageSchema: () => sparkGetAddressesRequestMessageSchema,
@@ -232,6 +249,9 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/request/index.ts
+var v35 = __toESM(require("valibot"));
+
 // src/provider/types.ts
 var v4 = __toESM(require("valibot"));
 
@@ -425,8 +445,53 @@ function getSupportedWallets() {
   return wallets;
 }
 
-// src/request/index.ts
-var v25 = __toESM(require("valibot"));
+// src/request/sanitizeRequest.ts
+var sanitizeRequest = (method, params, providerInfo) => {
+  try {
+    const [major, minor, patch] = providerInfo.version.split(".").map((part) => parseInt(part, 10));
+    const platform = providerInfo.platform;
+    if (
+      // platform is missing for versions < 1.5.0 on web and < 1.55.0 on mobile
+      !platform || platform === "web" /* Web */ && major <= 1 && minor <= 4 || platform === "mobile" /* Mobile */ && major <= 1 && minor <= 54
+    ) {
+      const v1Sanitized = sanitizeAddressPurposeRequest(method, params);
+      method = v1Sanitized.method;
+      params = v1Sanitized.params;
+    }
+  } catch {
+  }
+  return { method, params };
+};
+var sanitizeAddressPurposeRequest = (method, params) => {
+  const filterPurposes = (purposes) => purposes?.filter(
+    (purpose) => purpose !== "spark" /* Spark */ && purpose !== "starknet" /* Starknet */
+  );
+  if (method === "wallet_connect") {
+    const typedParams = params;
+    if (!typedParams) {
+      return { method, params };
+    }
+    const { addresses, ...rest } = typedParams;
+    const overrideParams = {
+      ...rest,
+      addresses: filterPurposes(addresses)
+    };
+    return { method, params: overrideParams };
+  }
+  if (method === "getAccounts") {
+    const typedParams = params;
+    const { purposes, ...rest } = typedParams;
+    const overrideParams = { ...rest, purposes: filterPurposes(purposes) };
+    return { method, params: overrideParams };
+  }
+  if (method === "getAddresses") {
+    const typedParams = params;
+    const { purposes, ...rest } = typedParams;
+    const overrideParams = { ...rest, purposes: filterPurposes(purposes) };
+    return { method, params: overrideParams };
+  }
+  return { method, params };
+};
 
 // src/request/types/btcMethods.ts
 var v6 = __toESM(require("valibot"));
@@ -645,6 +710,11 @@ var addNetworkResultSchema = v5.object({
 });
 
 // src/request/types/btcMethods.ts
+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({
@@ -652,6 +722,10 @@ var getInfoResultSchema = v6.object({
    * Version of the wallet.
    */
   version: v6.string(),
+  /**
+   * The platform the wallet is running on (web or mobile).
+   */
+  platform: v6.optional(v6.enum(ProviderPlatform)),
   /**
    * [WBIP](https://wbips.netlify.app/wbips/WBIP002) methods supported by the wallet.
    */
@@ -1039,146 +1113,319 @@ var runesTransferRequestMessageSchema = v11.object({
   }).entries
 });
 
-// src/request/types/sparkMethods/getAddresses.ts
+// src/request/types/sparkMethods/flashnetMethods/getJwt.ts
 var v12 = __toESM(require("valibot"));
+var sparkFlashnetGetJwtMethodName = "spark_flashnet_getJwt";
+var sparkFlashnetGetJwtParamsSchema = v12.null();
+var sparkFlashnetGetJwtResultSchema = v12.object({
+  /**
+   * The JWT token for authenticated requests to the Flashnet API.
+   */
+  jwt: v12.string()
+});
+var sparkFlashnetGetJwtRequestMessageSchema = v12.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v12.object({
+    method: v12.literal(sparkFlashnetGetJwtMethodName),
+    params: sparkFlashnetGetJwtParamsSchema,
+    id: v12.string()
+  }).entries
+});
+
+// src/request/types/sparkMethods/flashnetMethods/intents/addLiquidity.ts
+var v13 = __toESM(require("valibot"));
+var sparkFlashnetAddLiquidityIntentSchema = v13.object({
+  type: v13.literal("addLiquidity"),
+  data: v13.object({
+    userPublicKey: v13.string(),
+    poolId: v13.string(),
+    assetAAmount: v13.string(),
+    assetBAmount: v13.string(),
+    assetAMinAmountIn: v13.string(),
+    assetBMinAmountIn: v13.string(),
+    assetATransferId: v13.string(),
+    assetBTransferId: v13.string(),
+    nonce: v13.string()
+  })
+});
+
+// src/request/types/sparkMethods/flashnetMethods/intents/clawback.ts
+var v14 = __toESM(require("valibot"));
+var sparkFlashnetClawbackIntentSchema = v14.object({
+  type: v14.literal("clawback"),
+  data: v14.object({
+    senderPublicKey: v14.string(),
+    sparkTransferId: v14.string(),
+    lpIdentityPublicKey: v14.string(),
+    nonce: v14.string()
+  })
+});
+
+// src/request/types/sparkMethods/flashnetMethods/intents/confirmInitialDeposit.ts
+var v15 = __toESM(require("valibot"));
+var sparkFlashnetConfirmInitialDepositIntentSchema = v15.object({
+  type: v15.literal("confirmInitialDeposit"),
+  data: v15.object({
+    poolId: v15.string(),
+    assetASparkTransferId: v15.string(),
+    poolOwnerPublicKey: v15.string(),
+    nonce: v15.string()
+  })
+});
+
+// src/request/types/sparkMethods/flashnetMethods/intents/createConstantProductPool.ts
+var v16 = __toESM(require("valibot"));
+var sparkFlashnetCreateConstantProductPoolIntentSchema = v16.object({
+  type: v16.literal("createConstantProductPool"),
+  data: v16.object({
+    poolOwnerPublicKey: v16.string(),
+    assetAAddress: v16.string(),
+    assetBAddress: v16.string(),
+    lpFeeRateBps: v16.number(),
+    totalHostFeeRateBps: v16.number(),
+    nonce: v16.string()
+  })
+});
+
+// src/request/types/sparkMethods/flashnetMethods/intents/createSingleSidedPool.ts
+var v17 = __toESM(require("valibot"));
+var sparkFlashnetCreateSingleSidedPoolIntentSchema = v17.object({
+  type: v17.literal("createSingleSidedPool"),
+  data: v17.object({
+    assetAAddress: v17.string(),
+    assetBAddress: v17.string(),
+    assetAInitialReserve: v17.string(),
+    virtualReserveA: v17.union([v17.number(), v17.string()]),
+    virtualReserveB: v17.union([v17.number(), v17.string()]),
+    threshold: v17.union([v17.number(), v17.string()]),
+    lpFeeRateBps: v17.number(),
+    totalHostFeeRateBps: v17.number(),
+    poolOwnerPublicKey: v17.string(),
+    nonce: v17.string()
+  })
+});
+
+// src/request/types/sparkMethods/flashnetMethods/intents/removeLiquidity.ts
+var v18 = __toESM(require("valibot"));
+var sparkFlashnetRemoveLiquidityIntentSchema = v18.object({
+  type: v18.literal("removeLiquidity"),
+  data: v18.object({
+    userPublicKey: v18.string(),
+    poolId: v18.string(),
+    lpTokensToRemove: v18.string(),
+    nonce: v18.string()
+  })
+});
+
+// src/request/types/sparkMethods/flashnetMethods/intents/routeSwap.ts
+var v19 = __toESM(require("valibot"));
+var sparkFlashnetRouteSwapIntentSchema = v19.object({
+  type: v19.literal("executeRouteSwap"),
+  data: v19.object({
+    userPublicKey: v19.string(),
+    initialSparkTransferId: v19.string(),
+    hops: v19.array(
+      v19.object({
+        poolId: v19.string(),
+        inputAssetAddress: v19.string(),
+        outputAssetAddress: v19.string(),
+        hopIntegratorFeeRateBps: v19.optional(v19.number())
+      })
+    ),
+    inputAmount: v19.string(),
+    maxRouteSlippageBps: v19.number(),
+    minAmountOut: v19.string(),
+    defaultIntegratorFeeRateBps: v19.optional(v19.number()),
+    nonce: v19.string()
+  })
+});
+
+// src/request/types/sparkMethods/flashnetMethods/intents/swap.ts
+var v20 = __toESM(require("valibot"));
+var sparkFlashnetSwapIntentSchema = v20.object({
+  type: v20.literal("executeSwap"),
+  data: v20.object({
+    userPublicKey: v20.string(),
+    poolId: v20.string(),
+    transferId: v20.string(),
+    assetInAddress: v20.string(),
+    assetOutAddress: v20.string(),
+    amountIn: v20.string(),
+    maxSlippageBps: v20.number(),
+    minAmountOut: v20.string(),
+    totalIntegratorFeeRateBps: v20.optional(v20.number()),
+    nonce: v20.string()
+  })
+});
+
+// src/request/types/sparkMethods/flashnetMethods/signIntent.ts
+var v21 = __toESM(require("valibot"));
+var sparkFlashnetSignIntentMethodName = "spark_flashnet_signIntent";
+var sparkFlashnetSignIntentParamsSchema = v21.union([
+  sparkFlashnetSwapIntentSchema,
+  sparkFlashnetRouteSwapIntentSchema,
+  sparkFlashnetAddLiquidityIntentSchema,
+  sparkFlashnetClawbackIntentSchema,
+  sparkFlashnetConfirmInitialDepositIntentSchema,
+  sparkFlashnetCreateConstantProductPoolIntentSchema,
+  sparkFlashnetCreateSingleSidedPoolIntentSchema,
+  sparkFlashnetRemoveLiquidityIntentSchema
+]);
+var sparkFlashnetSignIntentResultSchema = v21.object({
+  /**
+   * The signed intent as a hex string.
+   */
+  signature: v21.string()
+});
+var sparkFlashnetSignIntentRequestMessageSchema = v21.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v21.object({
+    method: v21.literal(sparkFlashnetSignIntentMethodName),
+    params: sparkFlashnetSignIntentParamsSchema,
+    id: v21.string()
+  }).entries
+});
+
+// src/request/types/sparkMethods/getAddresses.ts
+var v22 = __toESM(require("valibot"));
 var sparkGetAddressesMethodName = "spark_getAddresses";
-var sparkGetAddressesParamsSchema = v12.nullish(
-  v12.object({
+var sparkGetAddressesParamsSchema = v22.nullish(
+  v22.object({
     /**
      * A message to be displayed to the user in the request prompt.
      */
-    message: v12.optional(v12.string())
+    message: v22.optional(v22.string())
   })
 );
-var sparkGetAddressesResultSchema = v12.object({
+var sparkGetAddressesResultSchema = v22.object({
   /**
    * The addresses generated for the given purposes.
    */
-  addresses: v12.array(addressSchema),
+  addresses: v22.array(addressSchema),
   network: getNetworkResultSchema
 });
-var sparkGetAddressesRequestMessageSchema = v12.object({
+var sparkGetAddressesRequestMessageSchema = v22.object({
   ...rpcRequestMessageSchema.entries,
-  ...v12.object({
-    method: v12.literal(sparkGetAddressesMethodName),
+  ...v22.object({
+    method: v22.literal(sparkGetAddressesMethodName),
     params: sparkGetAddressesParamsSchema,
-    id: v12.string()
+    id: v22.string()
   }).entries
 });
 
 // src/request/types/sparkMethods/getBalance.ts
-var v13 = __toESM(require("valibot"));
+var v23 = __toESM(require("valibot"));
 var sparkGetBalanceMethodName = "spark_getBalance";
-var sparkGetBalanceParamsSchema = v13.nullish(v13.null());
-var sparkGetBalanceResultSchema = v13.object({
+var sparkGetBalanceParamsSchema = v23.nullish(v23.null());
+var sparkGetBalanceResultSchema = v23.object({
   /**
    * The Spark Bitcoin address balance in sats in string form.
    */
-  balance: v13.string(),
-  tokenBalances: v13.array(
-    v13.object({
+  balance: v23.string(),
+  tokenBalances: v23.array(
+    v23.object({
       /* The address balance of the token in string form as it can overflow a js number */
-      balance: v13.string(),
-      tokenMetadata: v13.object({
-        tokenIdentifier: v13.string(),
-        tokenName: v13.string(),
-        tokenTicker: v13.string(),
-        decimals: v13.number(),
-        maxSupply: v13.string()
+      balance: v23.string(),
+      tokenMetadata: v23.object({
+        tokenIdentifier: v23.string(),
+        tokenName: v23.string(),
+        tokenTicker: v23.string(),
+        decimals: v23.number(),
+        maxSupply: v23.string()
       })
     })
   )
 });
-var sparkGetBalanceRequestMessageSchema = v13.object({
+var sparkGetBalanceRequestMessageSchema = v23.object({
   ...rpcRequestMessageSchema.entries,
-  ...v13.object({
-    method: v13.literal(sparkGetBalanceMethodName),
+  ...v23.object({
+    method: v23.literal(sparkGetBalanceMethodName),
     params: sparkGetBalanceParamsSchema,
-    id: v13.string()
+    id: v23.string()
   }).entries
 });
 
 // src/request/types/sparkMethods/transfer.ts
-var v14 = __toESM(require("valibot"));
+var v24 = __toESM(require("valibot"));
 var sparkTransferMethodName = "spark_transfer";
-var sparkTransferParamsSchema = v14.object({
+var sparkTransferParamsSchema = v24.object({
   /**
    * Amount of SATS to transfer as a string or number.
    */
-  amountSats: v14.union([v14.number(), v14.string()]),
+  amountSats: v24.union([v24.number(), v24.string()]),
   /**
    * The recipient's spark address.
    */
-  receiverSparkAddress: v14.string()
+  receiverSparkAddress: v24.string()
 });
-var sparkTransferResultSchema = v14.object({
+var sparkTransferResultSchema = v24.object({
   /**
    * The ID of the transaction.
    */
-  id: v14.string()
+  id: v24.string()
 });
-var sparkTransferRequestMessageSchema = v14.object({
+var sparkTransferRequestMessageSchema = v24.object({
   ...rpcRequestMessageSchema.entries,
-  ...v14.object({
-    method: v14.literal(sparkTransferMethodName),
+  ...v24.object({
+    method: v24.literal(sparkTransferMethodName),
     params: sparkTransferParamsSchema,
-    id: v14.string()
+    id: v24.string()
   }).entries
 });
 
 // src/request/types/sparkMethods/transferToken.ts
-var v15 = __toESM(require("valibot"));
+var v25 = __toESM(require("valibot"));
 var sparkTransferTokenMethodName = "spark_transferToken";
-var sparkTransferTokenParamsSchema = v15.object({
+var sparkTransferTokenParamsSchema = v25.object({
   /**
    * Amount of units of the token to transfer as a string or number.
    */
-  tokenAmount: v15.union([v15.number(), v15.string()]),
+  tokenAmount: v25.union([v25.number(), v25.string()]),
   /**
    * The Bech32m token identifier.
    */
-  tokenIdentifier: v15.string(),
+  tokenIdentifier: v25.string(),
   /**
    * The recipient's spark address.
    */
-  receiverSparkAddress: v15.string()
+  receiverSparkAddress: v25.string()
 });
-var sparkTransferTokenResultSchema = v15.object({
+var sparkTransferTokenResultSchema = v25.object({
   /**
    * The ID of the transaction.
    */
-  id: v15.string()
+  id: v25.string()
 });
-var sparkTransferTokenRequestMessageSchema = v15.object({
+var sparkTransferTokenRequestMessageSchema = v25.object({
   ...rpcRequestMessageSchema.entries,
-  ...v15.object({
-    method: v15.literal(sparkTransferTokenMethodName),
+  ...v25.object({
+    method: v25.literal(sparkTransferTokenMethodName),
     params: sparkTransferTokenParamsSchema,
-    id: v15.string()
+    id: v25.string()
   }).entries
 });
 
 // src/request/types/stxMethods/callContract.ts
-var v16 = __toESM(require("valibot"));
+var v26 = __toESM(require("valibot"));
 var stxCallContractMethodName = "stx_callContract";
-var stxCallContractParamsSchema = v16.object({
+var stxCallContractParamsSchema = v26.object({
   /**
    * The contract principal.
    *
    * E.g. `"SPKE...GD5C.my-contract"`
    */
-  contract: v16.string(),
+  contract: v26.string(),
   /**
    * The name of the function to call.
    *
    * Note: spec changes ongoing,
    * https://github.com/stacksgov/sips/pull/166#pullrequestreview-1914236999
    */
-  functionName: v16.string(),
+  functionName: v26.string(),
   /**
    * @deprecated in favor of `functionArgs` for @stacks/connect compatibility
    */
-  arguments: v16.optional(v16.array(v16.string())),
+  arguments: v26.optional(v26.array(v26.string())),
   /**
    * The function's arguments. The arguments are expected to be hex-encoded
    * strings of Clarity values.
@@ -1193,274 +1440,274 @@ var stxCallContractParamsSchema = v16.object({
    * const hexArgs = functionArgs.map(cvToHex);
    * ```
    */
-  functionArgs: v16.optional(v16.array(v16.string())),
+  functionArgs: v26.optional(v26.array(v26.string())),
   /**
    * The post conditions to apply to the contract call.
    */
-  postConditions: v16.optional(v16.array(v16.string())),
+  postConditions: v26.optional(v26.array(v26.string())),
   /**
    * The mode to apply to the post conditions.
    */
-  postConditionMode: v16.optional(v16.union([v16.literal("allow"), v16.literal("deny")]))
+  postConditionMode: v26.optional(v26.union([v26.literal("allow"), v26.literal("deny")]))
 });
-var stxCallContractResultSchema = v16.object({
+var stxCallContractResultSchema = v26.object({
   /**
    * The ID of the transaction.
    */
-  txid: v16.string(),
+  txid: v26.string(),
   /**
    * A Stacks transaction as a hex-encoded string.
    */
-  transaction: v16.string()
+  transaction: v26.string()
 });
-var stxCallContractRequestMessageSchema = v16.object({
+var stxCallContractRequestMessageSchema = v26.object({
   ...rpcRequestMessageSchema.entries,
-  ...v16.object({
-    method: v16.literal(stxCallContractMethodName),
+  ...v26.object({
+    method: v26.literal(stxCallContractMethodName),
     params: stxCallContractParamsSchema,
-    id: v16.string()
+    id: v26.string()
   }).entries
 });
 
 // src/request/types/stxMethods/deployContract.ts
-var v17 = __toESM(require("valibot"));
+var v27 = __toESM(require("valibot"));
 var stxDeployContractMethodName = "stx_deployContract";
-var stxDeployContractParamsSchema = v17.object({
+var stxDeployContractParamsSchema = v27.object({
   /**
    * Name of the contract.
    */
-  name: v17.string(),
+  name: v27.string(),
   /**
    * The source code of the Clarity contract.
    */
-  clarityCode: v17.string(),
+  clarityCode: v27.string(),
   /**
    * The version of the Clarity contract.
    */
-  clarityVersion: v17.optional(v17.number()),
+  clarityVersion: v27.optional(v27.number()),
   /**
    * The post conditions to apply to the contract call.
    */
-  postConditions: v17.optional(v17.array(v17.string())),
+  postConditions: v27.optional(v27.array(v27.string())),
   /**
    * The mode to apply to the post conditions.
    */
-  postConditionMode: v17.optional(v17.union([v17.literal("allow"), v17.literal("deny")]))
+  postConditionMode: v27.optional(v27.union([v27.literal("allow"), v27.literal("deny")]))
 });
-var stxDeployContractResultSchema = v17.object({
+var stxDeployContractResultSchema = v27.object({
   /**
    * The ID of the transaction.
    */
-  txid: v17.string(),
+  txid: v27.string(),
   /**
    * A Stacks transaction as a hex-encoded string.
    */
-  transaction: v17.string()
+  transaction: v27.string()
 });
-var stxDeployContractRequestMessageSchema = v17.object({
+var stxDeployContractRequestMessageSchema = v27.object({
   ...rpcRequestMessageSchema.entries,
-  ...v17.object({
-    method: v17.literal(stxDeployContractMethodName),
+  ...v27.object({
+    method: v27.literal(stxDeployContractMethodName),
     params: stxDeployContractParamsSchema,
-    id: v17.string()
+    id: v27.string()
   }).entries
 });
 
 // src/request/types/stxMethods/getAccounts.ts
-var v18 = __toESM(require("valibot"));
+var v28 = __toESM(require("valibot"));
 var stxGetAccountsMethodName = "stx_getAccounts";
-var stxGetAccountsParamsSchema = v18.nullish(v18.null());
-var stxGetAccountsResultSchema = v18.object({
+var stxGetAccountsParamsSchema = v28.nullish(v28.null());
+var stxGetAccountsResultSchema = v28.object({
   /**
    * The addresses generated for the given purposes.
    */
-  addresses: v18.array(
-    v18.object({
-      address: v18.string(),
-      publicKey: v18.string(),
-      gaiaHubUrl: v18.string(),
-      gaiaAppKey: v18.string()
+  addresses: v28.array(
+    v28.object({
+      address: v28.string(),
+      publicKey: v28.string(),
+      gaiaHubUrl: v28.string(),
+      gaiaAppKey: v28.string()
     })
   ),
   network: getNetworkResultSchema
 });
-var stxGetAccountsRequestMessageSchema = v18.object({
+var stxGetAccountsRequestMessageSchema = v28.object({
   ...rpcRequestMessageSchema.entries,
-  ...v18.object({
-    method: v18.literal(stxGetAccountsMethodName),
+  ...v28.object({
+    method: v28.literal(stxGetAccountsMethodName),
     params: stxGetAccountsParamsSchema,
-    id: v18.string()
+    id: v28.string()
   }).entries
 });
 
 // src/request/types/stxMethods/getAddresses.ts
-var v19 = __toESM(require("valibot"));
+var v29 = __toESM(require("valibot"));
 var stxGetAddressesMethodName = "stx_getAddresses";
-var stxGetAddressesParamsSchema = v19.nullish(
-  v19.object({
+var stxGetAddressesParamsSchema = v29.nullish(
+  v29.object({
     /**
      * A message to be displayed to the user in the request prompt.
      */
-    message: v19.optional(v19.string())
+    message: v29.optional(v29.string())
   })
 );
-var stxGetAddressesResultSchema = v19.object({
+var stxGetAddressesResultSchema = v29.object({
   /**
    * The addresses generated for the given purposes.
    */
-  addresses: v19.array(addressSchema),
+  addresses: v29.array(addressSchema),
   network: getNetworkResultSchema
 });
-var stxGetAddressesRequestMessageSchema = v19.object({
+var stxGetAddressesRequestMessageSchema = v29.object({
   ...rpcRequestMessageSchema.entries,
-  ...v19.object({
-    method: v19.literal(stxGetAddressesMethodName),
+  ...v29.object({
+    method: v29.literal(stxGetAddressesMethodName),
     params: stxGetAddressesParamsSchema,
-    id: v19.string()
+    id: v29.string()
   }).entries
 });
 
 // src/request/types/stxMethods/signMessage.ts
-var v20 = __toESM(require("valibot"));
+var v30 = __toESM(require("valibot"));
 var stxSignMessageMethodName = "stx_signMessage";
-var stxSignMessageParamsSchema = v20.object({
+var stxSignMessageParamsSchema = v30.object({
   /**
    * The message to sign.
    */
-  message: v20.string()
+  message: v30.string()
 });
-var stxSignMessageResultSchema = v20.object({
+var stxSignMessageResultSchema = v30.object({
   /**
    * The signature of the message.
    */
-  signature: v20.string(),
+  signature: v30.string(),
   /**
    * The public key used to sign the message.
    */
-  publicKey: v20.string()
+  publicKey: v30.string()
 });
-var stxSignMessageRequestMessageSchema = v20.object({
+var stxSignMessageRequestMessageSchema = v30.object({
   ...rpcRequestMessageSchema.entries,
-  ...v20.object({
-    method: v20.literal(stxSignMessageMethodName),
+  ...v30.object({
+    method: v30.literal(stxSignMessageMethodName),
     params: stxSignMessageParamsSchema,
-    id: v20.string()
+    id: v30.string()
   }).entries
 });
 
 // src/request/types/stxMethods/signStructuredMessage.ts
-var v21 = __toESM(require("valibot"));
+var v31 = __toESM(require("valibot"));
 var stxSignStructuredMessageMethodName = "stx_signStructuredMessage";
-var stxSignStructuredMessageParamsSchema = v21.object({
+var stxSignStructuredMessageParamsSchema = v31.object({
   /**
    * The domain to be signed.
    */
-  domain: v21.string(),
+  domain: v31.string(),
   /**
    * Message payload to be signed.
    */
-  message: v21.string(),
+  message: v31.string(),
   /**
    * The public key to sign the message with.
    */
-  publicKey: v21.optional(v21.string())
+  publicKey: v31.optional(v31.string())
 });
-var stxSignStructuredMessageResultSchema = v21.object({
+var stxSignStructuredMessageResultSchema = v31.object({
   /**
    * Signature of the message.
    */
-  signature: v21.string(),
+  signature: v31.string(),
   /**
    * Public key as hex-encoded string.
    */
-  publicKey: v21.string()
+  publicKey: v31.string()
 });
-var stxSignStructuredMessageRequestMessageSchema = v21.object({
+var stxSignStructuredMessageRequestMessageSchema = v31.object({
   ...rpcRequestMessageSchema.entries,
-  ...v21.object({
-    method: v21.literal(stxSignStructuredMessageMethodName),
+  ...v31.object({
+    method: v31.literal(stxSignStructuredMessageMethodName),
     params: stxSignStructuredMessageParamsSchema,
-    id: v21.string()
+    id: v31.string()
   }).entries
 });
 
 // src/request/types/stxMethods/signTransaction.ts
-var v22 = __toESM(require("valibot"));
+var v32 = __toESM(require("valibot"));
 var stxSignTransactionMethodName = "stx_signTransaction";
-var stxSignTransactionParamsSchema = v22.object({
+var stxSignTransactionParamsSchema = v32.object({
   /**
    * The transaction to sign as a hex-encoded string.
    */
-  transaction: v22.string(),
+  transaction: v32.string(),
   /**
    * The public key to sign the transaction with. The wallet may use any key
    * when not provided.
    */
-  pubkey: v22.optional(v22.string()),
+  pubkey: v32.optional(v32.string()),
   /**
    * Whether to broadcast the transaction after signing. Defaults to `true`.
    */
-  broadcast: v22.optional(v22.boolean())
+  broadcast: v32.optional(v32.boolean())
 });
-var stxSignTransactionResultSchema = v22.object({
+var stxSignTransactionResultSchema = v32.object({
   /**
    * The signed transaction as a hex-encoded string.
    */
-  transaction: v22.string()
+  transaction: v32.string()
 });
-var stxSignTransactionRequestMessageSchema = v22.object({
+var stxSignTransactionRequestMessageSchema = v32.object({
   ...rpcRequestMessageSchema.entries,
-  ...v22.object({
-    method: v22.literal(stxSignTransactionMethodName),
+  ...v32.object({
+    method: v32.literal(stxSignTransactionMethodName),
     params: stxSignTransactionParamsSchema,
-    id: v22.string()
+    id: v32.string()
   }).entries
 });
 
 // src/request/types/stxMethods/signTransactions.ts
-var v23 = __toESM(require("valibot"));
+var v33 = __toESM(require("valibot"));
 var stxSignTransactionsMethodName = "stx_signTransactions";
-var stxSignTransactionsParamsSchema = v23.object({
+var stxSignTransactionsParamsSchema = v33.object({
   /**
    * The transactions to sign as hex-encoded strings.
    */
-  transactions: v23.pipe(
-    v23.array(
-      v23.pipe(
-        v23.string(),
-        v23.check((hex) => {
+  transactions: v33.pipe(
+    v33.array(
+      v33.pipe(
+        v33.string(),
+        v33.check((hex) => {
           return true;
         }, "Invalid hex-encoded Stacks transaction.")
       )
     ),
-    v23.minLength(1)
+    v33.minLength(1)
   ),
   /**
    * Whether the signed transactions should be broadcast after signing. Defaults
    * to `true`.
    */
-  broadcast: v23.optional(v23.boolean())
+  broadcast: v33.optional(v33.boolean())
 });
-var stxSignTransactionsResultSchema = v23.object({
+var stxSignTransactionsResultSchema = v33.object({
   /**
    * The signed transactions as hex-encoded strings, in the same order as in the
    * sign request.
    */
-  transactions: v23.array(v23.string())
+  transactions: v33.array(v33.string())
 });
-var stxSignTransactionsRequestMessageSchema = v23.object({
+var stxSignTransactionsRequestMessageSchema = v33.object({
   ...rpcRequestMessageSchema.entries,
-  ...v23.object({
-    method: v23.literal(stxSignTransactionsMethodName),
+  ...v33.object({
+    method: v33.literal(stxSignTransactionsMethodName),
     params: stxSignTransactionsParamsSchema,
-    id: v23.string()
+    id: v33.string()
   }).entries
 });
 
 // src/request/types/stxMethods/transferStx.ts
-var v24 = __toESM(require("valibot"));
+var v34 = __toESM(require("valibot"));
 var stxTransferStxMethodName = "stx_transferStx";
-var stxTransferStxParamsSchema = v24.object({
+var stxTransferStxParamsSchema = v34.object({
   /**
    * Amount of STX tokens to transfer in microstacks as a string. Anything
    * parseable by `BigInt` is acceptable.
@@ -1473,23 +1720,23 @@ var stxTransferStxParamsSchema = v24.object({
    * const amount3 = '1234';
    * ```
    */
-  amount: v24.union([v24.number(), v24.string()]),
+  amount: v34.union([v34.number(), v34.string()]),
   /**
    * The recipient's principal.
    */
-  recipient: v24.string(),
+  recipient: v34.string(),
   /**
    * A string representing the memo.
    */
-  memo: v24.optional(v24.string()),
+  memo: v34.optional(v34.string()),
   /**
    * Version of parameter format.
    */
-  version: v24.optional(v24.string()),
+  version: v34.optional(v34.string()),
   /**
    * The mode of the post conditions.
    */
-  postConditionMode: v24.optional(v24.number()),
+  postConditionMode: v34.optional(v34.number()),
   /**
    * A hex-encoded string representing the post conditions.
    *
@@ -1502,52 +1749,43 @@ var stxTransferStxParamsSchema = v24.object({
    * const hexPostCondition = serializePostCondition(postCondition).toString('hex');
    * ```
    */
-  postConditions: v24.optional(v24.array(v24.string())),
+  postConditions: v34.optional(v34.array(v34.string())),
   /**
    * The public key to sign the transaction with. The wallet may use any key
    * when not provided.
    */
-  pubkey: v24.optional(v24.string())
+  pubkey: v34.optional(v34.string())
 });
-var stxTransferStxResultSchema = v24.object({
+var stxTransferStxResultSchema = v34.object({
   /**
    * The ID of the transaction.
    */
-  txid: v24.string(),
+  txid: v34.string(),
   /**
    * A Stacks transaction as a hex-encoded string.
    */
-  transaction: v24.string()
+  transaction: v34.string()
 });
-var stxTransferStxRequestMessageSchema = v24.object({
+var stxTransferStxRequestMessageSchema = v34.object({
   ...rpcRequestMessageSchema.entries,
-  ...v24.object({
-    method: v24.literal(stxTransferStxMethodName),
+  ...v34.object({
+    method: v34.literal(stxTransferStxMethodName),
     params: stxTransferStxParamsSchema,
-    id: v24.string()
+    id: v34.string()
   }).entries
 });
 
 // src/request/index.ts
-var request = async (method, params, providerId) => {
-  let provider = window.XverseProviders?.BitcoinProvider || window.BitcoinProvider;
-  if (providerId) {
-    provider = await getProviderById(providerId);
-  }
-  if (!provider) {
-    throw new Error("no wallet provider was found");
-  }
-  if (!method) {
-    throw new Error("A wallet method is required");
-  }
+var cache = {};
+var requestInternal = async (provider, method, params) => {
   const response = await provider.request(method, params);
-  if (v25.is(rpcErrorResponseMessageSchema, response)) {
+  if (v35.is(rpcErrorResponseMessageSchema, response)) {
     return {
       status: "error",
       error: response.error
     };
   }
-  if (v25.is(rpcSuccessResponseMessageSchema, response)) {
+  if (v35.is(rpcSuccessResponseMessageSchema, response)) {
     return {
       status: "success",
       result: response.result
@@ -1562,6 +1800,39 @@ var request = async (method, params, providerId) => {
     }
   };
 };
+var request = async (method, params, providerId) => {
+  let provider = window.XverseProviders?.BitcoinProvider || window.BitcoinProvider;
+  if (providerId) {
+    provider = await getProviderById(providerId);
+  }
+  if (!provider) {
+    throw new Error("no wallet provider was found");
+  }
+  if (!method) {
+    throw new Error("A wallet method is required");
+  }
+  if (!cache.providerInfo) {
+    const infoResult = await requestInternal(provider, "getInfo", null);
+    if (infoResult.status === "success") {
+      cache.providerInfo = infoResult.result;
+    }
+  }
+  if (cache.providerInfo) {
+    if (method === "getInfo") {
+      return {
+        status: "success",
+        result: cache.providerInfo
+      };
+    }
+    const sanitized = sanitizeRequest(method, params, cache.providerInfo);
+    if (sanitized.overrideResponse) {
+      return sanitized.overrideResponse;
+    }
+    method = sanitized.method;
+    params = sanitized.params;
+  }
+  return requestInternal(provider, method, params);
+};
 var addListener = (...rawArgs) => {
   const [listenerInfo, providerId] = (() => {
     if (rawArgs.length === 1) {
@@ -2567,6 +2838,7 @@ var signMultipleTransactions = async (options) => {
   DefaultAdaptersInfo,
   MessageSigningProtocols,
   PermissionRequestParams,
+  ProviderPlatform,
   RpcErrorCode,
   RpcIdSchema,
   SatsConnectAdapter,
@@ -2702,6 +2974,22 @@ var signMultipleTransactions = async (options) => {
   signPsbtRequestMessageSchema,
   signPsbtResultSchema,
   signTransaction,
+  sparkFlashnetAddLiquidityIntentSchema,
+  sparkFlashnetClawbackIntentSchema,
+  sparkFlashnetConfirmInitialDepositIntentSchema,
+  sparkFlashnetCreateConstantProductPoolIntentSchema,
+  sparkFlashnetCreateSingleSidedPoolIntentSchema,
+  sparkFlashnetGetJwtMethodName,
+  sparkFlashnetGetJwtParamsSchema,
+  sparkFlashnetGetJwtRequestMessageSchema,
+  sparkFlashnetGetJwtResultSchema,
+  sparkFlashnetRemoveLiquidityIntentSchema,
+  sparkFlashnetRouteSwapIntentSchema,
+  sparkFlashnetSignIntentMethodName,
+  sparkFlashnetSignIntentParamsSchema,
+  sparkFlashnetSignIntentRequestMessageSchema,
+  sparkFlashnetSignIntentResultSchema,
+  sparkFlashnetSwapIntentSchema,
   sparkGetAddressesMethodName,
   sparkGetAddressesParamsSchema,
   sparkGetAddressesRequestMessageSchema,