@sats-connect/core 0.11.0-44ab88e → 0.11.0-72e36df

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.mjs CHANGED
@@ -1,5 +1,5 @@
1
1
  // src/request/index.ts
2
- import * as v39 from "valibot";
2
+ import * as v40 from "valibot";
3
3
 
4
4
  // src/provider/types.ts
5
5
  import * as v4 from "valibot";
@@ -862,224 +862,246 @@ var runesTransferRequestMessageSchema = v11.object({
862
862
  }).entries
863
863
  });
864
864
 
865
- // src/request/types/sparkMethods/flashnetMethods/executeRouteSwap.ts
865
+ // src/request/types/sparkMethods/flashnetMethods/executeClawBack.ts
866
866
  import * as v12 from "valibot";
867
- var sparkFlashnetExecuteRouteSwapMethodName = "spark_flashnet_executeRouteSwap";
868
- var sparkFlashnetExecuteRouteSwapParamsSchema = v12.object({
869
- hops: v12.array(
870
- v12.object({
871
- poolId: v12.string(),
872
- assetInAddress: v12.string(),
873
- assetOutAddress: v12.string(),
874
- hopIntegratorFeeRateBps: v12.optional(v12.number())
875
- })
876
- ),
877
- initialAssetAddress: v12.string(),
878
- inputAmount: v12.string(),
879
- maxRouteSlippageBps: v12.string(),
880
- minAmountOut: v12.string(),
881
- integratorFeeRateBps: v12.optional(v12.number()),
882
- integratorPublicKey: v12.optional(v12.string())
883
- });
884
- var sparkFlashnetExecuteRouteSwapResultSchema = v12.object({
867
+ var sparkFlashnetExecuteClawBackMethodName = "spark_flashnet_executeClawBack";
868
+ var sparkFlashnetExecuteClawBackParamsSchema = v12.object({
869
+ sparkTransferId: v12.string(),
870
+ lpIdentityPublicKey: v12.string()
871
+ });
872
+ var sparkFlashnetExecuteClawBackResultSchema = v12.object({
885
873
  requestId: v12.string(),
886
874
  accepted: v12.boolean(),
887
- outputAmount: v12.string(),
888
- executionPrice: v12.string(),
889
- finalOutboundTransferId: v12.string(),
890
- error: v12.optional(v12.string())
875
+ internalRequestId: v12.string(),
876
+ sparkStatusTrackingId: v12.string()
891
877
  });
892
- var sparkFlashnetExecuteRouteSwapRequestMessageSchema = v12.object({
878
+ var sparkFlashnetExecuteClawBackRequestMessageSchema = v12.object({
893
879
  ...rpcRequestMessageSchema.entries,
894
880
  ...v12.object({
895
- method: v12.literal(sparkFlashnetExecuteRouteSwapMethodName),
896
- params: sparkFlashnetExecuteRouteSwapParamsSchema,
881
+ method: v12.literal(sparkFlashnetExecuteClawBackMethodName),
882
+ params: sparkFlashnetExecuteClawBackParamsSchema,
897
883
  id: v12.string()
898
884
  }).entries
899
885
  });
900
886
 
901
- // src/request/types/sparkMethods/flashnetMethods/executeSwap.ts
887
+ // src/request/types/sparkMethods/flashnetMethods/executeRouteSwap.ts
902
888
  import * as v13 from "valibot";
903
- var sparkFlashnetExecuteSwapMethodName = "spark_flashnet_executeSwap";
904
- var sparkFlashnetExecuteSwapParamsSchema = v13.object({
905
- poolId: v13.string(),
906
- assetInAddress: v13.string(),
907
- assetOutAddress: v13.string(),
908
- amountIn: v13.string(),
909
- maxSlippageBps: v13.number(),
889
+ var sparkFlashnetExecuteRouteSwapMethodName = "spark_flashnet_executeRouteSwap";
890
+ var sparkFlashnetExecuteRouteSwapParamsSchema = v13.object({
891
+ hops: v13.array(
892
+ v13.object({
893
+ poolId: v13.string(),
894
+ assetInAddress: v13.string(),
895
+ assetOutAddress: v13.string(),
896
+ hopIntegratorFeeRateBps: v13.optional(v13.number())
897
+ })
898
+ ),
899
+ initialAssetAddress: v13.string(),
900
+ inputAmount: v13.string(),
901
+ maxRouteSlippageBps: v13.string(),
910
902
  minAmountOut: v13.string(),
911
903
  integratorFeeRateBps: v13.optional(v13.number()),
912
904
  integratorPublicKey: v13.optional(v13.string())
913
905
  });
914
- var sparkFlashnetExecuteSwapResultSchema = v13.object({
906
+ var sparkFlashnetExecuteRouteSwapResultSchema = v13.object({
915
907
  requestId: v13.string(),
916
908
  accepted: v13.boolean(),
917
- amountOut: v13.optional(v13.string()),
918
- feeAmount: v13.optional(v13.string()),
919
- executionPrice: v13.optional(v13.string()),
920
- assetOutAddress: v13.optional(v13.string()),
921
- assetInAddress: v13.optional(v13.string()),
922
- outboundTransferId: v13.optional(v13.string()),
909
+ outputAmount: v13.string(),
910
+ executionPrice: v13.string(),
911
+ finalOutboundTransferId: v13.string(),
923
912
  error: v13.optional(v13.string())
924
913
  });
925
- var sparkFlashnetExecuteSwapRequestMessageSchema = v13.object({
914
+ var sparkFlashnetExecuteRouteSwapRequestMessageSchema = v13.object({
926
915
  ...rpcRequestMessageSchema.entries,
927
916
  ...v13.object({
928
- method: v13.literal(sparkFlashnetExecuteSwapMethodName),
929
- params: sparkFlashnetExecuteSwapParamsSchema,
917
+ method: v13.literal(sparkFlashnetExecuteRouteSwapMethodName),
918
+ params: sparkFlashnetExecuteRouteSwapParamsSchema,
930
919
  id: v13.string()
931
920
  }).entries
932
921
  });
933
922
 
934
- // src/request/types/sparkMethods/flashnetMethods/getJwt.ts
923
+ // src/request/types/sparkMethods/flashnetMethods/executeSwap.ts
935
924
  import * as v14 from "valibot";
925
+ var sparkFlashnetExecuteSwapMethodName = "spark_flashnet_executeSwap";
926
+ var sparkFlashnetExecuteSwapParamsSchema = v14.object({
927
+ poolId: v14.string(),
928
+ assetInAddress: v14.string(),
929
+ assetOutAddress: v14.string(),
930
+ amountIn: v14.string(),
931
+ maxSlippageBps: v14.number(),
932
+ minAmountOut: v14.string(),
933
+ integratorFeeRateBps: v14.optional(v14.number()),
934
+ integratorPublicKey: v14.optional(v14.string())
935
+ });
936
+ var sparkFlashnetExecuteSwapResultSchema = v14.object({
937
+ requestId: v14.string(),
938
+ accepted: v14.boolean(),
939
+ amountOut: v14.optional(v14.string()),
940
+ feeAmount: v14.optional(v14.string()),
941
+ executionPrice: v14.optional(v14.string()),
942
+ assetOutAddress: v14.optional(v14.string()),
943
+ assetInAddress: v14.optional(v14.string()),
944
+ outboundTransferId: v14.optional(v14.string()),
945
+ error: v14.optional(v14.string())
946
+ });
947
+ var sparkFlashnetExecuteSwapRequestMessageSchema = v14.object({
948
+ ...rpcRequestMessageSchema.entries,
949
+ ...v14.object({
950
+ method: v14.literal(sparkFlashnetExecuteSwapMethodName),
951
+ params: sparkFlashnetExecuteSwapParamsSchema,
952
+ id: v14.string()
953
+ }).entries
954
+ });
955
+
956
+ // src/request/types/sparkMethods/flashnetMethods/getJwt.ts
957
+ import * as v15 from "valibot";
936
958
  var sparkFlashnetGetJwtMethodName = "spark_flashnet_getJwt";
937
- var sparkFlashnetGetJwtParamsSchema = v14.null();
938
- var sparkFlashnetGetJwtResultSchema = v14.object({
959
+ var sparkFlashnetGetJwtParamsSchema = v15.null();
960
+ var sparkFlashnetGetJwtResultSchema = v15.object({
939
961
  /**
940
962
  * The JWT token for authenticated requests to the Flashnet API.
941
963
  */
942
- jwt: v14.string()
964
+ jwt: v15.string()
943
965
  });
944
- var sparkFlashnetGetJwtRequestMessageSchema = v14.object({
966
+ var sparkFlashnetGetJwtRequestMessageSchema = v15.object({
945
967
  ...rpcRequestMessageSchema.entries,
946
- ...v14.object({
947
- method: v14.literal(sparkFlashnetGetJwtMethodName),
968
+ ...v15.object({
969
+ method: v15.literal(sparkFlashnetGetJwtMethodName),
948
970
  params: sparkFlashnetGetJwtParamsSchema,
949
- id: v14.string()
971
+ id: v15.string()
950
972
  }).entries
951
973
  });
952
974
 
953
975
  // src/request/types/sparkMethods/flashnetMethods/intents/addLiquidity.ts
954
- import * as v15 from "valibot";
955
- var sparkFlashnetAddLiquidityIntentSchema = v15.object({
956
- type: v15.literal("addLiquidity"),
957
- data: v15.object({
958
- userPublicKey: v15.string(),
959
- poolId: v15.string(),
960
- assetAAmount: v15.string(),
961
- assetBAmount: v15.string(),
962
- assetAMinAmountIn: v15.string(),
963
- assetBMinAmountIn: v15.string(),
964
- assetATransferId: v15.string(),
965
- assetBTransferId: v15.string(),
966
- nonce: v15.string()
967
- })
968
- });
969
-
970
- // src/request/types/sparkMethods/flashnetMethods/intents/clawback.ts
971
976
  import * as v16 from "valibot";
972
- var sparkFlashnetClawbackIntentSchema = v16.object({
973
- type: v16.literal("clawback"),
977
+ var sparkFlashnetAddLiquidityIntentSchema = v16.object({
978
+ type: v16.literal("addLiquidity"),
974
979
  data: v16.object({
975
- senderPublicKey: v16.string(),
976
- sparkTransferId: v16.string(),
977
- lpIdentityPublicKey: v16.string(),
980
+ userPublicKey: v16.string(),
981
+ poolId: v16.string(),
982
+ assetAAmount: v16.string(),
983
+ assetBAmount: v16.string(),
984
+ assetAMinAmountIn: v16.string(),
985
+ assetBMinAmountIn: v16.string(),
986
+ assetATransferId: v16.string(),
987
+ assetBTransferId: v16.string(),
978
988
  nonce: v16.string()
979
989
  })
980
990
  });
981
991
 
982
- // src/request/types/sparkMethods/flashnetMethods/intents/confirmInitialDeposit.ts
992
+ // src/request/types/sparkMethods/flashnetMethods/intents/clawback.ts
983
993
  import * as v17 from "valibot";
984
- var sparkFlashnetConfirmInitialDepositIntentSchema = v17.object({
985
- type: v17.literal("confirmInitialDeposit"),
994
+ var sparkFlashnetClawbackIntentSchema = v17.object({
995
+ type: v17.literal("clawback"),
986
996
  data: v17.object({
987
- poolId: v17.string(),
988
- assetASparkTransferId: v17.string(),
989
- poolOwnerPublicKey: v17.string(),
997
+ senderPublicKey: v17.string(),
998
+ sparkTransferId: v17.string(),
999
+ lpIdentityPublicKey: v17.string(),
990
1000
  nonce: v17.string()
991
1001
  })
992
1002
  });
993
1003
 
994
- // src/request/types/sparkMethods/flashnetMethods/intents/createConstantProductPool.ts
1004
+ // src/request/types/sparkMethods/flashnetMethods/intents/confirmInitialDeposit.ts
995
1005
  import * as v18 from "valibot";
996
- var sparkFlashnetCreateConstantProductPoolIntentSchema = v18.object({
997
- type: v18.literal("createConstantProductPool"),
1006
+ var sparkFlashnetConfirmInitialDepositIntentSchema = v18.object({
1007
+ type: v18.literal("confirmInitialDeposit"),
998
1008
  data: v18.object({
1009
+ poolId: v18.string(),
1010
+ assetASparkTransferId: v18.string(),
999
1011
  poolOwnerPublicKey: v18.string(),
1000
- assetAAddress: v18.string(),
1001
- assetBAddress: v18.string(),
1002
- lpFeeRateBps: v18.union([v18.number(), v18.string()]),
1003
- totalHostFeeRateBps: v18.union([v18.number(), v18.string()]),
1004
1012
  nonce: v18.string()
1005
1013
  })
1006
1014
  });
1007
1015
 
1008
- // src/request/types/sparkMethods/flashnetMethods/intents/createSingleSidedPool.ts
1016
+ // src/request/types/sparkMethods/flashnetMethods/intents/createConstantProductPool.ts
1009
1017
  import * as v19 from "valibot";
1010
- var sparkFlashnetCreateSingleSidedPoolIntentSchema = v19.object({
1011
- type: v19.literal("createSingleSidedPool"),
1018
+ var sparkFlashnetCreateConstantProductPoolIntentSchema = v19.object({
1019
+ type: v19.literal("createConstantProductPool"),
1012
1020
  data: v19.object({
1021
+ poolOwnerPublicKey: v19.string(),
1013
1022
  assetAAddress: v19.string(),
1014
1023
  assetBAddress: v19.string(),
1015
- assetAInitialReserve: v19.string(),
1016
- virtualReserveA: v19.union([v19.number(), v19.string()]),
1017
- virtualReserveB: v19.union([v19.number(), v19.string()]),
1018
- threshold: v19.union([v19.number(), v19.string()]),
1019
1024
  lpFeeRateBps: v19.union([v19.number(), v19.string()]),
1020
1025
  totalHostFeeRateBps: v19.union([v19.number(), v19.string()]),
1021
- poolOwnerPublicKey: v19.string(),
1022
1026
  nonce: v19.string()
1023
1027
  })
1024
1028
  });
1025
1029
 
1026
- // src/request/types/sparkMethods/flashnetMethods/intents/removeLiquidity.ts
1030
+ // src/request/types/sparkMethods/flashnetMethods/intents/createSingleSidedPool.ts
1027
1031
  import * as v20 from "valibot";
1028
- var sparkFlashnetRemoveLiquidityIntentSchema = v20.object({
1029
- type: v20.literal("removeLiquidity"),
1032
+ var sparkFlashnetCreateSingleSidedPoolIntentSchema = v20.object({
1033
+ type: v20.literal("createSingleSidedPool"),
1030
1034
  data: v20.object({
1031
- userPublicKey: v20.string(),
1032
- poolId: v20.string(),
1033
- lpTokensToRemove: v20.string(),
1035
+ assetAAddress: v20.string(),
1036
+ assetBAddress: v20.string(),
1037
+ assetAInitialReserve: v20.string(),
1038
+ virtualReserveA: v20.union([v20.number(), v20.string()]),
1039
+ virtualReserveB: v20.union([v20.number(), v20.string()]),
1040
+ threshold: v20.union([v20.number(), v20.string()]),
1041
+ lpFeeRateBps: v20.union([v20.number(), v20.string()]),
1042
+ totalHostFeeRateBps: v20.union([v20.number(), v20.string()]),
1043
+ poolOwnerPublicKey: v20.string(),
1034
1044
  nonce: v20.string()
1035
1045
  })
1036
1046
  });
1037
1047
 
1038
- // src/request/types/sparkMethods/flashnetMethods/intents/routeSwap.ts
1048
+ // src/request/types/sparkMethods/flashnetMethods/intents/removeLiquidity.ts
1039
1049
  import * as v21 from "valibot";
1040
- var sparkFlashnetRouteSwapIntentSchema = v21.object({
1041
- type: v21.literal("executeRouteSwap"),
1050
+ var sparkFlashnetRemoveLiquidityIntentSchema = v21.object({
1051
+ type: v21.literal("removeLiquidity"),
1042
1052
  data: v21.object({
1043
1053
  userPublicKey: v21.string(),
1044
- initialSparkTransferId: v21.string(),
1045
- hops: v21.array(
1046
- v21.object({
1047
- poolId: v21.string(),
1048
- inputAssetAddress: v21.string(),
1049
- outputAssetAddress: v21.string(),
1050
- hopIntegratorFeeRateBps: v21.optional(v21.union([v21.number(), v21.string()]))
1051
- })
1052
- ),
1053
- inputAmount: v21.string(),
1054
- maxRouteSlippageBps: v21.union([v21.number(), v21.string()]),
1055
- minAmountOut: v21.string(),
1056
- defaultIntegratorFeeRateBps: v21.optional(v21.union([v21.number(), v21.string()])),
1054
+ poolId: v21.string(),
1055
+ lpTokensToRemove: v21.string(),
1057
1056
  nonce: v21.string()
1058
1057
  })
1059
1058
  });
1060
1059
 
1061
- // src/request/types/sparkMethods/flashnetMethods/intents/swap.ts
1060
+ // src/request/types/sparkMethods/flashnetMethods/intents/routeSwap.ts
1062
1061
  import * as v22 from "valibot";
1063
- var sparkFlashnetSwapIntentSchema = v22.object({
1064
- type: v22.literal("executeSwap"),
1062
+ var sparkFlashnetRouteSwapIntentSchema = v22.object({
1063
+ type: v22.literal("executeRouteSwap"),
1065
1064
  data: v22.object({
1066
1065
  userPublicKey: v22.string(),
1067
- poolId: v22.string(),
1068
- transferId: v22.string(),
1069
- assetInAddress: v22.string(),
1070
- assetOutAddress: v22.string(),
1071
- amountIn: v22.string(),
1072
- maxSlippageBps: v22.union([v22.number(), v22.string()]),
1066
+ initialSparkTransferId: v22.string(),
1067
+ hops: v22.array(
1068
+ v22.object({
1069
+ poolId: v22.string(),
1070
+ inputAssetAddress: v22.string(),
1071
+ outputAssetAddress: v22.string(),
1072
+ hopIntegratorFeeRateBps: v22.optional(v22.union([v22.number(), v22.string()]))
1073
+ })
1074
+ ),
1075
+ inputAmount: v22.string(),
1076
+ maxRouteSlippageBps: v22.union([v22.number(), v22.string()]),
1073
1077
  minAmountOut: v22.string(),
1074
- totalIntegratorFeeRateBps: v22.optional(v22.union([v22.number(), v22.string()])),
1078
+ defaultIntegratorFeeRateBps: v22.optional(v22.union([v22.number(), v22.string()])),
1075
1079
  nonce: v22.string()
1076
1080
  })
1077
1081
  });
1078
1082
 
1079
- // src/request/types/sparkMethods/flashnetMethods/signIntent.ts
1083
+ // src/request/types/sparkMethods/flashnetMethods/intents/swap.ts
1080
1084
  import * as v23 from "valibot";
1085
+ var sparkFlashnetSwapIntentSchema = v23.object({
1086
+ type: v23.literal("executeSwap"),
1087
+ data: v23.object({
1088
+ userPublicKey: v23.string(),
1089
+ poolId: v23.string(),
1090
+ transferId: v23.string(),
1091
+ assetInAddress: v23.string(),
1092
+ assetOutAddress: v23.string(),
1093
+ amountIn: v23.string(),
1094
+ maxSlippageBps: v23.union([v23.number(), v23.string()]),
1095
+ minAmountOut: v23.string(),
1096
+ totalIntegratorFeeRateBps: v23.optional(v23.union([v23.number(), v23.string()])),
1097
+ nonce: v23.string()
1098
+ })
1099
+ });
1100
+
1101
+ // src/request/types/sparkMethods/flashnetMethods/signIntent.ts
1102
+ import * as v24 from "valibot";
1081
1103
  var sparkFlashnetSignIntentMethodName = "spark_flashnet_signIntent";
1082
- var sparkFlashnetSignIntentParamsSchema = v23.union([
1104
+ var sparkFlashnetSignIntentParamsSchema = v24.union([
1083
1105
  sparkFlashnetSwapIntentSchema,
1084
1106
  sparkFlashnetRouteSwapIntentSchema,
1085
1107
  sparkFlashnetAddLiquidityIntentSchema,
@@ -1089,109 +1111,109 @@ var sparkFlashnetSignIntentParamsSchema = v23.union([
1089
1111
  sparkFlashnetCreateSingleSidedPoolIntentSchema,
1090
1112
  sparkFlashnetRemoveLiquidityIntentSchema
1091
1113
  ]);
1092
- var sparkFlashnetSignIntentResultSchema = v23.object({
1114
+ var sparkFlashnetSignIntentResultSchema = v24.object({
1093
1115
  /**
1094
1116
  * The signed intent as a hex string.
1095
1117
  */
1096
- signature: v23.string()
1118
+ signature: v24.string()
1097
1119
  });
1098
- var sparkFlashnetSignIntentRequestMessageSchema = v23.object({
1120
+ var sparkFlashnetSignIntentRequestMessageSchema = v24.object({
1099
1121
  ...rpcRequestMessageSchema.entries,
1100
- ...v23.object({
1101
- method: v23.literal(sparkFlashnetSignIntentMethodName),
1122
+ ...v24.object({
1123
+ method: v24.literal(sparkFlashnetSignIntentMethodName),
1102
1124
  params: sparkFlashnetSignIntentParamsSchema,
1103
- id: v23.string()
1125
+ id: v24.string()
1104
1126
  }).entries
1105
1127
  });
1106
1128
 
1107
1129
  // src/request/types/sparkMethods/flashnetMethods/signStructuredMessage.ts
1108
- import * as v24 from "valibot";
1130
+ import * as v25 from "valibot";
1109
1131
  var sparkFlashnetSignStructuredMessageMethodName = "spark_flashnet_signStructuredMessage";
1110
- var sparkFlashnetSignStructuredMessageParamsSchema = v24.object({
1111
- message: v24.string()
1132
+ var sparkFlashnetSignStructuredMessageParamsSchema = v25.object({
1133
+ message: v25.string()
1112
1134
  });
1113
- var sparkFlashnetSignStructuredMessageResultSchema = v24.object({
1114
- message: v24.string(),
1115
- signature: v24.string()
1135
+ var sparkFlashnetSignStructuredMessageResultSchema = v25.object({
1136
+ message: v25.string(),
1137
+ signature: v25.string()
1116
1138
  });
1117
- var sparkFlashnetSignStructuredMessageRequestMessageSchema = v24.object({
1139
+ var sparkFlashnetSignStructuredMessageRequestMessageSchema = v25.object({
1118
1140
  ...rpcRequestMessageSchema.entries,
1119
- ...v24.object({
1120
- method: v24.literal(sparkFlashnetSignStructuredMessageMethodName),
1141
+ ...v25.object({
1142
+ method: v25.literal(sparkFlashnetSignStructuredMessageMethodName),
1121
1143
  params: sparkFlashnetSignStructuredMessageParamsSchema,
1122
- id: v24.string()
1144
+ id: v25.string()
1123
1145
  }).entries
1124
1146
  });
1125
1147
 
1126
1148
  // src/request/types/sparkMethods/getAddresses.ts
1127
- import * as v25 from "valibot";
1149
+ import * as v26 from "valibot";
1128
1150
  var sparkGetAddressesMethodName = "spark_getAddresses";
1129
- var sparkGetAddressesParamsSchema = v25.nullish(
1130
- v25.object({
1151
+ var sparkGetAddressesParamsSchema = v26.nullish(
1152
+ v26.object({
1131
1153
  /**
1132
1154
  * A message to be displayed to the user in the request prompt.
1133
1155
  */
1134
- message: v25.optional(v25.string())
1156
+ message: v26.optional(v26.string())
1135
1157
  })
1136
1158
  );
1137
- var sparkGetAddressesResultSchema = v25.object({
1159
+ var sparkGetAddressesResultSchema = v26.object({
1138
1160
  /**
1139
1161
  * The addresses generated for the given purposes.
1140
1162
  */
1141
- addresses: v25.array(addressSchema),
1163
+ addresses: v26.array(addressSchema),
1142
1164
  network: getNetworkResultSchema
1143
1165
  });
1144
- var sparkGetAddressesRequestMessageSchema = v25.object({
1166
+ var sparkGetAddressesRequestMessageSchema = v26.object({
1145
1167
  ...rpcRequestMessageSchema.entries,
1146
- ...v25.object({
1147
- method: v25.literal(sparkGetAddressesMethodName),
1168
+ ...v26.object({
1169
+ method: v26.literal(sparkGetAddressesMethodName),
1148
1170
  params: sparkGetAddressesParamsSchema,
1149
- id: v25.string()
1171
+ id: v26.string()
1150
1172
  }).entries
1151
1173
  });
1152
1174
 
1153
1175
  // src/request/types/sparkMethods/getBalance.ts
1154
- import * as v26 from "valibot";
1176
+ import * as v27 from "valibot";
1155
1177
  var sparkGetBalanceMethodName = "spark_getBalance";
1156
- var sparkGetBalanceParamsSchema = v26.nullish(v26.null());
1157
- var sparkGetBalanceResultSchema = v26.object({
1178
+ var sparkGetBalanceParamsSchema = v27.nullish(v27.null());
1179
+ var sparkGetBalanceResultSchema = v27.object({
1158
1180
  /**
1159
1181
  * The Spark Bitcoin address balance in sats in string form.
1160
1182
  */
1161
- balance: v26.string(),
1162
- tokenBalances: v26.array(
1163
- v26.object({
1183
+ balance: v27.string(),
1184
+ tokenBalances: v27.array(
1185
+ v27.object({
1164
1186
  /* The address balance of the token in string form as it can overflow a js number */
1165
- balance: v26.string(),
1166
- tokenMetadata: v26.object({
1167
- tokenIdentifier: v26.string(),
1168
- tokenName: v26.string(),
1169
- tokenTicker: v26.string(),
1170
- decimals: v26.number(),
1171
- maxSupply: v26.string()
1187
+ balance: v27.string(),
1188
+ tokenMetadata: v27.object({
1189
+ tokenIdentifier: v27.string(),
1190
+ tokenName: v27.string(),
1191
+ tokenTicker: v27.string(),
1192
+ decimals: v27.number(),
1193
+ maxSupply: v27.string()
1172
1194
  })
1173
1195
  })
1174
1196
  )
1175
1197
  });
1176
- var sparkGetBalanceRequestMessageSchema = v26.object({
1198
+ var sparkGetBalanceRequestMessageSchema = v27.object({
1177
1199
  ...rpcRequestMessageSchema.entries,
1178
- ...v26.object({
1179
- method: v26.literal(sparkGetBalanceMethodName),
1200
+ ...v27.object({
1201
+ method: v27.literal(sparkGetBalanceMethodName),
1180
1202
  params: sparkGetBalanceParamsSchema,
1181
- id: v26.string()
1203
+ id: v27.string()
1182
1204
  }).entries
1183
1205
  });
1184
1206
 
1185
1207
  // src/request/types/sparkMethods/signMessage.ts
1186
- import * as v27 from "valibot";
1208
+ import * as v28 from "valibot";
1187
1209
  var sparkSignMessageMethodName = "spark_signMessage";
1188
- var sparkSignMessageParamsSchema = v27.object({
1210
+ var sparkSignMessageParamsSchema = v28.object({
1189
1211
  /**
1190
1212
  * The message to sign. The message should only consist of valid UTF-8 characters.
1191
1213
  */
1192
- message: v27.string()
1214
+ message: v28.string()
1193
1215
  });
1194
- var sparkSignMessageResultSchema = v27.object({
1216
+ var sparkSignMessageResultSchema = v28.object({
1195
1217
  /**
1196
1218
  * The signature, encoded in base64, of the message hash.
1197
1219
  *
@@ -1199,98 +1221,98 @@ var sparkSignMessageResultSchema = v27.object({
1199
1221
  * and the resulting byte array is hashed with SHA256 before signing
1200
1222
  * with the private key.
1201
1223
  */
1202
- signature: v27.string()
1224
+ signature: v28.string()
1203
1225
  });
1204
- var sparkSignMessageRequestMessageSchema = v27.object({
1226
+ var sparkSignMessageRequestMessageSchema = v28.object({
1205
1227
  ...rpcRequestMessageSchema.entries,
1206
- ...v27.object({
1207
- method: v27.literal(sparkSignMessageMethodName),
1228
+ ...v28.object({
1229
+ method: v28.literal(sparkSignMessageMethodName),
1208
1230
  params: sparkSignMessageParamsSchema,
1209
- id: v27.string()
1231
+ id: v28.string()
1210
1232
  }).entries
1211
1233
  });
1212
1234
 
1213
1235
  // src/request/types/sparkMethods/transfer.ts
1214
- import * as v28 from "valibot";
1236
+ import * as v29 from "valibot";
1215
1237
  var sparkTransferMethodName = "spark_transfer";
1216
- var sparkTransferParamsSchema = v28.object({
1238
+ var sparkTransferParamsSchema = v29.object({
1217
1239
  /**
1218
1240
  * Amount of SATS to transfer as a string or number.
1219
1241
  */
1220
- amountSats: v28.union([v28.number(), v28.string()]),
1242
+ amountSats: v29.union([v29.number(), v29.string()]),
1221
1243
  /**
1222
1244
  * The recipient's spark address.
1223
1245
  */
1224
- receiverSparkAddress: v28.string()
1246
+ receiverSparkAddress: v29.string()
1225
1247
  });
1226
- var sparkTransferResultSchema = v28.object({
1248
+ var sparkTransferResultSchema = v29.object({
1227
1249
  /**
1228
1250
  * The ID of the transaction.
1229
1251
  */
1230
- id: v28.string()
1252
+ id: v29.string()
1231
1253
  });
1232
- var sparkTransferRequestMessageSchema = v28.object({
1254
+ var sparkTransferRequestMessageSchema = v29.object({
1233
1255
  ...rpcRequestMessageSchema.entries,
1234
- ...v28.object({
1235
- method: v28.literal(sparkTransferMethodName),
1256
+ ...v29.object({
1257
+ method: v29.literal(sparkTransferMethodName),
1236
1258
  params: sparkTransferParamsSchema,
1237
- id: v28.string()
1259
+ id: v29.string()
1238
1260
  }).entries
1239
1261
  });
1240
1262
 
1241
1263
  // src/request/types/sparkMethods/transferToken.ts
1242
- import * as v29 from "valibot";
1264
+ import * as v30 from "valibot";
1243
1265
  var sparkTransferTokenMethodName = "spark_transferToken";
1244
- var sparkTransferTokenParamsSchema = v29.object({
1266
+ var sparkTransferTokenParamsSchema = v30.object({
1245
1267
  /**
1246
1268
  * Amount of units of the token to transfer as a string or number.
1247
1269
  */
1248
- tokenAmount: v29.union([v29.number(), v29.string()]),
1270
+ tokenAmount: v30.union([v30.number(), v30.string()]),
1249
1271
  /**
1250
1272
  * The Bech32m token identifier.
1251
1273
  */
1252
- tokenIdentifier: v29.string(),
1274
+ tokenIdentifier: v30.string(),
1253
1275
  /**
1254
1276
  * The recipient's spark address.
1255
1277
  */
1256
- receiverSparkAddress: v29.string()
1278
+ receiverSparkAddress: v30.string()
1257
1279
  });
1258
- var sparkTransferTokenResultSchema = v29.object({
1280
+ var sparkTransferTokenResultSchema = v30.object({
1259
1281
  /**
1260
1282
  * The ID of the transaction.
1261
1283
  */
1262
- id: v29.string()
1284
+ id: v30.string()
1263
1285
  });
1264
- var sparkTransferTokenRequestMessageSchema = v29.object({
1286
+ var sparkTransferTokenRequestMessageSchema = v30.object({
1265
1287
  ...rpcRequestMessageSchema.entries,
1266
- ...v29.object({
1267
- method: v29.literal(sparkTransferTokenMethodName),
1288
+ ...v30.object({
1289
+ method: v30.literal(sparkTransferTokenMethodName),
1268
1290
  params: sparkTransferTokenParamsSchema,
1269
- id: v29.string()
1291
+ id: v30.string()
1270
1292
  }).entries
1271
1293
  });
1272
1294
 
1273
1295
  // src/request/types/stxMethods/callContract.ts
1274
- import * as v30 from "valibot";
1296
+ import * as v31 from "valibot";
1275
1297
  var stxCallContractMethodName = "stx_callContract";
1276
- var stxCallContractParamsSchema = v30.object({
1298
+ var stxCallContractParamsSchema = v31.object({
1277
1299
  /**
1278
1300
  * The contract principal.
1279
1301
  *
1280
1302
  * E.g. `"SPKE...GD5C.my-contract"`
1281
1303
  */
1282
- contract: v30.string(),
1304
+ contract: v31.string(),
1283
1305
  /**
1284
1306
  * The name of the function to call.
1285
1307
  *
1286
1308
  * Note: spec changes ongoing,
1287
1309
  * https://github.com/stacksgov/sips/pull/166#pullrequestreview-1914236999
1288
1310
  */
1289
- functionName: v30.string(),
1311
+ functionName: v31.string(),
1290
1312
  /**
1291
1313
  * @deprecated in favor of `functionArgs` for @stacks/connect compatibility
1292
1314
  */
1293
- arguments: v30.optional(v30.array(v30.string())),
1315
+ arguments: v31.optional(v31.array(v31.string())),
1294
1316
  /**
1295
1317
  * The function's arguments. The arguments are expected to be hex-encoded
1296
1318
  * strings of Clarity values.
@@ -1305,274 +1327,274 @@ var stxCallContractParamsSchema = v30.object({
1305
1327
  * const hexArgs = functionArgs.map(cvToHex);
1306
1328
  * ```
1307
1329
  */
1308
- functionArgs: v30.optional(v30.array(v30.string())),
1330
+ functionArgs: v31.optional(v31.array(v31.string())),
1309
1331
  /**
1310
1332
  * The post conditions to apply to the contract call.
1311
1333
  */
1312
- postConditions: v30.optional(v30.array(v30.string())),
1334
+ postConditions: v31.optional(v31.array(v31.string())),
1313
1335
  /**
1314
1336
  * The mode to apply to the post conditions.
1315
1337
  */
1316
- postConditionMode: v30.optional(v30.union([v30.literal("allow"), v30.literal("deny")]))
1338
+ postConditionMode: v31.optional(v31.union([v31.literal("allow"), v31.literal("deny")]))
1317
1339
  });
1318
- var stxCallContractResultSchema = v30.object({
1340
+ var stxCallContractResultSchema = v31.object({
1319
1341
  /**
1320
1342
  * The ID of the transaction.
1321
1343
  */
1322
- txid: v30.string(),
1344
+ txid: v31.string(),
1323
1345
  /**
1324
1346
  * A Stacks transaction as a hex-encoded string.
1325
1347
  */
1326
- transaction: v30.string()
1348
+ transaction: v31.string()
1327
1349
  });
1328
- var stxCallContractRequestMessageSchema = v30.object({
1350
+ var stxCallContractRequestMessageSchema = v31.object({
1329
1351
  ...rpcRequestMessageSchema.entries,
1330
- ...v30.object({
1331
- method: v30.literal(stxCallContractMethodName),
1352
+ ...v31.object({
1353
+ method: v31.literal(stxCallContractMethodName),
1332
1354
  params: stxCallContractParamsSchema,
1333
- id: v30.string()
1355
+ id: v31.string()
1334
1356
  }).entries
1335
1357
  });
1336
1358
 
1337
1359
  // src/request/types/stxMethods/deployContract.ts
1338
- import * as v31 from "valibot";
1360
+ import * as v32 from "valibot";
1339
1361
  var stxDeployContractMethodName = "stx_deployContract";
1340
- var stxDeployContractParamsSchema = v31.object({
1362
+ var stxDeployContractParamsSchema = v32.object({
1341
1363
  /**
1342
1364
  * Name of the contract.
1343
1365
  */
1344
- name: v31.string(),
1366
+ name: v32.string(),
1345
1367
  /**
1346
1368
  * The source code of the Clarity contract.
1347
1369
  */
1348
- clarityCode: v31.string(),
1370
+ clarityCode: v32.string(),
1349
1371
  /**
1350
1372
  * The version of the Clarity contract.
1351
1373
  */
1352
- clarityVersion: v31.optional(v31.number()),
1374
+ clarityVersion: v32.optional(v32.number()),
1353
1375
  /**
1354
1376
  * The post conditions to apply to the contract call.
1355
1377
  */
1356
- postConditions: v31.optional(v31.array(v31.string())),
1378
+ postConditions: v32.optional(v32.array(v32.string())),
1357
1379
  /**
1358
1380
  * The mode to apply to the post conditions.
1359
1381
  */
1360
- postConditionMode: v31.optional(v31.union([v31.literal("allow"), v31.literal("deny")]))
1382
+ postConditionMode: v32.optional(v32.union([v32.literal("allow"), v32.literal("deny")]))
1361
1383
  });
1362
- var stxDeployContractResultSchema = v31.object({
1384
+ var stxDeployContractResultSchema = v32.object({
1363
1385
  /**
1364
1386
  * The ID of the transaction.
1365
1387
  */
1366
- txid: v31.string(),
1388
+ txid: v32.string(),
1367
1389
  /**
1368
1390
  * A Stacks transaction as a hex-encoded string.
1369
1391
  */
1370
- transaction: v31.string()
1392
+ transaction: v32.string()
1371
1393
  });
1372
- var stxDeployContractRequestMessageSchema = v31.object({
1394
+ var stxDeployContractRequestMessageSchema = v32.object({
1373
1395
  ...rpcRequestMessageSchema.entries,
1374
- ...v31.object({
1375
- method: v31.literal(stxDeployContractMethodName),
1396
+ ...v32.object({
1397
+ method: v32.literal(stxDeployContractMethodName),
1376
1398
  params: stxDeployContractParamsSchema,
1377
- id: v31.string()
1399
+ id: v32.string()
1378
1400
  }).entries
1379
1401
  });
1380
1402
 
1381
1403
  // src/request/types/stxMethods/getAccounts.ts
1382
- import * as v32 from "valibot";
1404
+ import * as v33 from "valibot";
1383
1405
  var stxGetAccountsMethodName = "stx_getAccounts";
1384
- var stxGetAccountsParamsSchema = v32.nullish(v32.null());
1385
- var stxGetAccountsResultSchema = v32.object({
1406
+ var stxGetAccountsParamsSchema = v33.nullish(v33.null());
1407
+ var stxGetAccountsResultSchema = v33.object({
1386
1408
  /**
1387
1409
  * The addresses generated for the given purposes.
1388
1410
  */
1389
- addresses: v32.array(
1390
- v32.object({
1391
- address: v32.string(),
1392
- publicKey: v32.string(),
1393
- gaiaHubUrl: v32.string(),
1394
- gaiaAppKey: v32.string()
1411
+ addresses: v33.array(
1412
+ v33.object({
1413
+ address: v33.string(),
1414
+ publicKey: v33.string(),
1415
+ gaiaHubUrl: v33.string(),
1416
+ gaiaAppKey: v33.string()
1395
1417
  })
1396
1418
  ),
1397
1419
  network: getNetworkResultSchema
1398
1420
  });
1399
- var stxGetAccountsRequestMessageSchema = v32.object({
1421
+ var stxGetAccountsRequestMessageSchema = v33.object({
1400
1422
  ...rpcRequestMessageSchema.entries,
1401
- ...v32.object({
1402
- method: v32.literal(stxGetAccountsMethodName),
1423
+ ...v33.object({
1424
+ method: v33.literal(stxGetAccountsMethodName),
1403
1425
  params: stxGetAccountsParamsSchema,
1404
- id: v32.string()
1426
+ id: v33.string()
1405
1427
  }).entries
1406
1428
  });
1407
1429
 
1408
1430
  // src/request/types/stxMethods/getAddresses.ts
1409
- import * as v33 from "valibot";
1431
+ import * as v34 from "valibot";
1410
1432
  var stxGetAddressesMethodName = "stx_getAddresses";
1411
- var stxGetAddressesParamsSchema = v33.nullish(
1412
- v33.object({
1433
+ var stxGetAddressesParamsSchema = v34.nullish(
1434
+ v34.object({
1413
1435
  /**
1414
1436
  * A message to be displayed to the user in the request prompt.
1415
1437
  */
1416
- message: v33.optional(v33.string())
1438
+ message: v34.optional(v34.string())
1417
1439
  })
1418
1440
  );
1419
- var stxGetAddressesResultSchema = v33.object({
1441
+ var stxGetAddressesResultSchema = v34.object({
1420
1442
  /**
1421
1443
  * The addresses generated for the given purposes.
1422
1444
  */
1423
- addresses: v33.array(addressSchema),
1445
+ addresses: v34.array(addressSchema),
1424
1446
  network: getNetworkResultSchema
1425
1447
  });
1426
- var stxGetAddressesRequestMessageSchema = v33.object({
1448
+ var stxGetAddressesRequestMessageSchema = v34.object({
1427
1449
  ...rpcRequestMessageSchema.entries,
1428
- ...v33.object({
1429
- method: v33.literal(stxGetAddressesMethodName),
1450
+ ...v34.object({
1451
+ method: v34.literal(stxGetAddressesMethodName),
1430
1452
  params: stxGetAddressesParamsSchema,
1431
- id: v33.string()
1453
+ id: v34.string()
1432
1454
  }).entries
1433
1455
  });
1434
1456
 
1435
1457
  // src/request/types/stxMethods/signMessage.ts
1436
- import * as v34 from "valibot";
1458
+ import * as v35 from "valibot";
1437
1459
  var stxSignMessageMethodName = "stx_signMessage";
1438
- var stxSignMessageParamsSchema = v34.object({
1460
+ var stxSignMessageParamsSchema = v35.object({
1439
1461
  /**
1440
1462
  * The message to sign.
1441
1463
  */
1442
- message: v34.string()
1464
+ message: v35.string()
1443
1465
  });
1444
- var stxSignMessageResultSchema = v34.object({
1466
+ var stxSignMessageResultSchema = v35.object({
1445
1467
  /**
1446
1468
  * The signature of the message.
1447
1469
  */
1448
- signature: v34.string(),
1470
+ signature: v35.string(),
1449
1471
  /**
1450
1472
  * The public key used to sign the message.
1451
1473
  */
1452
- publicKey: v34.string()
1474
+ publicKey: v35.string()
1453
1475
  });
1454
- var stxSignMessageRequestMessageSchema = v34.object({
1476
+ var stxSignMessageRequestMessageSchema = v35.object({
1455
1477
  ...rpcRequestMessageSchema.entries,
1456
- ...v34.object({
1457
- method: v34.literal(stxSignMessageMethodName),
1478
+ ...v35.object({
1479
+ method: v35.literal(stxSignMessageMethodName),
1458
1480
  params: stxSignMessageParamsSchema,
1459
- id: v34.string()
1481
+ id: v35.string()
1460
1482
  }).entries
1461
1483
  });
1462
1484
 
1463
1485
  // src/request/types/stxMethods/signStructuredMessage.ts
1464
- import * as v35 from "valibot";
1486
+ import * as v36 from "valibot";
1465
1487
  var stxSignStructuredMessageMethodName = "stx_signStructuredMessage";
1466
- var stxSignStructuredMessageParamsSchema = v35.object({
1488
+ var stxSignStructuredMessageParamsSchema = v36.object({
1467
1489
  /**
1468
1490
  * The domain to be signed.
1469
1491
  */
1470
- domain: v35.string(),
1492
+ domain: v36.string(),
1471
1493
  /**
1472
1494
  * Message payload to be signed.
1473
1495
  */
1474
- message: v35.string(),
1496
+ message: v36.string(),
1475
1497
  /**
1476
1498
  * The public key to sign the message with.
1477
1499
  */
1478
- publicKey: v35.optional(v35.string())
1500
+ publicKey: v36.optional(v36.string())
1479
1501
  });
1480
- var stxSignStructuredMessageResultSchema = v35.object({
1502
+ var stxSignStructuredMessageResultSchema = v36.object({
1481
1503
  /**
1482
1504
  * Signature of the message.
1483
1505
  */
1484
- signature: v35.string(),
1506
+ signature: v36.string(),
1485
1507
  /**
1486
1508
  * Public key as hex-encoded string.
1487
1509
  */
1488
- publicKey: v35.string()
1510
+ publicKey: v36.string()
1489
1511
  });
1490
- var stxSignStructuredMessageRequestMessageSchema = v35.object({
1512
+ var stxSignStructuredMessageRequestMessageSchema = v36.object({
1491
1513
  ...rpcRequestMessageSchema.entries,
1492
- ...v35.object({
1493
- method: v35.literal(stxSignStructuredMessageMethodName),
1514
+ ...v36.object({
1515
+ method: v36.literal(stxSignStructuredMessageMethodName),
1494
1516
  params: stxSignStructuredMessageParamsSchema,
1495
- id: v35.string()
1517
+ id: v36.string()
1496
1518
  }).entries
1497
1519
  });
1498
1520
 
1499
1521
  // src/request/types/stxMethods/signTransaction.ts
1500
- import * as v36 from "valibot";
1522
+ import * as v37 from "valibot";
1501
1523
  var stxSignTransactionMethodName = "stx_signTransaction";
1502
- var stxSignTransactionParamsSchema = v36.object({
1524
+ var stxSignTransactionParamsSchema = v37.object({
1503
1525
  /**
1504
1526
  * The transaction to sign as a hex-encoded string.
1505
1527
  */
1506
- transaction: v36.string(),
1528
+ transaction: v37.string(),
1507
1529
  /**
1508
1530
  * The public key to sign the transaction with. The wallet may use any key
1509
1531
  * when not provided.
1510
1532
  */
1511
- pubkey: v36.optional(v36.string()),
1533
+ pubkey: v37.optional(v37.string()),
1512
1534
  /**
1513
1535
  * Whether to broadcast the transaction after signing. Defaults to `true`.
1514
1536
  */
1515
- broadcast: v36.optional(v36.boolean())
1537
+ broadcast: v37.optional(v37.boolean())
1516
1538
  });
1517
- var stxSignTransactionResultSchema = v36.object({
1539
+ var stxSignTransactionResultSchema = v37.object({
1518
1540
  /**
1519
1541
  * The signed transaction as a hex-encoded string.
1520
1542
  */
1521
- transaction: v36.string()
1543
+ transaction: v37.string()
1522
1544
  });
1523
- var stxSignTransactionRequestMessageSchema = v36.object({
1545
+ var stxSignTransactionRequestMessageSchema = v37.object({
1524
1546
  ...rpcRequestMessageSchema.entries,
1525
- ...v36.object({
1526
- method: v36.literal(stxSignTransactionMethodName),
1547
+ ...v37.object({
1548
+ method: v37.literal(stxSignTransactionMethodName),
1527
1549
  params: stxSignTransactionParamsSchema,
1528
- id: v36.string()
1550
+ id: v37.string()
1529
1551
  }).entries
1530
1552
  });
1531
1553
 
1532
1554
  // src/request/types/stxMethods/signTransactions.ts
1533
- import * as v37 from "valibot";
1555
+ import * as v38 from "valibot";
1534
1556
  var stxSignTransactionsMethodName = "stx_signTransactions";
1535
- var stxSignTransactionsParamsSchema = v37.object({
1557
+ var stxSignTransactionsParamsSchema = v38.object({
1536
1558
  /**
1537
1559
  * The transactions to sign as hex-encoded strings.
1538
1560
  */
1539
- transactions: v37.pipe(
1540
- v37.array(
1541
- v37.pipe(
1542
- v37.string(),
1543
- v37.check((hex) => {
1561
+ transactions: v38.pipe(
1562
+ v38.array(
1563
+ v38.pipe(
1564
+ v38.string(),
1565
+ v38.check((hex) => {
1544
1566
  return true;
1545
1567
  }, "Invalid hex-encoded Stacks transaction.")
1546
1568
  )
1547
1569
  ),
1548
- v37.minLength(1)
1570
+ v38.minLength(1)
1549
1571
  ),
1550
1572
  /**
1551
1573
  * Whether the signed transactions should be broadcast after signing. Defaults
1552
1574
  * to `true`.
1553
1575
  */
1554
- broadcast: v37.optional(v37.boolean())
1576
+ broadcast: v38.optional(v38.boolean())
1555
1577
  });
1556
- var stxSignTransactionsResultSchema = v37.object({
1578
+ var stxSignTransactionsResultSchema = v38.object({
1557
1579
  /**
1558
1580
  * The signed transactions as hex-encoded strings, in the same order as in the
1559
1581
  * sign request.
1560
1582
  */
1561
- transactions: v37.array(v37.string())
1583
+ transactions: v38.array(v38.string())
1562
1584
  });
1563
- var stxSignTransactionsRequestMessageSchema = v37.object({
1585
+ var stxSignTransactionsRequestMessageSchema = v38.object({
1564
1586
  ...rpcRequestMessageSchema.entries,
1565
- ...v37.object({
1566
- method: v37.literal(stxSignTransactionsMethodName),
1587
+ ...v38.object({
1588
+ method: v38.literal(stxSignTransactionsMethodName),
1567
1589
  params: stxSignTransactionsParamsSchema,
1568
- id: v37.string()
1590
+ id: v38.string()
1569
1591
  }).entries
1570
1592
  });
1571
1593
 
1572
1594
  // src/request/types/stxMethods/transferStx.ts
1573
- import * as v38 from "valibot";
1595
+ import * as v39 from "valibot";
1574
1596
  var stxTransferStxMethodName = "stx_transferStx";
1575
- var stxTransferStxParamsSchema = v38.object({
1597
+ var stxTransferStxParamsSchema = v39.object({
1576
1598
  /**
1577
1599
  * Amount of STX tokens to transfer in microstacks as a string. Anything
1578
1600
  * parseable by `BigInt` is acceptable.
@@ -1585,23 +1607,23 @@ var stxTransferStxParamsSchema = v38.object({
1585
1607
  * const amount3 = '1234';
1586
1608
  * ```
1587
1609
  */
1588
- amount: v38.union([v38.number(), v38.string()]),
1610
+ amount: v39.union([v39.number(), v39.string()]),
1589
1611
  /**
1590
1612
  * The recipient's principal.
1591
1613
  */
1592
- recipient: v38.string(),
1614
+ recipient: v39.string(),
1593
1615
  /**
1594
1616
  * A string representing the memo.
1595
1617
  */
1596
- memo: v38.optional(v38.string()),
1618
+ memo: v39.optional(v39.string()),
1597
1619
  /**
1598
1620
  * Version of parameter format.
1599
1621
  */
1600
- version: v38.optional(v38.string()),
1622
+ version: v39.optional(v39.string()),
1601
1623
  /**
1602
1624
  * The mode of the post conditions.
1603
1625
  */
1604
- postConditionMode: v38.optional(v38.number()),
1626
+ postConditionMode: v39.optional(v39.number()),
1605
1627
  /**
1606
1628
  * A hex-encoded string representing the post conditions.
1607
1629
  *
@@ -1614,29 +1636,29 @@ var stxTransferStxParamsSchema = v38.object({
1614
1636
  * const hexPostCondition = serializePostCondition(postCondition).toString('hex');
1615
1637
  * ```
1616
1638
  */
1617
- postConditions: v38.optional(v38.array(v38.string())),
1639
+ postConditions: v39.optional(v39.array(v39.string())),
1618
1640
  /**
1619
1641
  * The public key to sign the transaction with. The wallet may use any key
1620
1642
  * when not provided.
1621
1643
  */
1622
- pubkey: v38.optional(v38.string())
1644
+ pubkey: v39.optional(v39.string())
1623
1645
  });
1624
- var stxTransferStxResultSchema = v38.object({
1646
+ var stxTransferStxResultSchema = v39.object({
1625
1647
  /**
1626
1648
  * The ID of the transaction.
1627
1649
  */
1628
- txid: v38.string(),
1650
+ txid: v39.string(),
1629
1651
  /**
1630
1652
  * A Stacks transaction as a hex-encoded string.
1631
1653
  */
1632
- transaction: v38.string()
1654
+ transaction: v39.string()
1633
1655
  });
1634
- var stxTransferStxRequestMessageSchema = v38.object({
1656
+ var stxTransferStxRequestMessageSchema = v39.object({
1635
1657
  ...rpcRequestMessageSchema.entries,
1636
- ...v38.object({
1637
- method: v38.literal(stxTransferStxMethodName),
1658
+ ...v39.object({
1659
+ method: v39.literal(stxTransferStxMethodName),
1638
1660
  params: stxTransferStxParamsSchema,
1639
- id: v38.string()
1661
+ id: v39.string()
1640
1662
  }).entries
1641
1663
  });
1642
1664
 
@@ -1644,13 +1666,13 @@ var stxTransferStxRequestMessageSchema = v38.object({
1644
1666
  var cache = {};
1645
1667
  var requestInternal = async (provider, method, params) => {
1646
1668
  const response = await provider.request(method, params);
1647
- if (v39.is(rpcErrorResponseMessageSchema, response)) {
1669
+ if (v40.is(rpcErrorResponseMessageSchema, response)) {
1648
1670
  return {
1649
1671
  status: "error",
1650
1672
  error: response.error
1651
1673
  };
1652
1674
  }
1653
- if (v39.is(rpcSuccessResponseMessageSchema, response)) {
1675
+ if (v40.is(rpcSuccessResponseMessageSchema, response)) {
1654
1676
  return {
1655
1677
  status: "success",
1656
1678
  result: response.result
@@ -2843,6 +2865,10 @@ export {
2843
2865
  sparkFlashnetConfirmInitialDepositIntentSchema,
2844
2866
  sparkFlashnetCreateConstantProductPoolIntentSchema,
2845
2867
  sparkFlashnetCreateSingleSidedPoolIntentSchema,
2868
+ sparkFlashnetExecuteClawBackMethodName,
2869
+ sparkFlashnetExecuteClawBackParamsSchema,
2870
+ sparkFlashnetExecuteClawBackRequestMessageSchema,
2871
+ sparkFlashnetExecuteClawBackResultSchema,
2846
2872
  sparkFlashnetExecuteRouteSwapMethodName,
2847
2873
  sparkFlashnetExecuteRouteSwapParamsSchema,
2848
2874
  sparkFlashnetExecuteRouteSwapRequestMessageSchema,