@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.d.mts +27 -1
- package/dist/index.d.ts +27 -1
- package/dist/index.js +351 -321
- package/dist/index.mjs +347 -321
- package/package.json +1 -1
package/dist/index.mjs
CHANGED
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
// src/request/index.ts
|
|
2
|
-
import * as
|
|
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/
|
|
865
|
+
// src/request/types/sparkMethods/flashnetMethods/executeClawBack.ts
|
|
866
866
|
import * as v12 from "valibot";
|
|
867
|
-
var
|
|
868
|
-
var
|
|
869
|
-
|
|
870
|
-
|
|
871
|
-
|
|
872
|
-
|
|
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
|
-
|
|
888
|
-
|
|
889
|
-
finalOutboundTransferId: v12.string(),
|
|
890
|
-
error: v12.optional(v12.string())
|
|
875
|
+
internalRequestId: v12.string(),
|
|
876
|
+
sparkStatusTrackingId: v12.string()
|
|
891
877
|
});
|
|
892
|
-
var
|
|
878
|
+
var sparkFlashnetExecuteClawBackRequestMessageSchema = v12.object({
|
|
893
879
|
...rpcRequestMessageSchema.entries,
|
|
894
880
|
...v12.object({
|
|
895
|
-
method: v12.literal(
|
|
896
|
-
params:
|
|
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/
|
|
887
|
+
// src/request/types/sparkMethods/flashnetMethods/executeRouteSwap.ts
|
|
902
888
|
import * as v13 from "valibot";
|
|
903
|
-
var
|
|
904
|
-
var
|
|
905
|
-
|
|
906
|
-
|
|
907
|
-
|
|
908
|
-
|
|
909
|
-
|
|
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
|
|
906
|
+
var sparkFlashnetExecuteRouteSwapResultSchema = v13.object({
|
|
915
907
|
requestId: v13.string(),
|
|
916
908
|
accepted: v13.boolean(),
|
|
917
|
-
|
|
918
|
-
|
|
919
|
-
|
|
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
|
|
914
|
+
var sparkFlashnetExecuteRouteSwapRequestMessageSchema = v13.object({
|
|
926
915
|
...rpcRequestMessageSchema.entries,
|
|
927
916
|
...v13.object({
|
|
928
|
-
method: v13.literal(
|
|
929
|
-
params:
|
|
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/
|
|
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 =
|
|
938
|
-
var sparkFlashnetGetJwtResultSchema =
|
|
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:
|
|
964
|
+
jwt: v15.string()
|
|
943
965
|
});
|
|
944
|
-
var sparkFlashnetGetJwtRequestMessageSchema =
|
|
966
|
+
var sparkFlashnetGetJwtRequestMessageSchema = v15.object({
|
|
945
967
|
...rpcRequestMessageSchema.entries,
|
|
946
|
-
...
|
|
947
|
-
method:
|
|
968
|
+
...v15.object({
|
|
969
|
+
method: v15.literal(sparkFlashnetGetJwtMethodName),
|
|
948
970
|
params: sparkFlashnetGetJwtParamsSchema,
|
|
949
|
-
id:
|
|
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
|
|
973
|
-
type: v16.literal("
|
|
977
|
+
var sparkFlashnetAddLiquidityIntentSchema = v16.object({
|
|
978
|
+
type: v16.literal("addLiquidity"),
|
|
974
979
|
data: v16.object({
|
|
975
|
-
|
|
976
|
-
|
|
977
|
-
|
|
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/
|
|
992
|
+
// src/request/types/sparkMethods/flashnetMethods/intents/clawback.ts
|
|
983
993
|
import * as v17 from "valibot";
|
|
984
|
-
var
|
|
985
|
-
type: v17.literal("
|
|
994
|
+
var sparkFlashnetClawbackIntentSchema = v17.object({
|
|
995
|
+
type: v17.literal("clawback"),
|
|
986
996
|
data: v17.object({
|
|
987
|
-
|
|
988
|
-
|
|
989
|
-
|
|
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/
|
|
1004
|
+
// src/request/types/sparkMethods/flashnetMethods/intents/confirmInitialDeposit.ts
|
|
995
1005
|
import * as v18 from "valibot";
|
|
996
|
-
var
|
|
997
|
-
type: v18.literal("
|
|
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/
|
|
1016
|
+
// src/request/types/sparkMethods/flashnetMethods/intents/createConstantProductPool.ts
|
|
1009
1017
|
import * as v19 from "valibot";
|
|
1010
|
-
var
|
|
1011
|
-
type: v19.literal("
|
|
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/
|
|
1030
|
+
// src/request/types/sparkMethods/flashnetMethods/intents/createSingleSidedPool.ts
|
|
1027
1031
|
import * as v20 from "valibot";
|
|
1028
|
-
var
|
|
1029
|
-
type: v20.literal("
|
|
1032
|
+
var sparkFlashnetCreateSingleSidedPoolIntentSchema = v20.object({
|
|
1033
|
+
type: v20.literal("createSingleSidedPool"),
|
|
1030
1034
|
data: v20.object({
|
|
1031
|
-
|
|
1032
|
-
|
|
1033
|
-
|
|
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/
|
|
1048
|
+
// src/request/types/sparkMethods/flashnetMethods/intents/removeLiquidity.ts
|
|
1039
1049
|
import * as v21 from "valibot";
|
|
1040
|
-
var
|
|
1041
|
-
type: v21.literal("
|
|
1050
|
+
var sparkFlashnetRemoveLiquidityIntentSchema = v21.object({
|
|
1051
|
+
type: v21.literal("removeLiquidity"),
|
|
1042
1052
|
data: v21.object({
|
|
1043
1053
|
userPublicKey: v21.string(),
|
|
1044
|
-
|
|
1045
|
-
|
|
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/
|
|
1060
|
+
// src/request/types/sparkMethods/flashnetMethods/intents/routeSwap.ts
|
|
1062
1061
|
import * as v22 from "valibot";
|
|
1063
|
-
var
|
|
1064
|
-
type: v22.literal("
|
|
1062
|
+
var sparkFlashnetRouteSwapIntentSchema = v22.object({
|
|
1063
|
+
type: v22.literal("executeRouteSwap"),
|
|
1065
1064
|
data: v22.object({
|
|
1066
1065
|
userPublicKey: v22.string(),
|
|
1067
|
-
|
|
1068
|
-
|
|
1069
|
-
|
|
1070
|
-
|
|
1071
|
-
|
|
1072
|
-
|
|
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
|
-
|
|
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/
|
|
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 =
|
|
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 =
|
|
1114
|
+
var sparkFlashnetSignIntentResultSchema = v24.object({
|
|
1093
1115
|
/**
|
|
1094
1116
|
* The signed intent as a hex string.
|
|
1095
1117
|
*/
|
|
1096
|
-
signature:
|
|
1118
|
+
signature: v24.string()
|
|
1097
1119
|
});
|
|
1098
|
-
var sparkFlashnetSignIntentRequestMessageSchema =
|
|
1120
|
+
var sparkFlashnetSignIntentRequestMessageSchema = v24.object({
|
|
1099
1121
|
...rpcRequestMessageSchema.entries,
|
|
1100
|
-
...
|
|
1101
|
-
method:
|
|
1122
|
+
...v24.object({
|
|
1123
|
+
method: v24.literal(sparkFlashnetSignIntentMethodName),
|
|
1102
1124
|
params: sparkFlashnetSignIntentParamsSchema,
|
|
1103
|
-
id:
|
|
1125
|
+
id: v24.string()
|
|
1104
1126
|
}).entries
|
|
1105
1127
|
});
|
|
1106
1128
|
|
|
1107
1129
|
// src/request/types/sparkMethods/flashnetMethods/signStructuredMessage.ts
|
|
1108
|
-
import * as
|
|
1130
|
+
import * as v25 from "valibot";
|
|
1109
1131
|
var sparkFlashnetSignStructuredMessageMethodName = "spark_flashnet_signStructuredMessage";
|
|
1110
|
-
var sparkFlashnetSignStructuredMessageParamsSchema =
|
|
1111
|
-
message:
|
|
1132
|
+
var sparkFlashnetSignStructuredMessageParamsSchema = v25.object({
|
|
1133
|
+
message: v25.string()
|
|
1112
1134
|
});
|
|
1113
|
-
var sparkFlashnetSignStructuredMessageResultSchema =
|
|
1114
|
-
message:
|
|
1115
|
-
signature:
|
|
1135
|
+
var sparkFlashnetSignStructuredMessageResultSchema = v25.object({
|
|
1136
|
+
message: v25.string(),
|
|
1137
|
+
signature: v25.string()
|
|
1116
1138
|
});
|
|
1117
|
-
var sparkFlashnetSignStructuredMessageRequestMessageSchema =
|
|
1139
|
+
var sparkFlashnetSignStructuredMessageRequestMessageSchema = v25.object({
|
|
1118
1140
|
...rpcRequestMessageSchema.entries,
|
|
1119
|
-
...
|
|
1120
|
-
method:
|
|
1141
|
+
...v25.object({
|
|
1142
|
+
method: v25.literal(sparkFlashnetSignStructuredMessageMethodName),
|
|
1121
1143
|
params: sparkFlashnetSignStructuredMessageParamsSchema,
|
|
1122
|
-
id:
|
|
1144
|
+
id: v25.string()
|
|
1123
1145
|
}).entries
|
|
1124
1146
|
});
|
|
1125
1147
|
|
|
1126
1148
|
// src/request/types/sparkMethods/getAddresses.ts
|
|
1127
|
-
import * as
|
|
1149
|
+
import * as v26 from "valibot";
|
|
1128
1150
|
var sparkGetAddressesMethodName = "spark_getAddresses";
|
|
1129
|
-
var sparkGetAddressesParamsSchema =
|
|
1130
|
-
|
|
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:
|
|
1156
|
+
message: v26.optional(v26.string())
|
|
1135
1157
|
})
|
|
1136
1158
|
);
|
|
1137
|
-
var sparkGetAddressesResultSchema =
|
|
1159
|
+
var sparkGetAddressesResultSchema = v26.object({
|
|
1138
1160
|
/**
|
|
1139
1161
|
* The addresses generated for the given purposes.
|
|
1140
1162
|
*/
|
|
1141
|
-
addresses:
|
|
1163
|
+
addresses: v26.array(addressSchema),
|
|
1142
1164
|
network: getNetworkResultSchema
|
|
1143
1165
|
});
|
|
1144
|
-
var sparkGetAddressesRequestMessageSchema =
|
|
1166
|
+
var sparkGetAddressesRequestMessageSchema = v26.object({
|
|
1145
1167
|
...rpcRequestMessageSchema.entries,
|
|
1146
|
-
...
|
|
1147
|
-
method:
|
|
1168
|
+
...v26.object({
|
|
1169
|
+
method: v26.literal(sparkGetAddressesMethodName),
|
|
1148
1170
|
params: sparkGetAddressesParamsSchema,
|
|
1149
|
-
id:
|
|
1171
|
+
id: v26.string()
|
|
1150
1172
|
}).entries
|
|
1151
1173
|
});
|
|
1152
1174
|
|
|
1153
1175
|
// src/request/types/sparkMethods/getBalance.ts
|
|
1154
|
-
import * as
|
|
1176
|
+
import * as v27 from "valibot";
|
|
1155
1177
|
var sparkGetBalanceMethodName = "spark_getBalance";
|
|
1156
|
-
var sparkGetBalanceParamsSchema =
|
|
1157
|
-
var sparkGetBalanceResultSchema =
|
|
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:
|
|
1162
|
-
tokenBalances:
|
|
1163
|
-
|
|
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:
|
|
1166
|
-
tokenMetadata:
|
|
1167
|
-
tokenIdentifier:
|
|
1168
|
-
tokenName:
|
|
1169
|
-
tokenTicker:
|
|
1170
|
-
decimals:
|
|
1171
|
-
maxSupply:
|
|
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 =
|
|
1198
|
+
var sparkGetBalanceRequestMessageSchema = v27.object({
|
|
1177
1199
|
...rpcRequestMessageSchema.entries,
|
|
1178
|
-
...
|
|
1179
|
-
method:
|
|
1200
|
+
...v27.object({
|
|
1201
|
+
method: v27.literal(sparkGetBalanceMethodName),
|
|
1180
1202
|
params: sparkGetBalanceParamsSchema,
|
|
1181
|
-
id:
|
|
1203
|
+
id: v27.string()
|
|
1182
1204
|
}).entries
|
|
1183
1205
|
});
|
|
1184
1206
|
|
|
1185
1207
|
// src/request/types/sparkMethods/signMessage.ts
|
|
1186
|
-
import * as
|
|
1208
|
+
import * as v28 from "valibot";
|
|
1187
1209
|
var sparkSignMessageMethodName = "spark_signMessage";
|
|
1188
|
-
var sparkSignMessageParamsSchema =
|
|
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:
|
|
1214
|
+
message: v28.string()
|
|
1193
1215
|
});
|
|
1194
|
-
var sparkSignMessageResultSchema =
|
|
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:
|
|
1224
|
+
signature: v28.string()
|
|
1203
1225
|
});
|
|
1204
|
-
var sparkSignMessageRequestMessageSchema =
|
|
1226
|
+
var sparkSignMessageRequestMessageSchema = v28.object({
|
|
1205
1227
|
...rpcRequestMessageSchema.entries,
|
|
1206
|
-
...
|
|
1207
|
-
method:
|
|
1228
|
+
...v28.object({
|
|
1229
|
+
method: v28.literal(sparkSignMessageMethodName),
|
|
1208
1230
|
params: sparkSignMessageParamsSchema,
|
|
1209
|
-
id:
|
|
1231
|
+
id: v28.string()
|
|
1210
1232
|
}).entries
|
|
1211
1233
|
});
|
|
1212
1234
|
|
|
1213
1235
|
// src/request/types/sparkMethods/transfer.ts
|
|
1214
|
-
import * as
|
|
1236
|
+
import * as v29 from "valibot";
|
|
1215
1237
|
var sparkTransferMethodName = "spark_transfer";
|
|
1216
|
-
var sparkTransferParamsSchema =
|
|
1238
|
+
var sparkTransferParamsSchema = v29.object({
|
|
1217
1239
|
/**
|
|
1218
1240
|
* Amount of SATS to transfer as a string or number.
|
|
1219
1241
|
*/
|
|
1220
|
-
amountSats:
|
|
1242
|
+
amountSats: v29.union([v29.number(), v29.string()]),
|
|
1221
1243
|
/**
|
|
1222
1244
|
* The recipient's spark address.
|
|
1223
1245
|
*/
|
|
1224
|
-
receiverSparkAddress:
|
|
1246
|
+
receiverSparkAddress: v29.string()
|
|
1225
1247
|
});
|
|
1226
|
-
var sparkTransferResultSchema =
|
|
1248
|
+
var sparkTransferResultSchema = v29.object({
|
|
1227
1249
|
/**
|
|
1228
1250
|
* The ID of the transaction.
|
|
1229
1251
|
*/
|
|
1230
|
-
id:
|
|
1252
|
+
id: v29.string()
|
|
1231
1253
|
});
|
|
1232
|
-
var sparkTransferRequestMessageSchema =
|
|
1254
|
+
var sparkTransferRequestMessageSchema = v29.object({
|
|
1233
1255
|
...rpcRequestMessageSchema.entries,
|
|
1234
|
-
...
|
|
1235
|
-
method:
|
|
1256
|
+
...v29.object({
|
|
1257
|
+
method: v29.literal(sparkTransferMethodName),
|
|
1236
1258
|
params: sparkTransferParamsSchema,
|
|
1237
|
-
id:
|
|
1259
|
+
id: v29.string()
|
|
1238
1260
|
}).entries
|
|
1239
1261
|
});
|
|
1240
1262
|
|
|
1241
1263
|
// src/request/types/sparkMethods/transferToken.ts
|
|
1242
|
-
import * as
|
|
1264
|
+
import * as v30 from "valibot";
|
|
1243
1265
|
var sparkTransferTokenMethodName = "spark_transferToken";
|
|
1244
|
-
var sparkTransferTokenParamsSchema =
|
|
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:
|
|
1270
|
+
tokenAmount: v30.union([v30.number(), v30.string()]),
|
|
1249
1271
|
/**
|
|
1250
1272
|
* The Bech32m token identifier.
|
|
1251
1273
|
*/
|
|
1252
|
-
tokenIdentifier:
|
|
1274
|
+
tokenIdentifier: v30.string(),
|
|
1253
1275
|
/**
|
|
1254
1276
|
* The recipient's spark address.
|
|
1255
1277
|
*/
|
|
1256
|
-
receiverSparkAddress:
|
|
1278
|
+
receiverSparkAddress: v30.string()
|
|
1257
1279
|
});
|
|
1258
|
-
var sparkTransferTokenResultSchema =
|
|
1280
|
+
var sparkTransferTokenResultSchema = v30.object({
|
|
1259
1281
|
/**
|
|
1260
1282
|
* The ID of the transaction.
|
|
1261
1283
|
*/
|
|
1262
|
-
id:
|
|
1284
|
+
id: v30.string()
|
|
1263
1285
|
});
|
|
1264
|
-
var sparkTransferTokenRequestMessageSchema =
|
|
1286
|
+
var sparkTransferTokenRequestMessageSchema = v30.object({
|
|
1265
1287
|
...rpcRequestMessageSchema.entries,
|
|
1266
|
-
...
|
|
1267
|
-
method:
|
|
1288
|
+
...v30.object({
|
|
1289
|
+
method: v30.literal(sparkTransferTokenMethodName),
|
|
1268
1290
|
params: sparkTransferTokenParamsSchema,
|
|
1269
|
-
id:
|
|
1291
|
+
id: v30.string()
|
|
1270
1292
|
}).entries
|
|
1271
1293
|
});
|
|
1272
1294
|
|
|
1273
1295
|
// src/request/types/stxMethods/callContract.ts
|
|
1274
|
-
import * as
|
|
1296
|
+
import * as v31 from "valibot";
|
|
1275
1297
|
var stxCallContractMethodName = "stx_callContract";
|
|
1276
|
-
var stxCallContractParamsSchema =
|
|
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:
|
|
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:
|
|
1311
|
+
functionName: v31.string(),
|
|
1290
1312
|
/**
|
|
1291
1313
|
* @deprecated in favor of `functionArgs` for @stacks/connect compatibility
|
|
1292
1314
|
*/
|
|
1293
|
-
arguments:
|
|
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:
|
|
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:
|
|
1334
|
+
postConditions: v31.optional(v31.array(v31.string())),
|
|
1313
1335
|
/**
|
|
1314
1336
|
* The mode to apply to the post conditions.
|
|
1315
1337
|
*/
|
|
1316
|
-
postConditionMode:
|
|
1338
|
+
postConditionMode: v31.optional(v31.union([v31.literal("allow"), v31.literal("deny")]))
|
|
1317
1339
|
});
|
|
1318
|
-
var stxCallContractResultSchema =
|
|
1340
|
+
var stxCallContractResultSchema = v31.object({
|
|
1319
1341
|
/**
|
|
1320
1342
|
* The ID of the transaction.
|
|
1321
1343
|
*/
|
|
1322
|
-
txid:
|
|
1344
|
+
txid: v31.string(),
|
|
1323
1345
|
/**
|
|
1324
1346
|
* A Stacks transaction as a hex-encoded string.
|
|
1325
1347
|
*/
|
|
1326
|
-
transaction:
|
|
1348
|
+
transaction: v31.string()
|
|
1327
1349
|
});
|
|
1328
|
-
var stxCallContractRequestMessageSchema =
|
|
1350
|
+
var stxCallContractRequestMessageSchema = v31.object({
|
|
1329
1351
|
...rpcRequestMessageSchema.entries,
|
|
1330
|
-
...
|
|
1331
|
-
method:
|
|
1352
|
+
...v31.object({
|
|
1353
|
+
method: v31.literal(stxCallContractMethodName),
|
|
1332
1354
|
params: stxCallContractParamsSchema,
|
|
1333
|
-
id:
|
|
1355
|
+
id: v31.string()
|
|
1334
1356
|
}).entries
|
|
1335
1357
|
});
|
|
1336
1358
|
|
|
1337
1359
|
// src/request/types/stxMethods/deployContract.ts
|
|
1338
|
-
import * as
|
|
1360
|
+
import * as v32 from "valibot";
|
|
1339
1361
|
var stxDeployContractMethodName = "stx_deployContract";
|
|
1340
|
-
var stxDeployContractParamsSchema =
|
|
1362
|
+
var stxDeployContractParamsSchema = v32.object({
|
|
1341
1363
|
/**
|
|
1342
1364
|
* Name of the contract.
|
|
1343
1365
|
*/
|
|
1344
|
-
name:
|
|
1366
|
+
name: v32.string(),
|
|
1345
1367
|
/**
|
|
1346
1368
|
* The source code of the Clarity contract.
|
|
1347
1369
|
*/
|
|
1348
|
-
clarityCode:
|
|
1370
|
+
clarityCode: v32.string(),
|
|
1349
1371
|
/**
|
|
1350
1372
|
* The version of the Clarity contract.
|
|
1351
1373
|
*/
|
|
1352
|
-
clarityVersion:
|
|
1374
|
+
clarityVersion: v32.optional(v32.number()),
|
|
1353
1375
|
/**
|
|
1354
1376
|
* The post conditions to apply to the contract call.
|
|
1355
1377
|
*/
|
|
1356
|
-
postConditions:
|
|
1378
|
+
postConditions: v32.optional(v32.array(v32.string())),
|
|
1357
1379
|
/**
|
|
1358
1380
|
* The mode to apply to the post conditions.
|
|
1359
1381
|
*/
|
|
1360
|
-
postConditionMode:
|
|
1382
|
+
postConditionMode: v32.optional(v32.union([v32.literal("allow"), v32.literal("deny")]))
|
|
1361
1383
|
});
|
|
1362
|
-
var stxDeployContractResultSchema =
|
|
1384
|
+
var stxDeployContractResultSchema = v32.object({
|
|
1363
1385
|
/**
|
|
1364
1386
|
* The ID of the transaction.
|
|
1365
1387
|
*/
|
|
1366
|
-
txid:
|
|
1388
|
+
txid: v32.string(),
|
|
1367
1389
|
/**
|
|
1368
1390
|
* A Stacks transaction as a hex-encoded string.
|
|
1369
1391
|
*/
|
|
1370
|
-
transaction:
|
|
1392
|
+
transaction: v32.string()
|
|
1371
1393
|
});
|
|
1372
|
-
var stxDeployContractRequestMessageSchema =
|
|
1394
|
+
var stxDeployContractRequestMessageSchema = v32.object({
|
|
1373
1395
|
...rpcRequestMessageSchema.entries,
|
|
1374
|
-
...
|
|
1375
|
-
method:
|
|
1396
|
+
...v32.object({
|
|
1397
|
+
method: v32.literal(stxDeployContractMethodName),
|
|
1376
1398
|
params: stxDeployContractParamsSchema,
|
|
1377
|
-
id:
|
|
1399
|
+
id: v32.string()
|
|
1378
1400
|
}).entries
|
|
1379
1401
|
});
|
|
1380
1402
|
|
|
1381
1403
|
// src/request/types/stxMethods/getAccounts.ts
|
|
1382
|
-
import * as
|
|
1404
|
+
import * as v33 from "valibot";
|
|
1383
1405
|
var stxGetAccountsMethodName = "stx_getAccounts";
|
|
1384
|
-
var stxGetAccountsParamsSchema =
|
|
1385
|
-
var stxGetAccountsResultSchema =
|
|
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:
|
|
1390
|
-
|
|
1391
|
-
address:
|
|
1392
|
-
publicKey:
|
|
1393
|
-
gaiaHubUrl:
|
|
1394
|
-
gaiaAppKey:
|
|
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 =
|
|
1421
|
+
var stxGetAccountsRequestMessageSchema = v33.object({
|
|
1400
1422
|
...rpcRequestMessageSchema.entries,
|
|
1401
|
-
...
|
|
1402
|
-
method:
|
|
1423
|
+
...v33.object({
|
|
1424
|
+
method: v33.literal(stxGetAccountsMethodName),
|
|
1403
1425
|
params: stxGetAccountsParamsSchema,
|
|
1404
|
-
id:
|
|
1426
|
+
id: v33.string()
|
|
1405
1427
|
}).entries
|
|
1406
1428
|
});
|
|
1407
1429
|
|
|
1408
1430
|
// src/request/types/stxMethods/getAddresses.ts
|
|
1409
|
-
import * as
|
|
1431
|
+
import * as v34 from "valibot";
|
|
1410
1432
|
var stxGetAddressesMethodName = "stx_getAddresses";
|
|
1411
|
-
var stxGetAddressesParamsSchema =
|
|
1412
|
-
|
|
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:
|
|
1438
|
+
message: v34.optional(v34.string())
|
|
1417
1439
|
})
|
|
1418
1440
|
);
|
|
1419
|
-
var stxGetAddressesResultSchema =
|
|
1441
|
+
var stxGetAddressesResultSchema = v34.object({
|
|
1420
1442
|
/**
|
|
1421
1443
|
* The addresses generated for the given purposes.
|
|
1422
1444
|
*/
|
|
1423
|
-
addresses:
|
|
1445
|
+
addresses: v34.array(addressSchema),
|
|
1424
1446
|
network: getNetworkResultSchema
|
|
1425
1447
|
});
|
|
1426
|
-
var stxGetAddressesRequestMessageSchema =
|
|
1448
|
+
var stxGetAddressesRequestMessageSchema = v34.object({
|
|
1427
1449
|
...rpcRequestMessageSchema.entries,
|
|
1428
|
-
...
|
|
1429
|
-
method:
|
|
1450
|
+
...v34.object({
|
|
1451
|
+
method: v34.literal(stxGetAddressesMethodName),
|
|
1430
1452
|
params: stxGetAddressesParamsSchema,
|
|
1431
|
-
id:
|
|
1453
|
+
id: v34.string()
|
|
1432
1454
|
}).entries
|
|
1433
1455
|
});
|
|
1434
1456
|
|
|
1435
1457
|
// src/request/types/stxMethods/signMessage.ts
|
|
1436
|
-
import * as
|
|
1458
|
+
import * as v35 from "valibot";
|
|
1437
1459
|
var stxSignMessageMethodName = "stx_signMessage";
|
|
1438
|
-
var stxSignMessageParamsSchema =
|
|
1460
|
+
var stxSignMessageParamsSchema = v35.object({
|
|
1439
1461
|
/**
|
|
1440
1462
|
* The message to sign.
|
|
1441
1463
|
*/
|
|
1442
|
-
message:
|
|
1464
|
+
message: v35.string()
|
|
1443
1465
|
});
|
|
1444
|
-
var stxSignMessageResultSchema =
|
|
1466
|
+
var stxSignMessageResultSchema = v35.object({
|
|
1445
1467
|
/**
|
|
1446
1468
|
* The signature of the message.
|
|
1447
1469
|
*/
|
|
1448
|
-
signature:
|
|
1470
|
+
signature: v35.string(),
|
|
1449
1471
|
/**
|
|
1450
1472
|
* The public key used to sign the message.
|
|
1451
1473
|
*/
|
|
1452
|
-
publicKey:
|
|
1474
|
+
publicKey: v35.string()
|
|
1453
1475
|
});
|
|
1454
|
-
var stxSignMessageRequestMessageSchema =
|
|
1476
|
+
var stxSignMessageRequestMessageSchema = v35.object({
|
|
1455
1477
|
...rpcRequestMessageSchema.entries,
|
|
1456
|
-
...
|
|
1457
|
-
method:
|
|
1478
|
+
...v35.object({
|
|
1479
|
+
method: v35.literal(stxSignMessageMethodName),
|
|
1458
1480
|
params: stxSignMessageParamsSchema,
|
|
1459
|
-
id:
|
|
1481
|
+
id: v35.string()
|
|
1460
1482
|
}).entries
|
|
1461
1483
|
});
|
|
1462
1484
|
|
|
1463
1485
|
// src/request/types/stxMethods/signStructuredMessage.ts
|
|
1464
|
-
import * as
|
|
1486
|
+
import * as v36 from "valibot";
|
|
1465
1487
|
var stxSignStructuredMessageMethodName = "stx_signStructuredMessage";
|
|
1466
|
-
var stxSignStructuredMessageParamsSchema =
|
|
1488
|
+
var stxSignStructuredMessageParamsSchema = v36.object({
|
|
1467
1489
|
/**
|
|
1468
1490
|
* The domain to be signed.
|
|
1469
1491
|
*/
|
|
1470
|
-
domain:
|
|
1492
|
+
domain: v36.string(),
|
|
1471
1493
|
/**
|
|
1472
1494
|
* Message payload to be signed.
|
|
1473
1495
|
*/
|
|
1474
|
-
message:
|
|
1496
|
+
message: v36.string(),
|
|
1475
1497
|
/**
|
|
1476
1498
|
* The public key to sign the message with.
|
|
1477
1499
|
*/
|
|
1478
|
-
publicKey:
|
|
1500
|
+
publicKey: v36.optional(v36.string())
|
|
1479
1501
|
});
|
|
1480
|
-
var stxSignStructuredMessageResultSchema =
|
|
1502
|
+
var stxSignStructuredMessageResultSchema = v36.object({
|
|
1481
1503
|
/**
|
|
1482
1504
|
* Signature of the message.
|
|
1483
1505
|
*/
|
|
1484
|
-
signature:
|
|
1506
|
+
signature: v36.string(),
|
|
1485
1507
|
/**
|
|
1486
1508
|
* Public key as hex-encoded string.
|
|
1487
1509
|
*/
|
|
1488
|
-
publicKey:
|
|
1510
|
+
publicKey: v36.string()
|
|
1489
1511
|
});
|
|
1490
|
-
var stxSignStructuredMessageRequestMessageSchema =
|
|
1512
|
+
var stxSignStructuredMessageRequestMessageSchema = v36.object({
|
|
1491
1513
|
...rpcRequestMessageSchema.entries,
|
|
1492
|
-
...
|
|
1493
|
-
method:
|
|
1514
|
+
...v36.object({
|
|
1515
|
+
method: v36.literal(stxSignStructuredMessageMethodName),
|
|
1494
1516
|
params: stxSignStructuredMessageParamsSchema,
|
|
1495
|
-
id:
|
|
1517
|
+
id: v36.string()
|
|
1496
1518
|
}).entries
|
|
1497
1519
|
});
|
|
1498
1520
|
|
|
1499
1521
|
// src/request/types/stxMethods/signTransaction.ts
|
|
1500
|
-
import * as
|
|
1522
|
+
import * as v37 from "valibot";
|
|
1501
1523
|
var stxSignTransactionMethodName = "stx_signTransaction";
|
|
1502
|
-
var stxSignTransactionParamsSchema =
|
|
1524
|
+
var stxSignTransactionParamsSchema = v37.object({
|
|
1503
1525
|
/**
|
|
1504
1526
|
* The transaction to sign as a hex-encoded string.
|
|
1505
1527
|
*/
|
|
1506
|
-
transaction:
|
|
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:
|
|
1533
|
+
pubkey: v37.optional(v37.string()),
|
|
1512
1534
|
/**
|
|
1513
1535
|
* Whether to broadcast the transaction after signing. Defaults to `true`.
|
|
1514
1536
|
*/
|
|
1515
|
-
broadcast:
|
|
1537
|
+
broadcast: v37.optional(v37.boolean())
|
|
1516
1538
|
});
|
|
1517
|
-
var stxSignTransactionResultSchema =
|
|
1539
|
+
var stxSignTransactionResultSchema = v37.object({
|
|
1518
1540
|
/**
|
|
1519
1541
|
* The signed transaction as a hex-encoded string.
|
|
1520
1542
|
*/
|
|
1521
|
-
transaction:
|
|
1543
|
+
transaction: v37.string()
|
|
1522
1544
|
});
|
|
1523
|
-
var stxSignTransactionRequestMessageSchema =
|
|
1545
|
+
var stxSignTransactionRequestMessageSchema = v37.object({
|
|
1524
1546
|
...rpcRequestMessageSchema.entries,
|
|
1525
|
-
...
|
|
1526
|
-
method:
|
|
1547
|
+
...v37.object({
|
|
1548
|
+
method: v37.literal(stxSignTransactionMethodName),
|
|
1527
1549
|
params: stxSignTransactionParamsSchema,
|
|
1528
|
-
id:
|
|
1550
|
+
id: v37.string()
|
|
1529
1551
|
}).entries
|
|
1530
1552
|
});
|
|
1531
1553
|
|
|
1532
1554
|
// src/request/types/stxMethods/signTransactions.ts
|
|
1533
|
-
import * as
|
|
1555
|
+
import * as v38 from "valibot";
|
|
1534
1556
|
var stxSignTransactionsMethodName = "stx_signTransactions";
|
|
1535
|
-
var stxSignTransactionsParamsSchema =
|
|
1557
|
+
var stxSignTransactionsParamsSchema = v38.object({
|
|
1536
1558
|
/**
|
|
1537
1559
|
* The transactions to sign as hex-encoded strings.
|
|
1538
1560
|
*/
|
|
1539
|
-
transactions:
|
|
1540
|
-
|
|
1541
|
-
|
|
1542
|
-
|
|
1543
|
-
|
|
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
|
-
|
|
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:
|
|
1576
|
+
broadcast: v38.optional(v38.boolean())
|
|
1555
1577
|
});
|
|
1556
|
-
var stxSignTransactionsResultSchema =
|
|
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:
|
|
1583
|
+
transactions: v38.array(v38.string())
|
|
1562
1584
|
});
|
|
1563
|
-
var stxSignTransactionsRequestMessageSchema =
|
|
1585
|
+
var stxSignTransactionsRequestMessageSchema = v38.object({
|
|
1564
1586
|
...rpcRequestMessageSchema.entries,
|
|
1565
|
-
...
|
|
1566
|
-
method:
|
|
1587
|
+
...v38.object({
|
|
1588
|
+
method: v38.literal(stxSignTransactionsMethodName),
|
|
1567
1589
|
params: stxSignTransactionsParamsSchema,
|
|
1568
|
-
id:
|
|
1590
|
+
id: v38.string()
|
|
1569
1591
|
}).entries
|
|
1570
1592
|
});
|
|
1571
1593
|
|
|
1572
1594
|
// src/request/types/stxMethods/transferStx.ts
|
|
1573
|
-
import * as
|
|
1595
|
+
import * as v39 from "valibot";
|
|
1574
1596
|
var stxTransferStxMethodName = "stx_transferStx";
|
|
1575
|
-
var stxTransferStxParamsSchema =
|
|
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:
|
|
1610
|
+
amount: v39.union([v39.number(), v39.string()]),
|
|
1589
1611
|
/**
|
|
1590
1612
|
* The recipient's principal.
|
|
1591
1613
|
*/
|
|
1592
|
-
recipient:
|
|
1614
|
+
recipient: v39.string(),
|
|
1593
1615
|
/**
|
|
1594
1616
|
* A string representing the memo.
|
|
1595
1617
|
*/
|
|
1596
|
-
memo:
|
|
1618
|
+
memo: v39.optional(v39.string()),
|
|
1597
1619
|
/**
|
|
1598
1620
|
* Version of parameter format.
|
|
1599
1621
|
*/
|
|
1600
|
-
version:
|
|
1622
|
+
version: v39.optional(v39.string()),
|
|
1601
1623
|
/**
|
|
1602
1624
|
* The mode of the post conditions.
|
|
1603
1625
|
*/
|
|
1604
|
-
postConditionMode:
|
|
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:
|
|
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:
|
|
1644
|
+
pubkey: v39.optional(v39.string())
|
|
1623
1645
|
});
|
|
1624
|
-
var stxTransferStxResultSchema =
|
|
1646
|
+
var stxTransferStxResultSchema = v39.object({
|
|
1625
1647
|
/**
|
|
1626
1648
|
* The ID of the transaction.
|
|
1627
1649
|
*/
|
|
1628
|
-
txid:
|
|
1650
|
+
txid: v39.string(),
|
|
1629
1651
|
/**
|
|
1630
1652
|
* A Stacks transaction as a hex-encoded string.
|
|
1631
1653
|
*/
|
|
1632
|
-
transaction:
|
|
1654
|
+
transaction: v39.string()
|
|
1633
1655
|
});
|
|
1634
|
-
var stxTransferStxRequestMessageSchema =
|
|
1656
|
+
var stxTransferStxRequestMessageSchema = v39.object({
|
|
1635
1657
|
...rpcRequestMessageSchema.entries,
|
|
1636
|
-
...
|
|
1637
|
-
method:
|
|
1658
|
+
...v39.object({
|
|
1659
|
+
method: v39.literal(stxTransferStxMethodName),
|
|
1638
1660
|
params: stxTransferStxParamsSchema,
|
|
1639
|
-
id:
|
|
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 (
|
|
1669
|
+
if (v40.is(rpcErrorResponseMessageSchema, response)) {
|
|
1648
1670
|
return {
|
|
1649
1671
|
status: "error",
|
|
1650
1672
|
error: response.error
|
|
1651
1673
|
};
|
|
1652
1674
|
}
|
|
1653
|
-
if (
|
|
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,
|