@sats-connect/core 0.11.0 → 0.12.0-9c448ee

package/dist/index.mjs

@@ -1,5 +1,5 @@
 // src/request/index.ts
-import * as v39 from "valibot";
+import * as v40 from "valibot";
 
 // src/provider/types.ts
 import * as v4 from "valibot";
@@ -862,224 +862,247 @@ var runesTransferRequestMessageSchema = v11.object({
   }).entries
 });
 
-// src/request/types/sparkMethods/flashnetMethods/executeRouteSwap.ts
+// src/request/types/sparkMethods/flashnetMethods/executeClawback.ts
 import * as v12 from "valibot";
-var sparkFlashnetExecuteRouteSwapMethodName = "spark_flashnet_executeRouteSwap";
-var sparkFlashnetExecuteRouteSwapParamsSchema = v12.object({
-  hops: v12.array(
-    v12.object({
-      poolId: v12.string(),
-      assetInAddress: v12.string(),
-      assetOutAddress: v12.string(),
-      hopIntegratorFeeRateBps: v12.optional(v12.number())
-    })
-  ),
-  initialAssetAddress: v12.string(),
-  inputAmount: v12.string(),
-  maxRouteSlippageBps: v12.string(),
-  minAmountOut: v12.optional(v12.string()),
-  integratorFeeRateBps: v12.optional(v12.number()),
-  integratorPublicKey: v12.optional(v12.string())
-});
-var sparkFlashnetExecuteRouteSwapResultSchema = v12.object({
+var sparkFlashnetExecuteClawbackMethodName = "spark_flashnet_executeClawback";
+var sparkFlashnetExecuteClawbackParamsSchema = v12.object({
+  sparkTransferId: v12.string(),
+  lpIdentityPublicKey: v12.string()
+});
+var sparkFlashnetExecuteClawbackResultSchema = v12.object({
   requestId: v12.string(),
   accepted: v12.boolean(),
-  outputAmount: v12.string(),
-  executionPrice: v12.string(),
-  finalOutboundTransferId: v12.string(),
+  internalRequestId: v12.optional(v12.string()),
+  sparkStatusTrackingId: v12.optional(v12.string()),
   error: v12.optional(v12.string())
 });
-var sparkFlashnetExecuteRouteSwapRequestMessageSchema = v12.object({
+var sparkFlashnetExecuteClawbackRequestMessageSchema = v12.object({
   ...rpcRequestMessageSchema.entries,
   ...v12.object({
-    method: v12.literal(sparkFlashnetExecuteRouteSwapMethodName),
-    params: sparkFlashnetExecuteRouteSwapParamsSchema,
+    method: v12.literal(sparkFlashnetExecuteClawbackMethodName),
+    params: sparkFlashnetExecuteClawbackParamsSchema,
     id: v12.string()
   }).entries
 });
 
-// src/request/types/sparkMethods/flashnetMethods/executeSwap.ts
+// src/request/types/sparkMethods/flashnetMethods/executeRouteSwap.ts
 import * as v13 from "valibot";
-var sparkFlashnetExecuteSwapMethodName = "spark_flashnet_executeSwap";
-var sparkFlashnetExecuteSwapParamsSchema = v13.object({
-  poolId: v13.string(),
-  assetInAddress: v13.string(),
-  assetOutAddress: v13.string(),
-  amountIn: v13.string(),
-  maxSlippageBps: v13.number(),
+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())
+    })
+  ),
+  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 sparkFlashnetExecuteSwapResultSchema = v13.object({
+var sparkFlashnetExecuteRouteSwapResultSchema = v13.object({
   requestId: v13.string(),
   accepted: v13.boolean(),
-  amountOut: v13.optional(v13.string()),
-  feeAmount: v13.optional(v13.string()),
-  executionPrice: v13.optional(v13.string()),
-  assetOutAddress: v13.optional(v13.string()),
-  assetInAddress: v13.optional(v13.string()),
-  outboundTransferId: v13.optional(v13.string()),
+  outputAmount: v13.string(),
+  executionPrice: v13.string(),
+  finalOutboundTransferId: v13.string(),
   error: v13.optional(v13.string())
 });
-var sparkFlashnetExecuteSwapRequestMessageSchema = v13.object({
+var sparkFlashnetExecuteRouteSwapRequestMessageSchema = v13.object({
   ...rpcRequestMessageSchema.entries,
   ...v13.object({
-    method: v13.literal(sparkFlashnetExecuteSwapMethodName),
-    params: sparkFlashnetExecuteSwapParamsSchema,
+    method: v13.literal(sparkFlashnetExecuteRouteSwapMethodName),
+    params: sparkFlashnetExecuteRouteSwapParamsSchema,
     id: v13.string()
   }).entries
 });
 
-// src/request/types/sparkMethods/flashnetMethods/getJwt.ts
+// src/request/types/sparkMethods/flashnetMethods/executeSwap.ts
 import * as v14 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({
+  ...rpcRequestMessageSchema.entries,
+  ...v14.object({
+    method: v14.literal(sparkFlashnetExecuteSwapMethodName),
+    params: sparkFlashnetExecuteSwapParamsSchema,
+    id: v14.string()
+  }).entries
+});
+
+// src/request/types/sparkMethods/flashnetMethods/getJwt.ts
+import * as v15 from "valibot";
 var sparkFlashnetGetJwtMethodName = "spark_flashnet_getJwt";
-var sparkFlashnetGetJwtParamsSchema = v14.null();
-var sparkFlashnetGetJwtResultSchema = v14.object({
+var sparkFlashnetGetJwtParamsSchema = v15.null();
+var sparkFlashnetGetJwtResultSchema = v15.object({
   /**
    * The JWT token for authenticated requests to the Flashnet API.
    */
-  jwt: v14.string()
+  jwt: v15.string()
 });
-var sparkFlashnetGetJwtRequestMessageSchema = v14.object({
+var sparkFlashnetGetJwtRequestMessageSchema = v15.object({
   ...rpcRequestMessageSchema.entries,
-  ...v14.object({
-    method: v14.literal(sparkFlashnetGetJwtMethodName),
+  ...v15.object({
+    method: v15.literal(sparkFlashnetGetJwtMethodName),
     params: sparkFlashnetGetJwtParamsSchema,
-    id: v14.string()
+    id: v15.string()
   }).entries
 });
 
 // src/request/types/sparkMethods/flashnetMethods/intents/addLiquidity.ts
-import * as v15 from "valibot";
-var sparkFlashnetAddLiquidityIntentSchema = v15.object({
-  type: v15.literal("addLiquidity"),
-  data: v15.object({
-    userPublicKey: v15.string(),
-    poolId: v15.string(),
-    assetAAmount: v15.string(),
-    assetBAmount: v15.string(),
-    assetAMinAmountIn: v15.string(),
-    assetBMinAmountIn: v15.string(),
-    assetATransferId: v15.string(),
-    assetBTransferId: v15.string(),
-    nonce: v15.string()
-  })
-});
-
-// src/request/types/sparkMethods/flashnetMethods/intents/clawback.ts
 import * as v16 from "valibot";
-var sparkFlashnetClawbackIntentSchema = v16.object({
-  type: v16.literal("clawback"),
+var sparkFlashnetAddLiquidityIntentSchema = v16.object({
+  type: v16.literal("addLiquidity"),
   data: v16.object({
-    senderPublicKey: v16.string(),
-    sparkTransferId: v16.string(),
-    lpIdentityPublicKey: v16.string(),
+    userPublicKey: v16.string(),
+    poolId: v16.string(),
+    assetAAmount: v16.string(),
+    assetBAmount: v16.string(),
+    assetAMinAmountIn: v16.string(),
+    assetBMinAmountIn: v16.string(),
+    assetATransferId: v16.string(),
+    assetBTransferId: v16.string(),
     nonce: v16.string()
   })
 });
 
-// src/request/types/sparkMethods/flashnetMethods/intents/confirmInitialDeposit.ts
+// src/request/types/sparkMethods/flashnetMethods/intents/clawback.ts
 import * as v17 from "valibot";
-var sparkFlashnetConfirmInitialDepositIntentSchema = v17.object({
-  type: v17.literal("confirmInitialDeposit"),
+var sparkFlashnetClawbackIntentSchema = v17.object({
+  type: v17.literal("clawback"),
   data: v17.object({
-    poolId: v17.string(),
-    assetASparkTransferId: v17.string(),
-    poolOwnerPublicKey: v17.string(),
+    senderPublicKey: v17.string(),
+    sparkTransferId: v17.string(),
+    lpIdentityPublicKey: v17.string(),
     nonce: v17.string()
   })
 });
 
-// src/request/types/sparkMethods/flashnetMethods/intents/createConstantProductPool.ts
+// src/request/types/sparkMethods/flashnetMethods/intents/confirmInitialDeposit.ts
 import * as v18 from "valibot";
-var sparkFlashnetCreateConstantProductPoolIntentSchema = v18.object({
-  type: v18.literal("createConstantProductPool"),
+var sparkFlashnetConfirmInitialDepositIntentSchema = v18.object({
+  type: v18.literal("confirmInitialDeposit"),
   data: v18.object({
+    poolId: v18.string(),
+    assetASparkTransferId: v18.string(),
     poolOwnerPublicKey: v18.string(),
-    assetAAddress: v18.string(),
-    assetBAddress: v18.string(),
-    lpFeeRateBps: v18.union([v18.number(), v18.string()]),
-    totalHostFeeRateBps: v18.union([v18.number(), v18.string()]),
     nonce: v18.string()
   })
 });
 
-// src/request/types/sparkMethods/flashnetMethods/intents/createSingleSidedPool.ts
+// src/request/types/sparkMethods/flashnetMethods/intents/createConstantProductPool.ts
 import * as v19 from "valibot";
-var sparkFlashnetCreateSingleSidedPoolIntentSchema = v19.object({
-  type: v19.literal("createSingleSidedPool"),
+var sparkFlashnetCreateConstantProductPoolIntentSchema = v19.object({
+  type: v19.literal("createConstantProductPool"),
   data: v19.object({
+    poolOwnerPublicKey: v19.string(),
     assetAAddress: v19.string(),
     assetBAddress: v19.string(),
-    assetAInitialReserve: v19.string(),
-    virtualReserveA: v19.union([v19.number(), v19.string()]),
-    virtualReserveB: v19.union([v19.number(), v19.string()]),
-    threshold: v19.union([v19.number(), v19.string()]),
     lpFeeRateBps: v19.union([v19.number(), v19.string()]),
     totalHostFeeRateBps: v19.union([v19.number(), v19.string()]),
-    poolOwnerPublicKey: v19.string(),
     nonce: v19.string()
   })
 });
 
-// src/request/types/sparkMethods/flashnetMethods/intents/removeLiquidity.ts
+// src/request/types/sparkMethods/flashnetMethods/intents/createSingleSidedPool.ts
 import * as v20 from "valibot";
-var sparkFlashnetRemoveLiquidityIntentSchema = v20.object({
-  type: v20.literal("removeLiquidity"),
+var sparkFlashnetCreateSingleSidedPoolIntentSchema = v20.object({
+  type: v20.literal("createSingleSidedPool"),
   data: v20.object({
-    userPublicKey: v20.string(),
-    poolId: v20.string(),
-    lpTokensToRemove: v20.string(),
+    assetAAddress: v20.string(),
+    assetBAddress: v20.string(),
+    assetAInitialReserve: v20.string(),
+    virtualReserveA: v20.union([v20.number(), v20.string()]),
+    virtualReserveB: v20.union([v20.number(), v20.string()]),
+    threshold: v20.union([v20.number(), v20.string()]),
+    lpFeeRateBps: v20.union([v20.number(), v20.string()]),
+    totalHostFeeRateBps: v20.union([v20.number(), v20.string()]),
+    poolOwnerPublicKey: v20.string(),
     nonce: v20.string()
   })
 });
 
-// src/request/types/sparkMethods/flashnetMethods/intents/routeSwap.ts
+// src/request/types/sparkMethods/flashnetMethods/intents/removeLiquidity.ts
 import * as v21 from "valibot";
-var sparkFlashnetRouteSwapIntentSchema = v21.object({
-  type: v21.literal("executeRouteSwap"),
+var sparkFlashnetRemoveLiquidityIntentSchema = v21.object({
+  type: v21.literal("removeLiquidity"),
   data: v21.object({
     userPublicKey: v21.string(),
-    initialSparkTransferId: v21.string(),
-    hops: v21.array(
-      v21.object({
-        poolId: v21.string(),
-        inputAssetAddress: v21.string(),
-        outputAssetAddress: v21.string(),
-        hopIntegratorFeeRateBps: v21.optional(v21.union([v21.number(), v21.string()]))
-      })
-    ),
-    inputAmount: v21.string(),
-    maxRouteSlippageBps: v21.union([v21.number(), v21.string()]),
-    minAmountOut: v21.string(),
-    defaultIntegratorFeeRateBps: v21.optional(v21.union([v21.number(), v21.string()])),
+    poolId: v21.string(),
+    lpTokensToRemove: v21.string(),
     nonce: v21.string()
   })
 });
 
-// src/request/types/sparkMethods/flashnetMethods/intents/swap.ts
+// src/request/types/sparkMethods/flashnetMethods/intents/routeSwap.ts
 import * as v22 from "valibot";
-var sparkFlashnetSwapIntentSchema = v22.object({
-  type: v22.literal("executeSwap"),
+var sparkFlashnetRouteSwapIntentSchema = v22.object({
+  type: v22.literal("executeRouteSwap"),
   data: v22.object({
     userPublicKey: v22.string(),
-    poolId: v22.string(),
-    transferId: v22.string(),
-    assetInAddress: v22.string(),
-    assetOutAddress: v22.string(),
-    amountIn: v22.string(),
-    maxSlippageBps: v22.union([v22.number(), v22.string()]),
+    initialSparkTransferId: v22.string(),
+    hops: v22.array(
+      v22.object({
+        poolId: v22.string(),
+        inputAssetAddress: v22.string(),
+        outputAssetAddress: v22.string(),
+        hopIntegratorFeeRateBps: v22.optional(v22.union([v22.number(), v22.string()]))
+      })
+    ),
+    inputAmount: v22.string(),
+    maxRouteSlippageBps: v22.union([v22.number(), v22.string()]),
     minAmountOut: v22.string(),
-    totalIntegratorFeeRateBps: v22.optional(v22.union([v22.number(), v22.string()])),
+    defaultIntegratorFeeRateBps: v22.optional(v22.union([v22.number(), v22.string()])),
     nonce: v22.string()
   })
 });
 
-// src/request/types/sparkMethods/flashnetMethods/signIntent.ts
+// src/request/types/sparkMethods/flashnetMethods/intents/swap.ts
 import * as v23 from "valibot";
+var sparkFlashnetSwapIntentSchema = v23.object({
+  type: v23.literal("executeSwap"),
+  data: v23.object({
+    userPublicKey: v23.string(),
+    poolId: v23.string(),
+    transferId: v23.string(),
+    assetInAddress: v23.string(),
+    assetOutAddress: v23.string(),
+    amountIn: v23.string(),
+    maxSlippageBps: v23.union([v23.number(), v23.string()]),
+    minAmountOut: v23.string(),
+    totalIntegratorFeeRateBps: v23.optional(v23.union([v23.number(), v23.string()])),
+    nonce: v23.string()
+  })
+});
+
+// src/request/types/sparkMethods/flashnetMethods/signIntent.ts
+import * as v24 from "valibot";
 var sparkFlashnetSignIntentMethodName = "spark_flashnet_signIntent";
-var sparkFlashnetSignIntentParamsSchema = v23.union([
+var sparkFlashnetSignIntentParamsSchema = v24.union([
   sparkFlashnetSwapIntentSchema,
   sparkFlashnetRouteSwapIntentSchema,
   sparkFlashnetAddLiquidityIntentSchema,
@@ -1089,109 +1112,109 @@ var sparkFlashnetSignIntentParamsSchema = v23.union([
   sparkFlashnetCreateSingleSidedPoolIntentSchema,
   sparkFlashnetRemoveLiquidityIntentSchema
 ]);
-var sparkFlashnetSignIntentResultSchema = v23.object({
+var sparkFlashnetSignIntentResultSchema = v24.object({
   /**
    * The signed intent as a hex string.
    */
-  signature: v23.string()
+  signature: v24.string()
 });
-var sparkFlashnetSignIntentRequestMessageSchema = v23.object({
+var sparkFlashnetSignIntentRequestMessageSchema = v24.object({
   ...rpcRequestMessageSchema.entries,
-  ...v23.object({
-    method: v23.literal(sparkFlashnetSignIntentMethodName),
+  ...v24.object({
+    method: v24.literal(sparkFlashnetSignIntentMethodName),
     params: sparkFlashnetSignIntentParamsSchema,
-    id: v23.string()
+    id: v24.string()
   }).entries
 });
 
 // src/request/types/sparkMethods/flashnetMethods/signStructuredMessage.ts
-import * as v24 from "valibot";
+import * as v25 from "valibot";
 var sparkFlashnetSignStructuredMessageMethodName = "spark_flashnet_signStructuredMessage";
-var sparkFlashnetSignStructuredMessageParamsSchema = v24.object({
-  message: v24.string()
+var sparkFlashnetSignStructuredMessageParamsSchema = v25.object({
+  message: v25.string()
 });
-var sparkFlashnetSignStructuredMessageResultSchema = v24.object({
-  message: v24.string(),
-  signature: v24.string()
+var sparkFlashnetSignStructuredMessageResultSchema = v25.object({
+  message: v25.string(),
+  signature: v25.string()
 });
-var sparkFlashnetSignStructuredMessageRequestMessageSchema = v24.object({
+var sparkFlashnetSignStructuredMessageRequestMessageSchema = v25.object({
   ...rpcRequestMessageSchema.entries,
-  ...v24.object({
-    method: v24.literal(sparkFlashnetSignStructuredMessageMethodName),
+  ...v25.object({
+    method: v25.literal(sparkFlashnetSignStructuredMessageMethodName),
     params: sparkFlashnetSignStructuredMessageParamsSchema,
-    id: v24.string()
+    id: v25.string()
   }).entries
 });
 
 // src/request/types/sparkMethods/getAddresses.ts
-import * as v25 from "valibot";
+import * as v26 from "valibot";
 var sparkGetAddressesMethodName = "spark_getAddresses";
-var sparkGetAddressesParamsSchema = v25.nullish(
-  v25.object({
+var sparkGetAddressesParamsSchema = v26.nullish(
+  v26.object({
     /**
      * A message to be displayed to the user in the request prompt.
      */
-    message: v25.optional(v25.string())
+    message: v26.optional(v26.string())
   })
 );
-var sparkGetAddressesResultSchema = v25.object({
+var sparkGetAddressesResultSchema = v26.object({
   /**
    * The addresses generated for the given purposes.
    */
-  addresses: v25.array(addressSchema),
+  addresses: v26.array(addressSchema),
   network: getNetworkResultSchema
 });
-var sparkGetAddressesRequestMessageSchema = v25.object({
+var sparkGetAddressesRequestMessageSchema = v26.object({
   ...rpcRequestMessageSchema.entries,
-  ...v25.object({
-    method: v25.literal(sparkGetAddressesMethodName),
+  ...v26.object({
+    method: v26.literal(sparkGetAddressesMethodName),
     params: sparkGetAddressesParamsSchema,
-    id: v25.string()
+    id: v26.string()
   }).entries
 });
 
 // src/request/types/sparkMethods/getBalance.ts
-import * as v26 from "valibot";
+import * as v27 from "valibot";
 var sparkGetBalanceMethodName = "spark_getBalance";
-var sparkGetBalanceParamsSchema = v26.nullish(v26.null());
-var sparkGetBalanceResultSchema = v26.object({
+var sparkGetBalanceParamsSchema = v27.nullish(v27.null());
+var sparkGetBalanceResultSchema = v27.object({
   /**
    * The Spark Bitcoin address balance in sats in string form.
    */
-  balance: v26.string(),
-  tokenBalances: v26.array(
-    v26.object({
+  balance: v27.string(),
+  tokenBalances: v27.array(
+    v27.object({
       /* The address balance of the token in string form as it can overflow a js number */
-      balance: v26.string(),
-      tokenMetadata: v26.object({
-        tokenIdentifier: v26.string(),
-        tokenName: v26.string(),
-        tokenTicker: v26.string(),
-        decimals: v26.number(),
-        maxSupply: v26.string()
+      balance: v27.string(),
+      tokenMetadata: v27.object({
+        tokenIdentifier: v27.string(),
+        tokenName: v27.string(),
+        tokenTicker: v27.string(),
+        decimals: v27.number(),
+        maxSupply: v27.string()
       })
     })
   )
 });
-var sparkGetBalanceRequestMessageSchema = v26.object({
+var sparkGetBalanceRequestMessageSchema = v27.object({
   ...rpcRequestMessageSchema.entries,
-  ...v26.object({
-    method: v26.literal(sparkGetBalanceMethodName),
+  ...v27.object({
+    method: v27.literal(sparkGetBalanceMethodName),
     params: sparkGetBalanceParamsSchema,
-    id: v26.string()
+    id: v27.string()
   }).entries
 });
 
 // src/request/types/sparkMethods/signMessage.ts
-import * as v27 from "valibot";
+import * as v28 from "valibot";
 var sparkSignMessageMethodName = "spark_signMessage";
-var sparkSignMessageParamsSchema = v27.object({
+var sparkSignMessageParamsSchema = v28.object({
   /**
    * The message to sign. The message should only consist of valid UTF-8 characters.
    */
-  message: v27.string()
+  message: v28.string()
 });
-var sparkSignMessageResultSchema = v27.object({
+var sparkSignMessageResultSchema = v28.object({
   /**
    * The signature, encoded in base64, of the message hash.
    *
@@ -1199,98 +1222,98 @@ var sparkSignMessageResultSchema = v27.object({
    * and the resulting byte array is hashed with SHA256 before signing
    * with the private key.
    */
-  signature: v27.string()
+  signature: v28.string()
 });
-var sparkSignMessageRequestMessageSchema = v27.object({
+var sparkSignMessageRequestMessageSchema = v28.object({
   ...rpcRequestMessageSchema.entries,
-  ...v27.object({
-    method: v27.literal(sparkSignMessageMethodName),
+  ...v28.object({
+    method: v28.literal(sparkSignMessageMethodName),
     params: sparkSignMessageParamsSchema,
-    id: v27.string()
+    id: v28.string()
   }).entries
 });
 
 // src/request/types/sparkMethods/transfer.ts
-import * as v28 from "valibot";
+import * as v29 from "valibot";
 var sparkTransferMethodName = "spark_transfer";
-var sparkTransferParamsSchema = v28.object({
+var sparkTransferParamsSchema = v29.object({
   /**
    * Amount of SATS to transfer as a string or number.
    */
-  amountSats: v28.union([v28.number(), v28.string()]),
+  amountSats: v29.union([v29.number(), v29.string()]),
   /**
    * The recipient's spark address.
    */
-  receiverSparkAddress: v28.string()
+  receiverSparkAddress: v29.string()
 });
-var sparkTransferResultSchema = v28.object({
+var sparkTransferResultSchema = v29.object({
   /**
    * The ID of the transaction.
    */
-  id: v28.string()
+  id: v29.string()
 });
-var sparkTransferRequestMessageSchema = v28.object({
+var sparkTransferRequestMessageSchema = v29.object({
   ...rpcRequestMessageSchema.entries,
-  ...v28.object({
-    method: v28.literal(sparkTransferMethodName),
+  ...v29.object({
+    method: v29.literal(sparkTransferMethodName),
     params: sparkTransferParamsSchema,
-    id: v28.string()
+    id: v29.string()
   }).entries
 });
 
 // src/request/types/sparkMethods/transferToken.ts
-import * as v29 from "valibot";
+import * as v30 from "valibot";
 var sparkTransferTokenMethodName = "spark_transferToken";
-var sparkTransferTokenParamsSchema = v29.object({
+var sparkTransferTokenParamsSchema = v30.object({
   /**
    * Amount of units of the token to transfer as a string or number.
    */
-  tokenAmount: v29.union([v29.number(), v29.string()]),
+  tokenAmount: v30.union([v30.number(), v30.string()]),
   /**
    * The Bech32m token identifier.
    */
-  tokenIdentifier: v29.string(),
+  tokenIdentifier: v30.string(),
   /**
    * The recipient's spark address.
    */
-  receiverSparkAddress: v29.string()
+  receiverSparkAddress: v30.string()
 });
-var sparkTransferTokenResultSchema = v29.object({
+var sparkTransferTokenResultSchema = v30.object({
   /**
    * The ID of the transaction.
    */
-  id: v29.string()
+  id: v30.string()
 });
-var sparkTransferTokenRequestMessageSchema = v29.object({
+var sparkTransferTokenRequestMessageSchema = v30.object({
   ...rpcRequestMessageSchema.entries,
-  ...v29.object({
-    method: v29.literal(sparkTransferTokenMethodName),
+  ...v30.object({
+    method: v30.literal(sparkTransferTokenMethodName),
     params: sparkTransferTokenParamsSchema,
-    id: v29.string()
+    id: v30.string()
   }).entries
 });
 
 // src/request/types/stxMethods/callContract.ts
-import * as v30 from "valibot";
+import * as v31 from "valibot";
 var stxCallContractMethodName = "stx_callContract";
-var stxCallContractParamsSchema = v30.object({
+var stxCallContractParamsSchema = v31.object({
   /**
    * The contract principal.
    *
    * E.g. `"SPKE...GD5C.my-contract"`
    */
-  contract: v30.string(),
+  contract: v31.string(),
   /**
    * The name of the function to call.
    *
    * Note: spec changes ongoing,
    * https://github.com/stacksgov/sips/pull/166#pullrequestreview-1914236999
    */
-  functionName: v30.string(),
+  functionName: v31.string(),
   /**
    * @deprecated in favor of `functionArgs` for @stacks/connect compatibility
    */
-  arguments: v30.optional(v30.array(v30.string())),
+  arguments: v31.optional(v31.array(v31.string())),
   /**
    * The function's arguments. The arguments are expected to be hex-encoded
    * strings of Clarity values.
@@ -1305,274 +1328,274 @@ var stxCallContractParamsSchema = v30.object({
    * const hexArgs = functionArgs.map(cvToHex);
    * ```
    */
-  functionArgs: v30.optional(v30.array(v30.string())),
+  functionArgs: v31.optional(v31.array(v31.string())),
   /**
    * The post conditions to apply to the contract call.
    */
-  postConditions: v30.optional(v30.array(v30.string())),
+  postConditions: v31.optional(v31.array(v31.string())),
   /**
    * The mode to apply to the post conditions.
    */
-  postConditionMode: v30.optional(v30.union([v30.literal("allow"), v30.literal("deny")]))
+  postConditionMode: v31.optional(v31.union([v31.literal("allow"), v31.literal("deny")]))
 });
-var stxCallContractResultSchema = v30.object({
+var stxCallContractResultSchema = v31.object({
   /**
    * The ID of the transaction.
    */
-  txid: v30.string(),
+  txid: v31.string(),
   /**
    * A Stacks transaction as a hex-encoded string.
    */
-  transaction: v30.string()
+  transaction: v31.string()
 });
-var stxCallContractRequestMessageSchema = v30.object({
+var stxCallContractRequestMessageSchema = v31.object({
   ...rpcRequestMessageSchema.entries,
-  ...v30.object({
-    method: v30.literal(stxCallContractMethodName),
+  ...v31.object({
+    method: v31.literal(stxCallContractMethodName),
     params: stxCallContractParamsSchema,
-    id: v30.string()
+    id: v31.string()
   }).entries
 });
 
 // src/request/types/stxMethods/deployContract.ts
-import * as v31 from "valibot";
+import * as v32 from "valibot";
 var stxDeployContractMethodName = "stx_deployContract";
-var stxDeployContractParamsSchema = v31.object({
+var stxDeployContractParamsSchema = v32.object({
   /**
    * Name of the contract.
    */
-  name: v31.string(),
+  name: v32.string(),
   /**
    * The source code of the Clarity contract.
    */
-  clarityCode: v31.string(),
+  clarityCode: v32.string(),
   /**
    * The version of the Clarity contract.
    */
-  clarityVersion: v31.optional(v31.number()),
+  clarityVersion: v32.optional(v32.number()),
   /**
    * The post conditions to apply to the contract call.
    */
-  postConditions: v31.optional(v31.array(v31.string())),
+  postConditions: v32.optional(v32.array(v32.string())),
   /**
    * The mode to apply to the post conditions.
    */
-  postConditionMode: v31.optional(v31.union([v31.literal("allow"), v31.literal("deny")]))
+  postConditionMode: v32.optional(v32.union([v32.literal("allow"), v32.literal("deny")]))
 });
-var stxDeployContractResultSchema = v31.object({
+var stxDeployContractResultSchema = v32.object({
   /**
    * The ID of the transaction.
    */
-  txid: v31.string(),
+  txid: v32.string(),
   /**
    * A Stacks transaction as a hex-encoded string.
    */
-  transaction: v31.string()
+  transaction: v32.string()
 });
-var stxDeployContractRequestMessageSchema = v31.object({
+var stxDeployContractRequestMessageSchema = v32.object({
   ...rpcRequestMessageSchema.entries,
-  ...v31.object({
-    method: v31.literal(stxDeployContractMethodName),
+  ...v32.object({
+    method: v32.literal(stxDeployContractMethodName),
     params: stxDeployContractParamsSchema,
-    id: v31.string()
+    id: v32.string()
   }).entries
 });
 
 // src/request/types/stxMethods/getAccounts.ts
-import * as v32 from "valibot";
+import * as v33 from "valibot";
 var stxGetAccountsMethodName = "stx_getAccounts";
-var stxGetAccountsParamsSchema = v32.nullish(v32.null());
-var stxGetAccountsResultSchema = v32.object({
+var stxGetAccountsParamsSchema = v33.nullish(v33.null());
+var stxGetAccountsResultSchema = v33.object({
   /**
    * The addresses generated for the given purposes.
    */
-  addresses: v32.array(
-    v32.object({
-      address: v32.string(),
-      publicKey: v32.string(),
-      gaiaHubUrl: v32.string(),
-      gaiaAppKey: v32.string()
+  addresses: v33.array(
+    v33.object({
+      address: v33.string(),
+      publicKey: v33.string(),
+      gaiaHubUrl: v33.string(),
+      gaiaAppKey: v33.string()
     })
   ),
   network: getNetworkResultSchema
 });
-var stxGetAccountsRequestMessageSchema = v32.object({
+var stxGetAccountsRequestMessageSchema = v33.object({
   ...rpcRequestMessageSchema.entries,
-  ...v32.object({
-    method: v32.literal(stxGetAccountsMethodName),
+  ...v33.object({
+    method: v33.literal(stxGetAccountsMethodName),
     params: stxGetAccountsParamsSchema,
-    id: v32.string()
+    id: v33.string()
   }).entries
 });
 
 // src/request/types/stxMethods/getAddresses.ts
-import * as v33 from "valibot";
+import * as v34 from "valibot";
 var stxGetAddressesMethodName = "stx_getAddresses";
-var stxGetAddressesParamsSchema = v33.nullish(
-  v33.object({
+var stxGetAddressesParamsSchema = v34.nullish(
+  v34.object({
     /**
      * A message to be displayed to the user in the request prompt.
      */
-    message: v33.optional(v33.string())
+    message: v34.optional(v34.string())
   })
 );
-var stxGetAddressesResultSchema = v33.object({
+var stxGetAddressesResultSchema = v34.object({
   /**
    * The addresses generated for the given purposes.
    */
-  addresses: v33.array(addressSchema),
+  addresses: v34.array(addressSchema),
   network: getNetworkResultSchema
 });
-var stxGetAddressesRequestMessageSchema = v33.object({
+var stxGetAddressesRequestMessageSchema = v34.object({
   ...rpcRequestMessageSchema.entries,
-  ...v33.object({
-    method: v33.literal(stxGetAddressesMethodName),
+  ...v34.object({
+    method: v34.literal(stxGetAddressesMethodName),
     params: stxGetAddressesParamsSchema,
-    id: v33.string()
+    id: v34.string()
   }).entries
 });
 
 // src/request/types/stxMethods/signMessage.ts
-import * as v34 from "valibot";
+import * as v35 from "valibot";
 var stxSignMessageMethodName = "stx_signMessage";
-var stxSignMessageParamsSchema = v34.object({
+var stxSignMessageParamsSchema = v35.object({
   /**
    * The message to sign.
    */
-  message: v34.string()
+  message: v35.string()
 });
-var stxSignMessageResultSchema = v34.object({
+var stxSignMessageResultSchema = v35.object({
   /**
    * The signature of the message.
    */
-  signature: v34.string(),
+  signature: v35.string(),
   /**
    * The public key used to sign the message.
    */
-  publicKey: v34.string()
+  publicKey: v35.string()
 });
-var stxSignMessageRequestMessageSchema = v34.object({
+var stxSignMessageRequestMessageSchema = v35.object({
   ...rpcRequestMessageSchema.entries,
-  ...v34.object({
-    method: v34.literal(stxSignMessageMethodName),
+  ...v35.object({
+    method: v35.literal(stxSignMessageMethodName),
     params: stxSignMessageParamsSchema,
-    id: v34.string()
+    id: v35.string()
   }).entries
 });
 
 // src/request/types/stxMethods/signStructuredMessage.ts
-import * as v35 from "valibot";
+import * as v36 from "valibot";
 var stxSignStructuredMessageMethodName = "stx_signStructuredMessage";
-var stxSignStructuredMessageParamsSchema = v35.object({
+var stxSignStructuredMessageParamsSchema = v36.object({
   /**
    * The domain to be signed.
    */
-  domain: v35.string(),
+  domain: v36.string(),
   /**
    * Message payload to be signed.
    */
-  message: v35.string(),
+  message: v36.string(),
   /**
    * The public key to sign the message with.
    */
-  publicKey: v35.optional(v35.string())
+  publicKey: v36.optional(v36.string())
 });
-var stxSignStructuredMessageResultSchema = v35.object({
+var stxSignStructuredMessageResultSchema = v36.object({
   /**
    * Signature of the message.
    */
-  signature: v35.string(),
+  signature: v36.string(),
   /**
    * Public key as hex-encoded string.
    */
-  publicKey: v35.string()
+  publicKey: v36.string()
 });
-var stxSignStructuredMessageRequestMessageSchema = v35.object({
+var stxSignStructuredMessageRequestMessageSchema = v36.object({
   ...rpcRequestMessageSchema.entries,
-  ...v35.object({
-    method: v35.literal(stxSignStructuredMessageMethodName),
+  ...v36.object({
+    method: v36.literal(stxSignStructuredMessageMethodName),
     params: stxSignStructuredMessageParamsSchema,
-    id: v35.string()
+    id: v36.string()
   }).entries
 });
 
 // src/request/types/stxMethods/signTransaction.ts
-import * as v36 from "valibot";
+import * as v37 from "valibot";
 var stxSignTransactionMethodName = "stx_signTransaction";
-var stxSignTransactionParamsSchema = v36.object({
+var stxSignTransactionParamsSchema = v37.object({
   /**
    * The transaction to sign as a hex-encoded string.
    */
-  transaction: v36.string(),
+  transaction: v37.string(),
   /**
    * The public key to sign the transaction with. The wallet may use any key
    * when not provided.
    */
-  pubkey: v36.optional(v36.string()),
+  pubkey: v37.optional(v37.string()),
   /**
    * Whether to broadcast the transaction after signing. Defaults to `true`.
    */
-  broadcast: v36.optional(v36.boolean())
+  broadcast: v37.optional(v37.boolean())
 });
-var stxSignTransactionResultSchema = v36.object({
+var stxSignTransactionResultSchema = v37.object({
   /**
    * The signed transaction as a hex-encoded string.
    */
-  transaction: v36.string()
+  transaction: v37.string()
 });
-var stxSignTransactionRequestMessageSchema = v36.object({
+var stxSignTransactionRequestMessageSchema = v37.object({
   ...rpcRequestMessageSchema.entries,
-  ...v36.object({
-    method: v36.literal(stxSignTransactionMethodName),
+  ...v37.object({
+    method: v37.literal(stxSignTransactionMethodName),
     params: stxSignTransactionParamsSchema,
-    id: v36.string()
+    id: v37.string()
   }).entries
 });
 
 // src/request/types/stxMethods/signTransactions.ts
-import * as v37 from "valibot";
+import * as v38 from "valibot";
 var stxSignTransactionsMethodName = "stx_signTransactions";
-var stxSignTransactionsParamsSchema = v37.object({
+var stxSignTransactionsParamsSchema = v38.object({
   /**
    * The transactions to sign as hex-encoded strings.
    */
-  transactions: v37.pipe(
-    v37.array(
-      v37.pipe(
-        v37.string(),
-        v37.check((hex) => {
+  transactions: v38.pipe(
+    v38.array(
+      v38.pipe(
+        v38.string(),
+        v38.check((hex) => {
           return true;
         }, "Invalid hex-encoded Stacks transaction.")
       )
     ),
-    v37.minLength(1)
+    v38.minLength(1)
   ),
   /**
    * Whether the signed transactions should be broadcast after signing. Defaults
    * to `true`.
    */
-  broadcast: v37.optional(v37.boolean())
+  broadcast: v38.optional(v38.boolean())
 });
-var stxSignTransactionsResultSchema = v37.object({
+var stxSignTransactionsResultSchema = v38.object({
   /**
    * The signed transactions as hex-encoded strings, in the same order as in the
    * sign request.
    */
-  transactions: v37.array(v37.string())
+  transactions: v38.array(v38.string())
 });
-var stxSignTransactionsRequestMessageSchema = v37.object({
+var stxSignTransactionsRequestMessageSchema = v38.object({
   ...rpcRequestMessageSchema.entries,
-  ...v37.object({
-    method: v37.literal(stxSignTransactionsMethodName),
+  ...v38.object({
+    method: v38.literal(stxSignTransactionsMethodName),
     params: stxSignTransactionsParamsSchema,
-    id: v37.string()
+    id: v38.string()
   }).entries
 });
 
 // src/request/types/stxMethods/transferStx.ts
-import * as v38 from "valibot";
+import * as v39 from "valibot";
 var stxTransferStxMethodName = "stx_transferStx";
-var stxTransferStxParamsSchema = v38.object({
+var stxTransferStxParamsSchema = v39.object({
   /**
    * Amount of STX tokens to transfer in microstacks as a string. Anything
    * parseable by `BigInt` is acceptable.
@@ -1585,23 +1608,23 @@ var stxTransferStxParamsSchema = v38.object({
    * const amount3 = '1234';
    * ```
    */
-  amount: v38.union([v38.number(), v38.string()]),
+  amount: v39.union([v39.number(), v39.string()]),
   /**
    * The recipient's principal.
    */
-  recipient: v38.string(),
+  recipient: v39.string(),
   /**
    * A string representing the memo.
    */
-  memo: v38.optional(v38.string()),
+  memo: v39.optional(v39.string()),
   /**
    * Version of parameter format.
    */
-  version: v38.optional(v38.string()),
+  version: v39.optional(v39.string()),
   /**
    * The mode of the post conditions.
    */
-  postConditionMode: v38.optional(v38.number()),
+  postConditionMode: v39.optional(v39.number()),
   /**
    * A hex-encoded string representing the post conditions.
    *
@@ -1614,29 +1637,29 @@ var stxTransferStxParamsSchema = v38.object({
    * const hexPostCondition = serializePostCondition(postCondition).toString('hex');
    * ```
    */
-  postConditions: v38.optional(v38.array(v38.string())),
+  postConditions: v39.optional(v39.array(v39.string())),
   /**
    * The public key to sign the transaction with. The wallet may use any key
    * when not provided.
    */
-  pubkey: v38.optional(v38.string())
+  pubkey: v39.optional(v39.string())
 });
-var stxTransferStxResultSchema = v38.object({
+var stxTransferStxResultSchema = v39.object({
   /**
    * The ID of the transaction.
    */
-  txid: v38.string(),
+  txid: v39.string(),
   /**
    * A Stacks transaction as a hex-encoded string.
    */
-  transaction: v38.string()
+  transaction: v39.string()
 });
-var stxTransferStxRequestMessageSchema = v38.object({
+var stxTransferStxRequestMessageSchema = v39.object({
   ...rpcRequestMessageSchema.entries,
-  ...v38.object({
-    method: v38.literal(stxTransferStxMethodName),
+  ...v39.object({
+    method: v39.literal(stxTransferStxMethodName),
     params: stxTransferStxParamsSchema,
-    id: v38.string()
+    id: v39.string()
   }).entries
 });
 
@@ -1644,13 +1667,13 @@ var stxTransferStxRequestMessageSchema = v38.object({
 var cache = {};
 var requestInternal = async (provider, method, params) => {
   const response = await provider.request(method, params);
-  if (v39.is(rpcErrorResponseMessageSchema, response)) {
+  if (v40.is(rpcErrorResponseMessageSchema, response)) {
     return {
       status: "error",
       error: response.error
     };
   }
-  if (v39.is(rpcSuccessResponseMessageSchema, response)) {
+  if (v40.is(rpcSuccessResponseMessageSchema, response)) {
     return {
       status: "success",
       result: response.result
@@ -2843,6 +2866,10 @@ export {
   sparkFlashnetConfirmInitialDepositIntentSchema,
   sparkFlashnetCreateConstantProductPoolIntentSchema,
   sparkFlashnetCreateSingleSidedPoolIntentSchema,
+  sparkFlashnetExecuteClawbackMethodName,
+  sparkFlashnetExecuteClawbackParamsSchema,
+  sparkFlashnetExecuteClawbackRequestMessageSchema,
+  sparkFlashnetExecuteClawbackResultSchema,
   sparkFlashnetExecuteRouteSwapMethodName,
   sparkFlashnetExecuteRouteSwapParamsSchema,
   sparkFlashnetExecuteRouteSwapRequestMessageSchema,