@sats-connect/core 0.18.1-2baa4e8 → 0.18.2-14a18d8

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 CHANGED
@@ -310,8 +310,59 @@ declare const unlockDefinitionSchema: v.VariantSchema<"type", [v.ObjectSchema<{
310
310
  }[], 1, undefined>]>;
311
311
  }, undefined>], undefined>;
312
312
  type UnlockDefinition = v.InferOutput<typeof unlockDefinitionSchema>;
313
+ /**
314
+ * Address fields without the cross-field checks; spread `.entries` to extend it, but validate
315
+ * wallet responses with `addressSchema`.
316
+ */
317
+ declare const addressObjectSchema: v.ObjectSchema<{
318
+ readonly address: v.StringSchema<undefined>;
319
+ /**
320
+ * Empty string for multisig (vault) Stacks addresses, which have no single public key.
321
+ */
322
+ readonly publicKey: v.StringSchema<undefined>;
323
+ readonly purpose: v.EnumSchema<typeof AddressPurpose, undefined>;
324
+ readonly addressType: v.EnumSchema<typeof AddressType, undefined>;
325
+ readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone", "multisig"], undefined>;
326
+ readonly scriptPubKey: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "Expected lowercase, even-length hex without a 0x prefix">]>, undefined>;
327
+ readonly unlockDefinition: v.OptionalSchema<v.VariantSchema<"type", [v.ObjectSchema<{
328
+ readonly type: v.LiteralSchema<"p2wpkh", undefined>;
329
+ }, undefined>, v.ObjectSchema<{
330
+ readonly type: v.LiteralSchema<"p2sh-p2wpkh", undefined>;
331
+ readonly redeemScript: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "Expected lowercase, even-length hex without a 0x prefix">]>;
332
+ }, undefined>, v.ObjectSchema<{
333
+ readonly type: v.LiteralSchema<"p2tr-key-path", undefined>;
334
+ readonly tapInternalKey: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "Expected lowercase, even-length hex without a 0x prefix">]>, v.LengthAction<string, 64, "Expected a 32-byte x-only key">]>;
335
+ }, undefined>, v.ObjectSchema<{
336
+ readonly type: v.LiteralSchema<"p2wsh", undefined>;
337
+ readonly witnessScript: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "Expected lowercase, even-length hex without a 0x prefix">]>;
338
+ }, undefined>, v.ObjectSchema<{
339
+ readonly type: v.LiteralSchema<"p2tr-script-path", undefined>;
340
+ readonly tapLeafScript: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
341
+ readonly script: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "Expected lowercase, even-length hex without a 0x prefix">]>;
342
+ readonly controlBlock: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "Expected lowercase, even-length hex without a 0x prefix">]>, v.CheckAction<string, "Expected a 33+32n byte BIP341 control block">]>;
343
+ }, undefined>, v.CheckAction<{
344
+ script: string;
345
+ controlBlock: string;
346
+ }, "Tapleaf version does not match the control block">]>, undefined>, v.MinLengthAction<{
347
+ script: string;
348
+ controlBlock: string;
349
+ }[], 1, undefined>]>;
350
+ }, undefined>], undefined>, undefined>;
351
+ /**
352
+ * Signer set of a multisig Stacks address. Only present on Stacks-purpose entries from
353
+ * wallets that support it; older wallets omit it, so fall back to `stx_getAccounts`.
354
+ */
355
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
356
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
357
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
358
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
359
+ }, undefined>, undefined>;
360
+ }, undefined>;
313
361
  declare const addressSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
314
362
  readonly address: v.StringSchema<undefined>;
363
+ /**
364
+ * Empty string for multisig (vault) Stacks addresses, which have no single public key.
365
+ */
315
366
  readonly publicKey: v.StringSchema<undefined>;
316
367
  readonly purpose: v.EnumSchema<typeof AddressPurpose, undefined>;
317
368
  readonly addressType: v.EnumSchema<typeof AddressType, undefined>;
@@ -341,6 +392,15 @@ declare const addressSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
341
392
  controlBlock: string;
342
393
  }[], 1, undefined>]>;
343
394
  }, undefined>], undefined>, undefined>;
395
+ /**
396
+ * Signer set of a multisig Stacks address. Only present on Stacks-purpose entries from
397
+ * wallets that support it; older wallets omit it, so fall back to `stx_getAccounts`.
398
+ */
399
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
400
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
401
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
402
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
403
+ }, undefined>, undefined>;
344
404
  }, undefined>, v.CheckAction<{
345
405
  address: string;
346
406
  publicKey: string;
@@ -366,6 +426,11 @@ declare const addressSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
366
426
  controlBlock: string;
367
427
  }[];
368
428
  } | undefined;
429
+ stacksMultisig?: {
430
+ hashMode: "P2SHNonSequential";
431
+ threshold: number;
432
+ publicKeys: string[];
433
+ } | undefined;
369
434
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
370
435
  address: string;
371
436
  publicKey: string;
@@ -391,7 +456,42 @@ declare const addressSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
391
456
  controlBlock: string;
392
457
  }[];
393
458
  } | undefined;
394
- }, "unlockDefinition type does not match addressType">]>;
459
+ stacksMultisig?: {
460
+ hashMode: "P2SHNonSequential";
461
+ threshold: number;
462
+ publicKeys: string[];
463
+ } | undefined;
464
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
465
+ address: string;
466
+ publicKey: string;
467
+ purpose: AddressPurpose;
468
+ addressType: AddressType;
469
+ walletType: "software" | "ledger" | "keystone" | "multisig";
470
+ scriptPubKey?: string | undefined;
471
+ unlockDefinition?: {
472
+ type: "p2wpkh";
473
+ } | {
474
+ type: "p2sh-p2wpkh";
475
+ redeemScript: string;
476
+ } | {
477
+ type: "p2tr-key-path";
478
+ tapInternalKey: string;
479
+ } | {
480
+ type: "p2wsh";
481
+ witnessScript: string;
482
+ } | {
483
+ type: "p2tr-script-path";
484
+ tapLeafScript: {
485
+ script: string;
486
+ controlBlock: string;
487
+ }[];
488
+ } | undefined;
489
+ stacksMultisig?: {
490
+ hashMode: "P2SHNonSequential";
491
+ threshold: number;
492
+ publicKeys: string[];
493
+ } | undefined;
494
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>;
395
495
  type Address = v.InferOutput<typeof addressSchema>;
396
496
  interface GetAddressResponse {
397
497
  addresses: Address[];
@@ -467,6 +567,11 @@ declare const bitcoinGetAccountsResultSchema: v.ArraySchema<v.SchemaWithPipe<rea
467
567
  controlBlock: string;
468
568
  }[], 1, undefined>]>;
469
569
  }, undefined>], undefined>, undefined>;
570
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
571
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
572
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
573
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
574
+ }, undefined>, undefined>;
470
575
  }, undefined>, v.CheckAction<{
471
576
  address: string;
472
577
  publicKey: string;
@@ -492,6 +597,11 @@ declare const bitcoinGetAccountsResultSchema: v.ArraySchema<v.SchemaWithPipe<rea
492
597
  controlBlock: string;
493
598
  }[];
494
599
  } | undefined;
600
+ stacksMultisig?: {
601
+ hashMode: "P2SHNonSequential";
602
+ threshold: number;
603
+ publicKeys: string[];
604
+ } | undefined;
495
605
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
496
606
  address: string;
497
607
  publicKey: string;
@@ -517,7 +627,42 @@ declare const bitcoinGetAccountsResultSchema: v.ArraySchema<v.SchemaWithPipe<rea
517
627
  controlBlock: string;
518
628
  }[];
519
629
  } | undefined;
520
- }, "unlockDefinition type does not match addressType">]>, undefined>;
630
+ stacksMultisig?: {
631
+ hashMode: "P2SHNonSequential";
632
+ threshold: number;
633
+ publicKeys: string[];
634
+ } | undefined;
635
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
636
+ address: string;
637
+ publicKey: string;
638
+ purpose: AddressPurpose;
639
+ addressType: AddressType;
640
+ walletType: "software" | "ledger" | "keystone" | "multisig";
641
+ scriptPubKey?: string | undefined;
642
+ unlockDefinition?: {
643
+ type: "p2wpkh";
644
+ } | {
645
+ type: "p2sh-p2wpkh";
646
+ redeemScript: string;
647
+ } | {
648
+ type: "p2tr-key-path";
649
+ tapInternalKey: string;
650
+ } | {
651
+ type: "p2wsh";
652
+ witnessScript: string;
653
+ } | {
654
+ type: "p2tr-script-path";
655
+ tapLeafScript: {
656
+ script: string;
657
+ controlBlock: string;
658
+ }[];
659
+ } | undefined;
660
+ stacksMultisig?: {
661
+ hashMode: "P2SHNonSequential";
662
+ threshold: number;
663
+ publicKeys: string[];
664
+ } | undefined;
665
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
521
666
  type BitcoinGetAccountsResult = v.InferOutput<typeof bitcoinGetAccountsResultSchema>;
522
667
  declare const bitcoinGetAccountsSuccessResponseSchema: v.ObjectSchema<{
523
668
  readonly id: v.StringSchema<undefined>;
@@ -552,6 +697,11 @@ declare const bitcoinGetAccountsSuccessResponseSchema: v.ObjectSchema<{
552
697
  controlBlock: string;
553
698
  }[], 1, undefined>]>;
554
699
  }, undefined>], undefined>, undefined>;
700
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
701
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
702
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
703
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
704
+ }, undefined>, undefined>;
555
705
  }, undefined>, v.CheckAction<{
556
706
  address: string;
557
707
  publicKey: string;
@@ -577,6 +727,11 @@ declare const bitcoinGetAccountsSuccessResponseSchema: v.ObjectSchema<{
577
727
  controlBlock: string;
578
728
  }[];
579
729
  } | undefined;
730
+ stacksMultisig?: {
731
+ hashMode: "P2SHNonSequential";
732
+ threshold: number;
733
+ publicKeys: string[];
734
+ } | undefined;
580
735
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
581
736
  address: string;
582
737
  publicKey: string;
@@ -602,7 +757,42 @@ declare const bitcoinGetAccountsSuccessResponseSchema: v.ObjectSchema<{
602
757
  controlBlock: string;
603
758
  }[];
604
759
  } | undefined;
605
- }, "unlockDefinition type does not match addressType">]>, undefined>;
760
+ stacksMultisig?: {
761
+ hashMode: "P2SHNonSequential";
762
+ threshold: number;
763
+ publicKeys: string[];
764
+ } | undefined;
765
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
766
+ address: string;
767
+ publicKey: string;
768
+ purpose: AddressPurpose;
769
+ addressType: AddressType;
770
+ walletType: "software" | "ledger" | "keystone" | "multisig";
771
+ scriptPubKey?: string | undefined;
772
+ unlockDefinition?: {
773
+ type: "p2wpkh";
774
+ } | {
775
+ type: "p2sh-p2wpkh";
776
+ redeemScript: string;
777
+ } | {
778
+ type: "p2tr-key-path";
779
+ tapInternalKey: string;
780
+ } | {
781
+ type: "p2wsh";
782
+ witnessScript: string;
783
+ } | {
784
+ type: "p2tr-script-path";
785
+ tapLeafScript: {
786
+ script: string;
787
+ controlBlock: string;
788
+ }[];
789
+ } | undefined;
790
+ stacksMultisig?: {
791
+ hashMode: "P2SHNonSequential";
792
+ threshold: number;
793
+ publicKeys: string[];
794
+ } | undefined;
795
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
606
796
  readonly '~sats-connect-method': v.LiteralSchema<"getAccounts", undefined>;
607
797
  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
608
798
  readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
@@ -682,6 +872,11 @@ declare const bitcoinGetAddressesResultSchema: v.ObjectSchema<{
682
872
  controlBlock: string;
683
873
  }[], 1, undefined>]>;
684
874
  }, undefined>], undefined>, undefined>;
875
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
876
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
877
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
878
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
879
+ }, undefined>, undefined>;
685
880
  }, undefined>, v.CheckAction<{
686
881
  address: string;
687
882
  publicKey: string;
@@ -707,6 +902,11 @@ declare const bitcoinGetAddressesResultSchema: v.ObjectSchema<{
707
902
  controlBlock: string;
708
903
  }[];
709
904
  } | undefined;
905
+ stacksMultisig?: {
906
+ hashMode: "P2SHNonSequential";
907
+ threshold: number;
908
+ publicKeys: string[];
909
+ } | undefined;
710
910
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
711
911
  address: string;
712
912
  publicKey: string;
@@ -732,7 +932,42 @@ declare const bitcoinGetAddressesResultSchema: v.ObjectSchema<{
732
932
  controlBlock: string;
733
933
  }[];
734
934
  } | undefined;
735
- }, "unlockDefinition type does not match addressType">]>, undefined>;
935
+ stacksMultisig?: {
936
+ hashMode: "P2SHNonSequential";
937
+ threshold: number;
938
+ publicKeys: string[];
939
+ } | undefined;
940
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
941
+ address: string;
942
+ publicKey: string;
943
+ purpose: AddressPurpose;
944
+ addressType: AddressType;
945
+ walletType: "software" | "ledger" | "keystone" | "multisig";
946
+ scriptPubKey?: string | undefined;
947
+ unlockDefinition?: {
948
+ type: "p2wpkh";
949
+ } | {
950
+ type: "p2sh-p2wpkh";
951
+ redeemScript: string;
952
+ } | {
953
+ type: "p2tr-key-path";
954
+ tapInternalKey: string;
955
+ } | {
956
+ type: "p2wsh";
957
+ witnessScript: string;
958
+ } | {
959
+ type: "p2tr-script-path";
960
+ tapLeafScript: {
961
+ script: string;
962
+ controlBlock: string;
963
+ }[];
964
+ } | undefined;
965
+ stacksMultisig?: {
966
+ hashMode: "P2SHNonSequential";
967
+ threshold: number;
968
+ publicKeys: string[];
969
+ } | undefined;
970
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
736
971
  readonly network: v.ObjectSchema<{
737
972
  readonly bitcoin: v.ObjectSchema<{
738
973
  readonly name: v.StringSchema<undefined>;
@@ -783,6 +1018,11 @@ declare const bitcoinGetAddressesSuccessResponseSchema: v.ObjectSchema<{
783
1018
  controlBlock: string;
784
1019
  }[], 1, undefined>]>;
785
1020
  }, undefined>], undefined>, undefined>;
1021
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
1022
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
1023
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
1024
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
1025
+ }, undefined>, undefined>;
786
1026
  }, undefined>, v.CheckAction<{
787
1027
  address: string;
788
1028
  publicKey: string;
@@ -808,6 +1048,11 @@ declare const bitcoinGetAddressesSuccessResponseSchema: v.ObjectSchema<{
808
1048
  controlBlock: string;
809
1049
  }[];
810
1050
  } | undefined;
1051
+ stacksMultisig?: {
1052
+ hashMode: "P2SHNonSequential";
1053
+ threshold: number;
1054
+ publicKeys: string[];
1055
+ } | undefined;
811
1056
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
812
1057
  address: string;
813
1058
  publicKey: string;
@@ -833,7 +1078,42 @@ declare const bitcoinGetAddressesSuccessResponseSchema: v.ObjectSchema<{
833
1078
  controlBlock: string;
834
1079
  }[];
835
1080
  } | undefined;
836
- }, "unlockDefinition type does not match addressType">]>, undefined>;
1081
+ stacksMultisig?: {
1082
+ hashMode: "P2SHNonSequential";
1083
+ threshold: number;
1084
+ publicKeys: string[];
1085
+ } | undefined;
1086
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
1087
+ address: string;
1088
+ publicKey: string;
1089
+ purpose: AddressPurpose;
1090
+ addressType: AddressType;
1091
+ walletType: "software" | "ledger" | "keystone" | "multisig";
1092
+ scriptPubKey?: string | undefined;
1093
+ unlockDefinition?: {
1094
+ type: "p2wpkh";
1095
+ } | {
1096
+ type: "p2sh-p2wpkh";
1097
+ redeemScript: string;
1098
+ } | {
1099
+ type: "p2tr-key-path";
1100
+ tapInternalKey: string;
1101
+ } | {
1102
+ type: "p2wsh";
1103
+ witnessScript: string;
1104
+ } | {
1105
+ type: "p2tr-script-path";
1106
+ tapLeafScript: {
1107
+ script: string;
1108
+ controlBlock: string;
1109
+ }[];
1110
+ } | undefined;
1111
+ stacksMultisig?: {
1112
+ hashMode: "P2SHNonSequential";
1113
+ threshold: number;
1114
+ publicKeys: string[];
1115
+ } | undefined;
1116
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
837
1117
  readonly network: v.ObjectSchema<{
838
1118
  readonly bitcoin: v.ObjectSchema<{
839
1119
  readonly name: v.StringSchema<undefined>;
@@ -925,6 +1205,11 @@ declare const bitcoinGetAddressesV2ResultSchema: v.ObjectSchema<{
925
1205
  controlBlock: string;
926
1206
  }[], 1, undefined>]>;
927
1207
  }, undefined>], undefined>, undefined>;
1208
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
1209
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
1210
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
1211
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
1212
+ }, undefined>, undefined>;
928
1213
  }, undefined>, v.CheckAction<{
929
1214
  address: string;
930
1215
  publicKey: string;
@@ -950,6 +1235,11 @@ declare const bitcoinGetAddressesV2ResultSchema: v.ObjectSchema<{
950
1235
  controlBlock: string;
951
1236
  }[];
952
1237
  } | undefined;
1238
+ stacksMultisig?: {
1239
+ hashMode: "P2SHNonSequential";
1240
+ threshold: number;
1241
+ publicKeys: string[];
1242
+ } | undefined;
953
1243
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
954
1244
  address: string;
955
1245
  publicKey: string;
@@ -975,7 +1265,42 @@ declare const bitcoinGetAddressesV2ResultSchema: v.ObjectSchema<{
975
1265
  controlBlock: string;
976
1266
  }[];
977
1267
  } | undefined;
978
- }, "unlockDefinition type does not match addressType">]>, undefined>;
1268
+ stacksMultisig?: {
1269
+ hashMode: "P2SHNonSequential";
1270
+ threshold: number;
1271
+ publicKeys: string[];
1272
+ } | undefined;
1273
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
1274
+ address: string;
1275
+ publicKey: string;
1276
+ purpose: AddressPurpose;
1277
+ addressType: AddressType;
1278
+ walletType: "software" | "ledger" | "keystone" | "multisig";
1279
+ scriptPubKey?: string | undefined;
1280
+ unlockDefinition?: {
1281
+ type: "p2wpkh";
1282
+ } | {
1283
+ type: "p2sh-p2wpkh";
1284
+ redeemScript: string;
1285
+ } | {
1286
+ type: "p2tr-key-path";
1287
+ tapInternalKey: string;
1288
+ } | {
1289
+ type: "p2wsh";
1290
+ witnessScript: string;
1291
+ } | {
1292
+ type: "p2tr-script-path";
1293
+ tapLeafScript: {
1294
+ script: string;
1295
+ controlBlock: string;
1296
+ }[];
1297
+ } | undefined;
1298
+ stacksMultisig?: {
1299
+ hashMode: "P2SHNonSequential";
1300
+ threshold: number;
1301
+ publicKeys: string[];
1302
+ } | undefined;
1303
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
979
1304
  readonly networks: v.ObjectSchema<{
980
1305
  readonly active: v.ObjectSchema<{
981
1306
  readonly bitcoin: v.ObjectSchema<{
@@ -1152,6 +1477,11 @@ declare const bitcoinGetAddressesV2SuccessResponseSchema: v.ObjectSchema<{
1152
1477
  controlBlock: string;
1153
1478
  }[], 1, undefined>]>;
1154
1479
  }, undefined>], undefined>, undefined>;
1480
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
1481
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
1482
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
1483
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
1484
+ }, undefined>, undefined>;
1155
1485
  }, undefined>, v.CheckAction<{
1156
1486
  address: string;
1157
1487
  publicKey: string;
@@ -1177,6 +1507,11 @@ declare const bitcoinGetAddressesV2SuccessResponseSchema: v.ObjectSchema<{
1177
1507
  controlBlock: string;
1178
1508
  }[];
1179
1509
  } | undefined;
1510
+ stacksMultisig?: {
1511
+ hashMode: "P2SHNonSequential";
1512
+ threshold: number;
1513
+ publicKeys: string[];
1514
+ } | undefined;
1180
1515
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
1181
1516
  address: string;
1182
1517
  publicKey: string;
@@ -1202,7 +1537,42 @@ declare const bitcoinGetAddressesV2SuccessResponseSchema: v.ObjectSchema<{
1202
1537
  controlBlock: string;
1203
1538
  }[];
1204
1539
  } | undefined;
1205
- }, "unlockDefinition type does not match addressType">]>, undefined>;
1540
+ stacksMultisig?: {
1541
+ hashMode: "P2SHNonSequential";
1542
+ threshold: number;
1543
+ publicKeys: string[];
1544
+ } | undefined;
1545
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
1546
+ address: string;
1547
+ publicKey: string;
1548
+ purpose: AddressPurpose;
1549
+ addressType: AddressType;
1550
+ walletType: "software" | "ledger" | "keystone" | "multisig";
1551
+ scriptPubKey?: string | undefined;
1552
+ unlockDefinition?: {
1553
+ type: "p2wpkh";
1554
+ } | {
1555
+ type: "p2sh-p2wpkh";
1556
+ redeemScript: string;
1557
+ } | {
1558
+ type: "p2tr-key-path";
1559
+ tapInternalKey: string;
1560
+ } | {
1561
+ type: "p2wsh";
1562
+ witnessScript: string;
1563
+ } | {
1564
+ type: "p2tr-script-path";
1565
+ tapLeafScript: {
1566
+ script: string;
1567
+ controlBlock: string;
1568
+ }[];
1569
+ } | undefined;
1570
+ stacksMultisig?: {
1571
+ hashMode: "P2SHNonSequential";
1572
+ threshold: number;
1573
+ publicKeys: string[];
1574
+ } | undefined;
1575
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
1206
1576
  readonly networks: v.ObjectSchema<{
1207
1577
  readonly active: v.ObjectSchema<{
1208
1578
  readonly bitcoin: v.ObjectSchema<{
@@ -2044,6 +2414,11 @@ declare const bitcoinSuccessResponseSchema: v.VariantSchema<"~sats-connect-metho
2044
2414
  controlBlock: string;
2045
2415
  }[], 1, undefined>]>;
2046
2416
  }, undefined>], undefined>, undefined>;
2417
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
2418
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
2419
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
2420
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
2421
+ }, undefined>, undefined>;
2047
2422
  }, undefined>, v.CheckAction<{
2048
2423
  address: string;
2049
2424
  publicKey: string;
@@ -2069,6 +2444,11 @@ declare const bitcoinSuccessResponseSchema: v.VariantSchema<"~sats-connect-metho
2069
2444
  controlBlock: string;
2070
2445
  }[];
2071
2446
  } | undefined;
2447
+ stacksMultisig?: {
2448
+ hashMode: "P2SHNonSequential";
2449
+ threshold: number;
2450
+ publicKeys: string[];
2451
+ } | undefined;
2072
2452
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
2073
2453
  address: string;
2074
2454
  publicKey: string;
@@ -2094,23 +2474,58 @@ declare const bitcoinSuccessResponseSchema: v.VariantSchema<"~sats-connect-metho
2094
2474
  controlBlock: string;
2095
2475
  }[];
2096
2476
  } | undefined;
2097
- }, "unlockDefinition type does not match addressType">]>, undefined>;
2098
- readonly '~sats-connect-method': v.LiteralSchema<"getAccounts", undefined>;
2099
- readonly extensions: v.OptionalSchema<v.ObjectSchema<{
2100
- readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
2101
- readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
2102
- readonly message: v.StringSchema<undefined>;
2103
- readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
2104
- }, undefined>], undefined>, undefined>;
2105
- }, undefined>, undefined>;
2106
- readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
2107
- }, undefined>, v.ObjectSchema<{
2108
- readonly id: v.StringSchema<undefined>;
2109
- readonly result: v.ObjectSchema<{
2110
- readonly addresses: v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
2111
- readonly address: v.StringSchema<undefined>;
2112
- readonly publicKey: v.StringSchema<undefined>;
2113
- readonly purpose: v.EnumSchema<typeof AddressPurpose, undefined>;
2477
+ stacksMultisig?: {
2478
+ hashMode: "P2SHNonSequential";
2479
+ threshold: number;
2480
+ publicKeys: string[];
2481
+ } | undefined;
2482
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
2483
+ address: string;
2484
+ publicKey: string;
2485
+ purpose: AddressPurpose;
2486
+ addressType: AddressType;
2487
+ walletType: "software" | "ledger" | "keystone" | "multisig";
2488
+ scriptPubKey?: string | undefined;
2489
+ unlockDefinition?: {
2490
+ type: "p2wpkh";
2491
+ } | {
2492
+ type: "p2sh-p2wpkh";
2493
+ redeemScript: string;
2494
+ } | {
2495
+ type: "p2tr-key-path";
2496
+ tapInternalKey: string;
2497
+ } | {
2498
+ type: "p2wsh";
2499
+ witnessScript: string;
2500
+ } | {
2501
+ type: "p2tr-script-path";
2502
+ tapLeafScript: {
2503
+ script: string;
2504
+ controlBlock: string;
2505
+ }[];
2506
+ } | undefined;
2507
+ stacksMultisig?: {
2508
+ hashMode: "P2SHNonSequential";
2509
+ threshold: number;
2510
+ publicKeys: string[];
2511
+ } | undefined;
2512
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
2513
+ readonly '~sats-connect-method': v.LiteralSchema<"getAccounts", undefined>;
2514
+ readonly extensions: v.OptionalSchema<v.ObjectSchema<{
2515
+ readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
2516
+ readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
2517
+ readonly message: v.StringSchema<undefined>;
2518
+ readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
2519
+ }, undefined>], undefined>, undefined>;
2520
+ }, undefined>, undefined>;
2521
+ readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
2522
+ }, undefined>, v.ObjectSchema<{
2523
+ readonly id: v.StringSchema<undefined>;
2524
+ readonly result: v.ObjectSchema<{
2525
+ readonly addresses: v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
2526
+ readonly address: v.StringSchema<undefined>;
2527
+ readonly publicKey: v.StringSchema<undefined>;
2528
+ readonly purpose: v.EnumSchema<typeof AddressPurpose, undefined>;
2114
2529
  readonly addressType: v.EnumSchema<typeof AddressType, undefined>;
2115
2530
  readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone", "multisig"], undefined>;
2116
2531
  readonly scriptPubKey: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "Expected lowercase, even-length hex without a 0x prefix">]>, undefined>;
@@ -2138,6 +2553,11 @@ declare const bitcoinSuccessResponseSchema: v.VariantSchema<"~sats-connect-metho
2138
2553
  controlBlock: string;
2139
2554
  }[], 1, undefined>]>;
2140
2555
  }, undefined>], undefined>, undefined>;
2556
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
2557
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
2558
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
2559
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
2560
+ }, undefined>, undefined>;
2141
2561
  }, undefined>, v.CheckAction<{
2142
2562
  address: string;
2143
2563
  publicKey: string;
@@ -2163,6 +2583,11 @@ declare const bitcoinSuccessResponseSchema: v.VariantSchema<"~sats-connect-metho
2163
2583
  controlBlock: string;
2164
2584
  }[];
2165
2585
  } | undefined;
2586
+ stacksMultisig?: {
2587
+ hashMode: "P2SHNonSequential";
2588
+ threshold: number;
2589
+ publicKeys: string[];
2590
+ } | undefined;
2166
2591
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
2167
2592
  address: string;
2168
2593
  publicKey: string;
@@ -2188,7 +2613,42 @@ declare const bitcoinSuccessResponseSchema: v.VariantSchema<"~sats-connect-metho
2188
2613
  controlBlock: string;
2189
2614
  }[];
2190
2615
  } | undefined;
2191
- }, "unlockDefinition type does not match addressType">]>, undefined>;
2616
+ stacksMultisig?: {
2617
+ hashMode: "P2SHNonSequential";
2618
+ threshold: number;
2619
+ publicKeys: string[];
2620
+ } | undefined;
2621
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
2622
+ address: string;
2623
+ publicKey: string;
2624
+ purpose: AddressPurpose;
2625
+ addressType: AddressType;
2626
+ walletType: "software" | "ledger" | "keystone" | "multisig";
2627
+ scriptPubKey?: string | undefined;
2628
+ unlockDefinition?: {
2629
+ type: "p2wpkh";
2630
+ } | {
2631
+ type: "p2sh-p2wpkh";
2632
+ redeemScript: string;
2633
+ } | {
2634
+ type: "p2tr-key-path";
2635
+ tapInternalKey: string;
2636
+ } | {
2637
+ type: "p2wsh";
2638
+ witnessScript: string;
2639
+ } | {
2640
+ type: "p2tr-script-path";
2641
+ tapLeafScript: {
2642
+ script: string;
2643
+ controlBlock: string;
2644
+ }[];
2645
+ } | undefined;
2646
+ stacksMultisig?: {
2647
+ hashMode: "P2SHNonSequential";
2648
+ threshold: number;
2649
+ publicKeys: string[];
2650
+ } | undefined;
2651
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
2192
2652
  readonly network: v.ObjectSchema<{
2193
2653
  readonly bitcoin: v.ObjectSchema<{
2194
2654
  readonly name: v.StringSchema<undefined>;
@@ -2244,6 +2704,11 @@ declare const bitcoinSuccessResponseSchema: v.VariantSchema<"~sats-connect-metho
2244
2704
  controlBlock: string;
2245
2705
  }[], 1, undefined>]>;
2246
2706
  }, undefined>], undefined>, undefined>;
2707
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
2708
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
2709
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
2710
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
2711
+ }, undefined>, undefined>;
2247
2712
  }, undefined>, v.CheckAction<{
2248
2713
  address: string;
2249
2714
  publicKey: string;
@@ -2269,6 +2734,11 @@ declare const bitcoinSuccessResponseSchema: v.VariantSchema<"~sats-connect-metho
2269
2734
  controlBlock: string;
2270
2735
  }[];
2271
2736
  } | undefined;
2737
+ stacksMultisig?: {
2738
+ hashMode: "P2SHNonSequential";
2739
+ threshold: number;
2740
+ publicKeys: string[];
2741
+ } | undefined;
2272
2742
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
2273
2743
  address: string;
2274
2744
  publicKey: string;
@@ -2294,7 +2764,42 @@ declare const bitcoinSuccessResponseSchema: v.VariantSchema<"~sats-connect-metho
2294
2764
  controlBlock: string;
2295
2765
  }[];
2296
2766
  } | undefined;
2297
- }, "unlockDefinition type does not match addressType">]>, undefined>;
2767
+ stacksMultisig?: {
2768
+ hashMode: "P2SHNonSequential";
2769
+ threshold: number;
2770
+ publicKeys: string[];
2771
+ } | undefined;
2772
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
2773
+ address: string;
2774
+ publicKey: string;
2775
+ purpose: AddressPurpose;
2776
+ addressType: AddressType;
2777
+ walletType: "software" | "ledger" | "keystone" | "multisig";
2778
+ scriptPubKey?: string | undefined;
2779
+ unlockDefinition?: {
2780
+ type: "p2wpkh";
2781
+ } | {
2782
+ type: "p2sh-p2wpkh";
2783
+ redeemScript: string;
2784
+ } | {
2785
+ type: "p2tr-key-path";
2786
+ tapInternalKey: string;
2787
+ } | {
2788
+ type: "p2wsh";
2789
+ witnessScript: string;
2790
+ } | {
2791
+ type: "p2tr-script-path";
2792
+ tapLeafScript: {
2793
+ script: string;
2794
+ controlBlock: string;
2795
+ }[];
2796
+ } | undefined;
2797
+ stacksMultisig?: {
2798
+ hashMode: "P2SHNonSequential";
2799
+ threshold: number;
2800
+ publicKeys: string[];
2801
+ } | undefined;
2802
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
2298
2803
  readonly networks: v.ObjectSchema<{
2299
2804
  readonly active: v.ObjectSchema<{
2300
2805
  readonly bitcoin: v.ObjectSchema<{
@@ -4241,6 +4746,11 @@ declare const sparkGetAddressesResultSchema: v.ObjectSchema<{
4241
4746
  controlBlock: string;
4242
4747
  }[], 1, undefined>]>;
4243
4748
  }, undefined>], undefined>, undefined>;
4749
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
4750
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
4751
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
4752
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
4753
+ }, undefined>, undefined>;
4244
4754
  }, undefined>, v.CheckAction<{
4245
4755
  address: string;
4246
4756
  publicKey: string;
@@ -4266,6 +4776,11 @@ declare const sparkGetAddressesResultSchema: v.ObjectSchema<{
4266
4776
  controlBlock: string;
4267
4777
  }[];
4268
4778
  } | undefined;
4779
+ stacksMultisig?: {
4780
+ hashMode: "P2SHNonSequential";
4781
+ threshold: number;
4782
+ publicKeys: string[];
4783
+ } | undefined;
4269
4784
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
4270
4785
  address: string;
4271
4786
  publicKey: string;
@@ -4291,7 +4806,42 @@ declare const sparkGetAddressesResultSchema: v.ObjectSchema<{
4291
4806
  controlBlock: string;
4292
4807
  }[];
4293
4808
  } | undefined;
4294
- }, "unlockDefinition type does not match addressType">]>, undefined>;
4809
+ stacksMultisig?: {
4810
+ hashMode: "P2SHNonSequential";
4811
+ threshold: number;
4812
+ publicKeys: string[];
4813
+ } | undefined;
4814
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
4815
+ address: string;
4816
+ publicKey: string;
4817
+ purpose: AddressPurpose;
4818
+ addressType: AddressType;
4819
+ walletType: "software" | "ledger" | "keystone" | "multisig";
4820
+ scriptPubKey?: string | undefined;
4821
+ unlockDefinition?: {
4822
+ type: "p2wpkh";
4823
+ } | {
4824
+ type: "p2sh-p2wpkh";
4825
+ redeemScript: string;
4826
+ } | {
4827
+ type: "p2tr-key-path";
4828
+ tapInternalKey: string;
4829
+ } | {
4830
+ type: "p2wsh";
4831
+ witnessScript: string;
4832
+ } | {
4833
+ type: "p2tr-script-path";
4834
+ tapLeafScript: {
4835
+ script: string;
4836
+ controlBlock: string;
4837
+ }[];
4838
+ } | undefined;
4839
+ stacksMultisig?: {
4840
+ hashMode: "P2SHNonSequential";
4841
+ threshold: number;
4842
+ publicKeys: string[];
4843
+ } | undefined;
4844
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
4295
4845
  readonly network: v.ObjectSchema<{
4296
4846
  readonly bitcoin: v.ObjectSchema<{
4297
4847
  readonly name: v.EnumSchema<typeof BitcoinNetworkType, undefined>;
@@ -4342,6 +4892,11 @@ declare const sparkGetAddressesSuccessResponseSchema: v.ObjectSchema<{
4342
4892
  controlBlock: string;
4343
4893
  }[], 1, undefined>]>;
4344
4894
  }, undefined>], undefined>, undefined>;
4895
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
4896
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
4897
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
4898
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
4899
+ }, undefined>, undefined>;
4345
4900
  }, undefined>, v.CheckAction<{
4346
4901
  address: string;
4347
4902
  publicKey: string;
@@ -4367,6 +4922,11 @@ declare const sparkGetAddressesSuccessResponseSchema: v.ObjectSchema<{
4367
4922
  controlBlock: string;
4368
4923
  }[];
4369
4924
  } | undefined;
4925
+ stacksMultisig?: {
4926
+ hashMode: "P2SHNonSequential";
4927
+ threshold: number;
4928
+ publicKeys: string[];
4929
+ } | undefined;
4370
4930
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
4371
4931
  address: string;
4372
4932
  publicKey: string;
@@ -4392,7 +4952,42 @@ declare const sparkGetAddressesSuccessResponseSchema: v.ObjectSchema<{
4392
4952
  controlBlock: string;
4393
4953
  }[];
4394
4954
  } | undefined;
4395
- }, "unlockDefinition type does not match addressType">]>, undefined>;
4955
+ stacksMultisig?: {
4956
+ hashMode: "P2SHNonSequential";
4957
+ threshold: number;
4958
+ publicKeys: string[];
4959
+ } | undefined;
4960
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
4961
+ address: string;
4962
+ publicKey: string;
4963
+ purpose: AddressPurpose;
4964
+ addressType: AddressType;
4965
+ walletType: "software" | "ledger" | "keystone" | "multisig";
4966
+ scriptPubKey?: string | undefined;
4967
+ unlockDefinition?: {
4968
+ type: "p2wpkh";
4969
+ } | {
4970
+ type: "p2sh-p2wpkh";
4971
+ redeemScript: string;
4972
+ } | {
4973
+ type: "p2tr-key-path";
4974
+ tapInternalKey: string;
4975
+ } | {
4976
+ type: "p2wsh";
4977
+ witnessScript: string;
4978
+ } | {
4979
+ type: "p2tr-script-path";
4980
+ tapLeafScript: {
4981
+ script: string;
4982
+ controlBlock: string;
4983
+ }[];
4984
+ } | undefined;
4985
+ stacksMultisig?: {
4986
+ hashMode: "P2SHNonSequential";
4987
+ threshold: number;
4988
+ publicKeys: string[];
4989
+ } | undefined;
4990
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
4396
4991
  readonly network: v.ObjectSchema<{
4397
4992
  readonly bitcoin: v.ObjectSchema<{
4398
4993
  readonly name: v.EnumSchema<typeof BitcoinNetworkType, undefined>;
@@ -4474,6 +5069,11 @@ declare const sparkGetAddressesV2ResultSchema: v.ObjectSchema<{
4474
5069
  controlBlock: string;
4475
5070
  }[], 1, undefined>]>;
4476
5071
  }, undefined>], undefined>, undefined>;
5072
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
5073
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
5074
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
5075
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
5076
+ }, undefined>, undefined>;
4477
5077
  }, undefined>, v.CheckAction<{
4478
5078
  address: string;
4479
5079
  publicKey: string;
@@ -4499,6 +5099,11 @@ declare const sparkGetAddressesV2ResultSchema: v.ObjectSchema<{
4499
5099
  controlBlock: string;
4500
5100
  }[];
4501
5101
  } | undefined;
5102
+ stacksMultisig?: {
5103
+ hashMode: "P2SHNonSequential";
5104
+ threshold: number;
5105
+ publicKeys: string[];
5106
+ } | undefined;
4502
5107
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
4503
5108
  address: string;
4504
5109
  publicKey: string;
@@ -4524,7 +5129,42 @@ declare const sparkGetAddressesV2ResultSchema: v.ObjectSchema<{
4524
5129
  controlBlock: string;
4525
5130
  }[];
4526
5131
  } | undefined;
4527
- }, "unlockDefinition type does not match addressType">]>, undefined>;
5132
+ stacksMultisig?: {
5133
+ hashMode: "P2SHNonSequential";
5134
+ threshold: number;
5135
+ publicKeys: string[];
5136
+ } | undefined;
5137
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
5138
+ address: string;
5139
+ publicKey: string;
5140
+ purpose: AddressPurpose;
5141
+ addressType: AddressType;
5142
+ walletType: "software" | "ledger" | "keystone" | "multisig";
5143
+ scriptPubKey?: string | undefined;
5144
+ unlockDefinition?: {
5145
+ type: "p2wpkh";
5146
+ } | {
5147
+ type: "p2sh-p2wpkh";
5148
+ redeemScript: string;
5149
+ } | {
5150
+ type: "p2tr-key-path";
5151
+ tapInternalKey: string;
5152
+ } | {
5153
+ type: "p2wsh";
5154
+ witnessScript: string;
5155
+ } | {
5156
+ type: "p2tr-script-path";
5157
+ tapLeafScript: {
5158
+ script: string;
5159
+ controlBlock: string;
5160
+ }[];
5161
+ } | undefined;
5162
+ stacksMultisig?: {
5163
+ hashMode: "P2SHNonSequential";
5164
+ threshold: number;
5165
+ publicKeys: string[];
5166
+ } | undefined;
5167
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
4528
5168
  readonly network: v.ObjectSchema<{
4529
5169
  readonly chain: v.LiteralSchema<"spark", undefined>;
4530
5170
  readonly mode: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EnumSchema<{
@@ -4579,6 +5219,11 @@ declare const sparkGetAddressesV2SuccessResponseSchema: v.ObjectSchema<{
4579
5219
  controlBlock: string;
4580
5220
  }[], 1, undefined>]>;
4581
5221
  }, undefined>], undefined>, undefined>;
5222
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
5223
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
5224
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
5225
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
5226
+ }, undefined>, undefined>;
4582
5227
  }, undefined>, v.CheckAction<{
4583
5228
  address: string;
4584
5229
  publicKey: string;
@@ -4604,6 +5249,11 @@ declare const sparkGetAddressesV2SuccessResponseSchema: v.ObjectSchema<{
4604
5249
  controlBlock: string;
4605
5250
  }[];
4606
5251
  } | undefined;
5252
+ stacksMultisig?: {
5253
+ hashMode: "P2SHNonSequential";
5254
+ threshold: number;
5255
+ publicKeys: string[];
5256
+ } | undefined;
4607
5257
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
4608
5258
  address: string;
4609
5259
  publicKey: string;
@@ -4629,7 +5279,42 @@ declare const sparkGetAddressesV2SuccessResponseSchema: v.ObjectSchema<{
4629
5279
  controlBlock: string;
4630
5280
  }[];
4631
5281
  } | undefined;
4632
- }, "unlockDefinition type does not match addressType">]>, undefined>;
5282
+ stacksMultisig?: {
5283
+ hashMode: "P2SHNonSequential";
5284
+ threshold: number;
5285
+ publicKeys: string[];
5286
+ } | undefined;
5287
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
5288
+ address: string;
5289
+ publicKey: string;
5290
+ purpose: AddressPurpose;
5291
+ addressType: AddressType;
5292
+ walletType: "software" | "ledger" | "keystone" | "multisig";
5293
+ scriptPubKey?: string | undefined;
5294
+ unlockDefinition?: {
5295
+ type: "p2wpkh";
5296
+ } | {
5297
+ type: "p2sh-p2wpkh";
5298
+ redeemScript: string;
5299
+ } | {
5300
+ type: "p2tr-key-path";
5301
+ tapInternalKey: string;
5302
+ } | {
5303
+ type: "p2wsh";
5304
+ witnessScript: string;
5305
+ } | {
5306
+ type: "p2tr-script-path";
5307
+ tapLeafScript: {
5308
+ script: string;
5309
+ controlBlock: string;
5310
+ }[];
5311
+ } | undefined;
5312
+ stacksMultisig?: {
5313
+ hashMode: "P2SHNonSequential";
5314
+ threshold: number;
5315
+ publicKeys: string[];
5316
+ } | undefined;
5317
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
4633
5318
  readonly network: v.ObjectSchema<{
4634
5319
  readonly chain: v.LiteralSchema<"spark", undefined>;
4635
5320
  readonly mode: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EnumSchema<{
@@ -5159,6 +5844,11 @@ declare const sparkSuccessResponseSchema: v.VariantSchema<"~sats-connect-method"
5159
5844
  controlBlock: string;
5160
5845
  }[], 1, undefined>]>;
5161
5846
  }, undefined>], undefined>, undefined>;
5847
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
5848
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
5849
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
5850
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
5851
+ }, undefined>, undefined>;
5162
5852
  }, undefined>, v.CheckAction<{
5163
5853
  address: string;
5164
5854
  publicKey: string;
@@ -5184,6 +5874,11 @@ declare const sparkSuccessResponseSchema: v.VariantSchema<"~sats-connect-method"
5184
5874
  controlBlock: string;
5185
5875
  }[];
5186
5876
  } | undefined;
5877
+ stacksMultisig?: {
5878
+ hashMode: "P2SHNonSequential";
5879
+ threshold: number;
5880
+ publicKeys: string[];
5881
+ } | undefined;
5187
5882
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
5188
5883
  address: string;
5189
5884
  publicKey: string;
@@ -5209,7 +5904,42 @@ declare const sparkSuccessResponseSchema: v.VariantSchema<"~sats-connect-method"
5209
5904
  controlBlock: string;
5210
5905
  }[];
5211
5906
  } | undefined;
5212
- }, "unlockDefinition type does not match addressType">]>, undefined>;
5907
+ stacksMultisig?: {
5908
+ hashMode: "P2SHNonSequential";
5909
+ threshold: number;
5910
+ publicKeys: string[];
5911
+ } | undefined;
5912
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
5913
+ address: string;
5914
+ publicKey: string;
5915
+ purpose: AddressPurpose;
5916
+ addressType: AddressType;
5917
+ walletType: "software" | "ledger" | "keystone" | "multisig";
5918
+ scriptPubKey?: string | undefined;
5919
+ unlockDefinition?: {
5920
+ type: "p2wpkh";
5921
+ } | {
5922
+ type: "p2sh-p2wpkh";
5923
+ redeemScript: string;
5924
+ } | {
5925
+ type: "p2tr-key-path";
5926
+ tapInternalKey: string;
5927
+ } | {
5928
+ type: "p2wsh";
5929
+ witnessScript: string;
5930
+ } | {
5931
+ type: "p2tr-script-path";
5932
+ tapLeafScript: {
5933
+ script: string;
5934
+ controlBlock: string;
5935
+ }[];
5936
+ } | undefined;
5937
+ stacksMultisig?: {
5938
+ hashMode: "P2SHNonSequential";
5939
+ threshold: number;
5940
+ publicKeys: string[];
5941
+ } | undefined;
5942
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
5213
5943
  readonly network: v.ObjectSchema<{
5214
5944
  readonly bitcoin: v.ObjectSchema<{
5215
5945
  readonly name: v.EnumSchema<typeof BitcoinNetworkType, undefined>;
@@ -5265,6 +5995,11 @@ declare const sparkSuccessResponseSchema: v.VariantSchema<"~sats-connect-method"
5265
5995
  controlBlock: string;
5266
5996
  }[], 1, undefined>]>;
5267
5997
  }, undefined>], undefined>, undefined>;
5998
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
5999
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
6000
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
6001
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
6002
+ }, undefined>, undefined>;
5268
6003
  }, undefined>, v.CheckAction<{
5269
6004
  address: string;
5270
6005
  publicKey: string;
@@ -5290,6 +6025,11 @@ declare const sparkSuccessResponseSchema: v.VariantSchema<"~sats-connect-method"
5290
6025
  controlBlock: string;
5291
6026
  }[];
5292
6027
  } | undefined;
6028
+ stacksMultisig?: {
6029
+ hashMode: "P2SHNonSequential";
6030
+ threshold: number;
6031
+ publicKeys: string[];
6032
+ } | undefined;
5293
6033
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
5294
6034
  address: string;
5295
6035
  publicKey: string;
@@ -5315,23 +6055,58 @@ declare const sparkSuccessResponseSchema: v.VariantSchema<"~sats-connect-method"
5315
6055
  controlBlock: string;
5316
6056
  }[];
5317
6057
  } | undefined;
5318
- }, "unlockDefinition type does not match addressType">]>, undefined>;
5319
- readonly network: v.ObjectSchema<{
5320
- readonly chain: v.LiteralSchema<"spark", undefined>;
5321
- readonly mode: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EnumSchema<{
5322
- readonly mainnet: "mainnet";
5323
- readonly regtest: "regtest";
5324
- }, undefined>]>;
5325
- readonly electrsApiUrl: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UrlAction<string, undefined>]>;
5326
- readonly id: v.StringSchema<undefined>;
5327
- readonly name: v.StringSchema<undefined>;
5328
- readonly source: v.EnumSchema<{
5329
- readonly builtin: "builtin";
5330
- readonly custom: "custom";
5331
- }, undefined>;
5332
- readonly blockExplorerUrl: v.OptionalSchema<v.UnionSchema<[v.SchemaWithPipe<readonly [v.LiteralSchema<"", undefined>, v.TransformAction<"", undefined>]>, v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UrlAction<string, undefined>]>], undefined>, undefined>;
5333
- }, undefined>;
5334
- }, undefined>;
6058
+ stacksMultisig?: {
6059
+ hashMode: "P2SHNonSequential";
6060
+ threshold: number;
6061
+ publicKeys: string[];
6062
+ } | undefined;
6063
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
6064
+ address: string;
6065
+ publicKey: string;
6066
+ purpose: AddressPurpose;
6067
+ addressType: AddressType;
6068
+ walletType: "software" | "ledger" | "keystone" | "multisig";
6069
+ scriptPubKey?: string | undefined;
6070
+ unlockDefinition?: {
6071
+ type: "p2wpkh";
6072
+ } | {
6073
+ type: "p2sh-p2wpkh";
6074
+ redeemScript: string;
6075
+ } | {
6076
+ type: "p2tr-key-path";
6077
+ tapInternalKey: string;
6078
+ } | {
6079
+ type: "p2wsh";
6080
+ witnessScript: string;
6081
+ } | {
6082
+ type: "p2tr-script-path";
6083
+ tapLeafScript: {
6084
+ script: string;
6085
+ controlBlock: string;
6086
+ }[];
6087
+ } | undefined;
6088
+ stacksMultisig?: {
6089
+ hashMode: "P2SHNonSequential";
6090
+ threshold: number;
6091
+ publicKeys: string[];
6092
+ } | undefined;
6093
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
6094
+ readonly network: v.ObjectSchema<{
6095
+ readonly chain: v.LiteralSchema<"spark", undefined>;
6096
+ readonly mode: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EnumSchema<{
6097
+ readonly mainnet: "mainnet";
6098
+ readonly regtest: "regtest";
6099
+ }, undefined>]>;
6100
+ readonly electrsApiUrl: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UrlAction<string, undefined>]>;
6101
+ readonly id: v.StringSchema<undefined>;
6102
+ readonly name: v.StringSchema<undefined>;
6103
+ readonly source: v.EnumSchema<{
6104
+ readonly builtin: "builtin";
6105
+ readonly custom: "custom";
6106
+ }, undefined>;
6107
+ readonly blockExplorerUrl: v.OptionalSchema<v.UnionSchema<[v.SchemaWithPipe<readonly [v.LiteralSchema<"", undefined>, v.TransformAction<"", undefined>]>, v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UrlAction<string, undefined>]>], undefined>, undefined>;
6108
+ }, undefined>;
6109
+ }, undefined>;
5335
6110
  readonly '~sats-connect-method': v.LiteralSchema<"spark_getAddressesV2", undefined>;
5336
6111
  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
5337
6112
  readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
@@ -5759,16 +6534,59 @@ declare const stacksGetAccountsRequestSchema: v.ObjectSchema<{
5759
6534
  type StacksGetAccountsRequest = v.InferOutput<typeof stacksGetAccountsRequestSchema>;
5760
6535
  //#endregion
5761
6536
  //#region src/request/rpc/objects/namespaces/stacks/methods/getAccounts/response.d.ts
6537
+ declare const stacksLegacyAccountSchema: v.ObjectSchema<{
6538
+ readonly address: v.StringSchema<undefined>;
6539
+ readonly publicKey: v.StringSchema<undefined>;
6540
+ readonly gaiaHubUrl: v.StringSchema<undefined>;
6541
+ readonly gaiaAppKey: v.StringSchema<undefined>;
6542
+ readonly walletType: v.OptionalSchema<v.PicklistSchema<("software" | "ledger" | "keystone")[], undefined>, undefined>;
6543
+ }, undefined>;
6544
+ type StacksLegacyAccount = v.InferOutput<typeof stacksLegacyAccountSchema>;
6545
+ declare const stacksMultisigAccountSchema: v.StrictObjectSchema<{
6546
+ readonly address: v.StringSchema<undefined>;
6547
+ readonly walletType: v.LiteralSchema<"multisig", undefined>;
6548
+ readonly multisig: v.ObjectSchema<{
6549
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
6550
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
6551
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
6552
+ }, undefined>;
6553
+ }, undefined>;
6554
+ type StacksMultisigAccount = v.InferOutput<typeof stacksMultisigAccountSchema>;
6555
+ declare const stacksAccountSchema: v.UnionSchema<[v.ObjectSchema<{
6556
+ readonly address: v.StringSchema<undefined>;
6557
+ readonly publicKey: v.StringSchema<undefined>;
6558
+ readonly gaiaHubUrl: v.StringSchema<undefined>;
6559
+ readonly gaiaAppKey: v.StringSchema<undefined>;
6560
+ readonly walletType: v.OptionalSchema<v.PicklistSchema<("software" | "ledger" | "keystone")[], undefined>, undefined>;
6561
+ }, undefined>, v.StrictObjectSchema<{
6562
+ readonly address: v.StringSchema<undefined>;
6563
+ readonly walletType: v.LiteralSchema<"multisig", undefined>;
6564
+ readonly multisig: v.ObjectSchema<{
6565
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
6566
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
6567
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
6568
+ }, undefined>;
6569
+ }, undefined>], undefined>;
6570
+ type StacksAccount = v.InferOutput<typeof stacksAccountSchema>;
5762
6571
  declare const stacksGetAccountsResultSchema: v.ObjectSchema<{
5763
6572
  /**
5764
6573
  * The addresses generated for the given purposes.
5765
6574
  */
5766
- readonly addresses: v.ArraySchema<v.ObjectSchema<{
6575
+ readonly addresses: v.ArraySchema<v.UnionSchema<[v.ObjectSchema<{
5767
6576
  readonly address: v.StringSchema<undefined>;
5768
6577
  readonly publicKey: v.StringSchema<undefined>;
5769
6578
  readonly gaiaHubUrl: v.StringSchema<undefined>;
5770
6579
  readonly gaiaAppKey: v.StringSchema<undefined>;
5771
- }, undefined>, undefined>;
6580
+ readonly walletType: v.OptionalSchema<v.PicklistSchema<("software" | "ledger" | "keystone")[], undefined>, undefined>;
6581
+ }, undefined>, v.StrictObjectSchema<{
6582
+ readonly address: v.StringSchema<undefined>;
6583
+ readonly walletType: v.LiteralSchema<"multisig", undefined>;
6584
+ readonly multisig: v.ObjectSchema<{
6585
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
6586
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
6587
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
6588
+ }, undefined>;
6589
+ }, undefined>], undefined>, undefined>;
5772
6590
  readonly network: v.ObjectSchema<{
5773
6591
  readonly bitcoin: v.ObjectSchema<{
5774
6592
  readonly name: v.EnumSchema<typeof BitcoinNetworkType, undefined>;
@@ -5788,12 +6606,21 @@ declare const stacksGetAccountsSuccessResponseSchema: v.ObjectSchema<{
5788
6606
  /**
5789
6607
  * The addresses generated for the given purposes.
5790
6608
  */
5791
- readonly addresses: v.ArraySchema<v.ObjectSchema<{
6609
+ readonly addresses: v.ArraySchema<v.UnionSchema<[v.ObjectSchema<{
5792
6610
  readonly address: v.StringSchema<undefined>;
5793
6611
  readonly publicKey: v.StringSchema<undefined>;
5794
6612
  readonly gaiaHubUrl: v.StringSchema<undefined>;
5795
6613
  readonly gaiaAppKey: v.StringSchema<undefined>;
5796
- }, undefined>, undefined>;
6614
+ readonly walletType: v.OptionalSchema<v.PicklistSchema<("software" | "ledger" | "keystone")[], undefined>, undefined>;
6615
+ }, undefined>, v.StrictObjectSchema<{
6616
+ readonly address: v.StringSchema<undefined>;
6617
+ readonly walletType: v.LiteralSchema<"multisig", undefined>;
6618
+ readonly multisig: v.ObjectSchema<{
6619
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
6620
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
6621
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
6622
+ }, undefined>;
6623
+ }, undefined>], undefined>, undefined>;
5797
6624
  readonly network: v.ObjectSchema<{
5798
6625
  readonly bitcoin: v.ObjectSchema<{
5799
6626
  readonly name: v.EnumSchema<typeof BitcoinNetworkType, undefined>;
@@ -5875,6 +6702,11 @@ declare const stacksGetAddressesResultSchema: v.ObjectSchema<{
5875
6702
  controlBlock: string;
5876
6703
  }[], 1, undefined>]>;
5877
6704
  }, undefined>], undefined>, undefined>;
6705
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
6706
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
6707
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
6708
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
6709
+ }, undefined>, undefined>;
5878
6710
  }, undefined>, v.CheckAction<{
5879
6711
  address: string;
5880
6712
  publicKey: string;
@@ -5900,6 +6732,11 @@ declare const stacksGetAddressesResultSchema: v.ObjectSchema<{
5900
6732
  controlBlock: string;
5901
6733
  }[];
5902
6734
  } | undefined;
6735
+ stacksMultisig?: {
6736
+ hashMode: "P2SHNonSequential";
6737
+ threshold: number;
6738
+ publicKeys: string[];
6739
+ } | undefined;
5903
6740
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
5904
6741
  address: string;
5905
6742
  publicKey: string;
@@ -5925,7 +6762,42 @@ declare const stacksGetAddressesResultSchema: v.ObjectSchema<{
5925
6762
  controlBlock: string;
5926
6763
  }[];
5927
6764
  } | undefined;
5928
- }, "unlockDefinition type does not match addressType">]>, undefined>;
6765
+ stacksMultisig?: {
6766
+ hashMode: "P2SHNonSequential";
6767
+ threshold: number;
6768
+ publicKeys: string[];
6769
+ } | undefined;
6770
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
6771
+ address: string;
6772
+ publicKey: string;
6773
+ purpose: AddressPurpose;
6774
+ addressType: AddressType;
6775
+ walletType: "software" | "ledger" | "keystone" | "multisig";
6776
+ scriptPubKey?: string | undefined;
6777
+ unlockDefinition?: {
6778
+ type: "p2wpkh";
6779
+ } | {
6780
+ type: "p2sh-p2wpkh";
6781
+ redeemScript: string;
6782
+ } | {
6783
+ type: "p2tr-key-path";
6784
+ tapInternalKey: string;
6785
+ } | {
6786
+ type: "p2wsh";
6787
+ witnessScript: string;
6788
+ } | {
6789
+ type: "p2tr-script-path";
6790
+ tapLeafScript: {
6791
+ script: string;
6792
+ controlBlock: string;
6793
+ }[];
6794
+ } | undefined;
6795
+ stacksMultisig?: {
6796
+ hashMode: "P2SHNonSequential";
6797
+ threshold: number;
6798
+ publicKeys: string[];
6799
+ } | undefined;
6800
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
5929
6801
  readonly network: v.ObjectSchema<{
5930
6802
  readonly bitcoin: v.ObjectSchema<{
5931
6803
  readonly name: v.EnumSchema<typeof BitcoinNetworkType, undefined>;
@@ -5976,6 +6848,11 @@ declare const stacksGetAddressesSuccessResponseSchema: v.ObjectSchema<{
5976
6848
  controlBlock: string;
5977
6849
  }[], 1, undefined>]>;
5978
6850
  }, undefined>], undefined>, undefined>;
6851
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
6852
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
6853
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
6854
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
6855
+ }, undefined>, undefined>;
5979
6856
  }, undefined>, v.CheckAction<{
5980
6857
  address: string;
5981
6858
  publicKey: string;
@@ -6001,6 +6878,11 @@ declare const stacksGetAddressesSuccessResponseSchema: v.ObjectSchema<{
6001
6878
  controlBlock: string;
6002
6879
  }[];
6003
6880
  } | undefined;
6881
+ stacksMultisig?: {
6882
+ hashMode: "P2SHNonSequential";
6883
+ threshold: number;
6884
+ publicKeys: string[];
6885
+ } | undefined;
6004
6886
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
6005
6887
  address: string;
6006
6888
  publicKey: string;
@@ -6026,7 +6908,42 @@ declare const stacksGetAddressesSuccessResponseSchema: v.ObjectSchema<{
6026
6908
  controlBlock: string;
6027
6909
  }[];
6028
6910
  } | undefined;
6029
- }, "unlockDefinition type does not match addressType">]>, undefined>;
6911
+ stacksMultisig?: {
6912
+ hashMode: "P2SHNonSequential";
6913
+ threshold: number;
6914
+ publicKeys: string[];
6915
+ } | undefined;
6916
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
6917
+ address: string;
6918
+ publicKey: string;
6919
+ purpose: AddressPurpose;
6920
+ addressType: AddressType;
6921
+ walletType: "software" | "ledger" | "keystone" | "multisig";
6922
+ scriptPubKey?: string | undefined;
6923
+ unlockDefinition?: {
6924
+ type: "p2wpkh";
6925
+ } | {
6926
+ type: "p2sh-p2wpkh";
6927
+ redeemScript: string;
6928
+ } | {
6929
+ type: "p2tr-key-path";
6930
+ tapInternalKey: string;
6931
+ } | {
6932
+ type: "p2wsh";
6933
+ witnessScript: string;
6934
+ } | {
6935
+ type: "p2tr-script-path";
6936
+ tapLeafScript: {
6937
+ script: string;
6938
+ controlBlock: string;
6939
+ }[];
6940
+ } | undefined;
6941
+ stacksMultisig?: {
6942
+ hashMode: "P2SHNonSequential";
6943
+ threshold: number;
6944
+ publicKeys: string[];
6945
+ } | undefined;
6946
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
6030
6947
  readonly network: v.ObjectSchema<{
6031
6948
  readonly bitcoin: v.ObjectSchema<{
6032
6949
  readonly name: v.EnumSchema<typeof BitcoinNetworkType, undefined>;
@@ -6248,6 +7165,22 @@ declare const stacksSignTransactionSuccessResponseSchema: v.ObjectSchema<{
6248
7165
  }, undefined>;
6249
7166
  type StacksSignTransactionSuccessResponse = v.InferOutput<typeof stacksSignTransactionSuccessResponseSchema>;
6250
7167
  //#endregion
7168
+ //#region src/request/rpc/objects/namespaces/stacks/methods/signTransactions/errorData.d.ts
7169
+ /**
7170
+ * The `data` of the error response when a wallet stops broadcasting a batch
7171
+ * partway through. Lists every transaction of the request, in request order.
7172
+ */
7173
+ declare const stacksSignTransactionsBroadcastErrorDataSchema: v.ObjectSchema<{
7174
+ readonly transactions: v.ArraySchema<v.ObjectSchema<{
7175
+ readonly index: v.NumberSchema<undefined>;
7176
+ readonly transaction: v.StringSchema<undefined>;
7177
+ readonly status: v.PicklistSchema<["broadcast", "failed", "not_broadcast"], undefined>;
7178
+ readonly txid: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
7179
+ readonly error: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
7180
+ }, undefined>, undefined>;
7181
+ }, undefined>;
7182
+ type StacksSignTransactionsBroadcastErrorData = v.InferOutput<typeof stacksSignTransactionsBroadcastErrorDataSchema>;
7183
+ //#endregion
6251
7184
  //#region src/request/rpc/objects/namespaces/stacks/methods/signTransactions/request.d.ts
6252
7185
  declare const stacksSignTransactionsParamsSchema: v.ObjectSchema<{
6253
7186
  /**
@@ -6286,6 +7219,11 @@ declare const stacksSignTransactionsResultSchema: v.ObjectSchema<{
6286
7219
  * sign request.
6287
7220
  */
6288
7221
  readonly transactions: v.ArraySchema<v.StringSchema<undefined>, undefined>;
7222
+ /**
7223
+ * The txids of the broadcast transactions, in the same order as
7224
+ * `transactions`. Only present when the wallet broadcast the batch.
7225
+ */
7226
+ readonly txids: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
6289
7227
  }, undefined>;
6290
7228
  type StacksSignTransactionsResult = v.InferOutput<typeof stacksSignTransactionsResultSchema>;
6291
7229
  declare const stacksSignTransactionsSuccessResponseSchema: v.ObjectSchema<{
@@ -6296,6 +7234,11 @@ declare const stacksSignTransactionsSuccessResponseSchema: v.ObjectSchema<{
6296
7234
  * sign request.
6297
7235
  */
6298
7236
  readonly transactions: v.ArraySchema<v.StringSchema<undefined>, undefined>;
7237
+ /**
7238
+ * The txids of the broadcast transactions, in the same order as
7239
+ * `transactions`. Only present when the wallet broadcast the batch.
7240
+ */
7241
+ readonly txids: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
6299
7242
  }, undefined>;
6300
7243
  readonly '~sats-connect-method': v.LiteralSchema<"stx_signTransactions", undefined>;
6301
7244
  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
@@ -6592,12 +7535,21 @@ declare const stacksSuccessResponseSchema: v.VariantSchema<"~sats-connect-method
6592
7535
  }, undefined>, v.ObjectSchema<{
6593
7536
  readonly id: v.StringSchema<undefined>;
6594
7537
  readonly result: v.ObjectSchema<{
6595
- readonly addresses: v.ArraySchema<v.ObjectSchema<{
7538
+ readonly addresses: v.ArraySchema<v.UnionSchema<[v.ObjectSchema<{
6596
7539
  readonly address: v.StringSchema<undefined>;
6597
7540
  readonly publicKey: v.StringSchema<undefined>;
6598
7541
  readonly gaiaHubUrl: v.StringSchema<undefined>;
6599
7542
  readonly gaiaAppKey: v.StringSchema<undefined>;
6600
- }, undefined>, undefined>;
7543
+ readonly walletType: v.OptionalSchema<v.PicklistSchema<("software" | "ledger" | "keystone")[], undefined>, undefined>;
7544
+ }, undefined>, v.StrictObjectSchema<{
7545
+ readonly address: v.StringSchema<undefined>;
7546
+ readonly walletType: v.LiteralSchema<"multisig", undefined>;
7547
+ readonly multisig: v.ObjectSchema<{
7548
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
7549
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
7550
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
7551
+ }, undefined>;
7552
+ }, undefined>], undefined>, undefined>;
6601
7553
  readonly network: v.ObjectSchema<{
6602
7554
  readonly bitcoin: v.ObjectSchema<{
6603
7555
  readonly name: v.EnumSchema<typeof BitcoinNetworkType, undefined>;
@@ -6653,6 +7605,11 @@ declare const stacksSuccessResponseSchema: v.VariantSchema<"~sats-connect-method
6653
7605
  controlBlock: string;
6654
7606
  }[], 1, undefined>]>;
6655
7607
  }, undefined>], undefined>, undefined>;
7608
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
7609
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
7610
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
7611
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
7612
+ }, undefined>, undefined>;
6656
7613
  }, undefined>, v.CheckAction<{
6657
7614
  address: string;
6658
7615
  publicKey: string;
@@ -6678,6 +7635,11 @@ declare const stacksSuccessResponseSchema: v.VariantSchema<"~sats-connect-method
6678
7635
  controlBlock: string;
6679
7636
  }[];
6680
7637
  } | undefined;
7638
+ stacksMultisig?: {
7639
+ hashMode: "P2SHNonSequential";
7640
+ threshold: number;
7641
+ publicKeys: string[];
7642
+ } | undefined;
6681
7643
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
6682
7644
  address: string;
6683
7645
  publicKey: string;
@@ -6703,7 +7665,42 @@ declare const stacksSuccessResponseSchema: v.VariantSchema<"~sats-connect-method
6703
7665
  controlBlock: string;
6704
7666
  }[];
6705
7667
  } | undefined;
6706
- }, "unlockDefinition type does not match addressType">]>, undefined>;
7668
+ stacksMultisig?: {
7669
+ hashMode: "P2SHNonSequential";
7670
+ threshold: number;
7671
+ publicKeys: string[];
7672
+ } | undefined;
7673
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
7674
+ address: string;
7675
+ publicKey: string;
7676
+ purpose: AddressPurpose;
7677
+ addressType: AddressType;
7678
+ walletType: "software" | "ledger" | "keystone" | "multisig";
7679
+ scriptPubKey?: string | undefined;
7680
+ unlockDefinition?: {
7681
+ type: "p2wpkh";
7682
+ } | {
7683
+ type: "p2sh-p2wpkh";
7684
+ redeemScript: string;
7685
+ } | {
7686
+ type: "p2tr-key-path";
7687
+ tapInternalKey: string;
7688
+ } | {
7689
+ type: "p2wsh";
7690
+ witnessScript: string;
7691
+ } | {
7692
+ type: "p2tr-script-path";
7693
+ tapLeafScript: {
7694
+ script: string;
7695
+ controlBlock: string;
7696
+ }[];
7697
+ } | undefined;
7698
+ stacksMultisig?: {
7699
+ hashMode: "P2SHNonSequential";
7700
+ threshold: number;
7701
+ publicKeys: string[];
7702
+ } | undefined;
7703
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
6707
7704
  readonly network: v.ObjectSchema<{
6708
7705
  readonly bitcoin: v.ObjectSchema<{
6709
7706
  readonly name: v.EnumSchema<typeof BitcoinNetworkType, undefined>;
@@ -6773,6 +7770,7 @@ declare const stacksSuccessResponseSchema: v.VariantSchema<"~sats-connect-method
6773
7770
  readonly id: v.StringSchema<undefined>;
6774
7771
  readonly result: v.ObjectSchema<{
6775
7772
  readonly transactions: v.ArraySchema<v.StringSchema<undefined>, undefined>;
7773
+ readonly txids: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
6776
7774
  }, undefined>;
6777
7775
  readonly '~sats-connect-method': v.LiteralSchema<"stx_signTransactions", undefined>;
6778
7776
  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
@@ -7862,6 +8860,11 @@ declare const walletConnectResultSchema: v.ObjectSchema<{
7862
8860
  controlBlock: string;
7863
8861
  }[], 1, undefined>]>;
7864
8862
  }, undefined>], undefined>, undefined>;
8863
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
8864
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
8865
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
8866
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
8867
+ }, undefined>, undefined>;
7865
8868
  }, undefined>, v.CheckAction<{
7866
8869
  address: string;
7867
8870
  publicKey: string;
@@ -7887,6 +8890,11 @@ declare const walletConnectResultSchema: v.ObjectSchema<{
7887
8890
  controlBlock: string;
7888
8891
  }[];
7889
8892
  } | undefined;
8893
+ stacksMultisig?: {
8894
+ hashMode: "P2SHNonSequential";
8895
+ threshold: number;
8896
+ publicKeys: string[];
8897
+ } | undefined;
7890
8898
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
7891
8899
  address: string;
7892
8900
  publicKey: string;
@@ -7912,7 +8920,42 @@ declare const walletConnectResultSchema: v.ObjectSchema<{
7912
8920
  controlBlock: string;
7913
8921
  }[];
7914
8922
  } | undefined;
7915
- }, "unlockDefinition type does not match addressType">]>, undefined>;
8923
+ stacksMultisig?: {
8924
+ hashMode: "P2SHNonSequential";
8925
+ threshold: number;
8926
+ publicKeys: string[];
8927
+ } | undefined;
8928
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
8929
+ address: string;
8930
+ publicKey: string;
8931
+ purpose: AddressPurpose;
8932
+ addressType: AddressType;
8933
+ walletType: "software" | "ledger" | "keystone" | "multisig";
8934
+ scriptPubKey?: string | undefined;
8935
+ unlockDefinition?: {
8936
+ type: "p2wpkh";
8937
+ } | {
8938
+ type: "p2sh-p2wpkh";
8939
+ redeemScript: string;
8940
+ } | {
8941
+ type: "p2tr-key-path";
8942
+ tapInternalKey: string;
8943
+ } | {
8944
+ type: "p2wsh";
8945
+ witnessScript: string;
8946
+ } | {
8947
+ type: "p2tr-script-path";
8948
+ tapLeafScript: {
8949
+ script: string;
8950
+ controlBlock: string;
8951
+ }[];
8952
+ } | undefined;
8953
+ stacksMultisig?: {
8954
+ hashMode: "P2SHNonSequential";
8955
+ threshold: number;
8956
+ publicKeys: string[];
8957
+ } | undefined;
8958
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
7916
8959
  readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone", "multisig"], undefined>;
7917
8960
  readonly network: v.ObjectSchema<{
7918
8961
  readonly bitcoin: v.ObjectSchema<{
@@ -7962,6 +9005,11 @@ declare const walletConnectSuccessResponseSchema: v.ObjectSchema<{
7962
9005
  controlBlock: string;
7963
9006
  }[], 1, undefined>]>;
7964
9007
  }, undefined>], undefined>, undefined>;
9008
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
9009
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
9010
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
9011
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
9012
+ }, undefined>, undefined>;
7965
9013
  }, undefined>, v.CheckAction<{
7966
9014
  address: string;
7967
9015
  publicKey: string;
@@ -7987,6 +9035,11 @@ declare const walletConnectSuccessResponseSchema: v.ObjectSchema<{
7987
9035
  controlBlock: string;
7988
9036
  }[];
7989
9037
  } | undefined;
9038
+ stacksMultisig?: {
9039
+ hashMode: "P2SHNonSequential";
9040
+ threshold: number;
9041
+ publicKeys: string[];
9042
+ } | undefined;
7990
9043
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
7991
9044
  address: string;
7992
9045
  publicKey: string;
@@ -8012,7 +9065,42 @@ declare const walletConnectSuccessResponseSchema: v.ObjectSchema<{
8012
9065
  controlBlock: string;
8013
9066
  }[];
8014
9067
  } | undefined;
8015
- }, "unlockDefinition type does not match addressType">]>, undefined>;
9068
+ stacksMultisig?: {
9069
+ hashMode: "P2SHNonSequential";
9070
+ threshold: number;
9071
+ publicKeys: string[];
9072
+ } | undefined;
9073
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
9074
+ address: string;
9075
+ publicKey: string;
9076
+ purpose: AddressPurpose;
9077
+ addressType: AddressType;
9078
+ walletType: "software" | "ledger" | "keystone" | "multisig";
9079
+ scriptPubKey?: string | undefined;
9080
+ unlockDefinition?: {
9081
+ type: "p2wpkh";
9082
+ } | {
9083
+ type: "p2sh-p2wpkh";
9084
+ redeemScript: string;
9085
+ } | {
9086
+ type: "p2tr-key-path";
9087
+ tapInternalKey: string;
9088
+ } | {
9089
+ type: "p2wsh";
9090
+ witnessScript: string;
9091
+ } | {
9092
+ type: "p2tr-script-path";
9093
+ tapLeafScript: {
9094
+ script: string;
9095
+ controlBlock: string;
9096
+ }[];
9097
+ } | undefined;
9098
+ stacksMultisig?: {
9099
+ hashMode: "P2SHNonSequential";
9100
+ threshold: number;
9101
+ publicKeys: string[];
9102
+ } | undefined;
9103
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
8016
9104
  readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone", "multisig"], undefined>;
8017
9105
  readonly network: v.ObjectSchema<{
8018
9106
  readonly bitcoin: v.ObjectSchema<{
@@ -8117,6 +9205,11 @@ declare const walletConnectV2ResultSchema: v.ObjectSchema<{
8117
9205
  controlBlock: string;
8118
9206
  }[], 1, undefined>]>;
8119
9207
  }, undefined>], undefined>, undefined>;
9208
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
9209
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
9210
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
9211
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
9212
+ }, undefined>, undefined>;
8120
9213
  }, undefined>, v.CheckAction<{
8121
9214
  address: string;
8122
9215
  publicKey: string;
@@ -8142,6 +9235,11 @@ declare const walletConnectV2ResultSchema: v.ObjectSchema<{
8142
9235
  controlBlock: string;
8143
9236
  }[];
8144
9237
  } | undefined;
9238
+ stacksMultisig?: {
9239
+ hashMode: "P2SHNonSequential";
9240
+ threshold: number;
9241
+ publicKeys: string[];
9242
+ } | undefined;
8145
9243
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
8146
9244
  address: string;
8147
9245
  publicKey: string;
@@ -8167,7 +9265,42 @@ declare const walletConnectV2ResultSchema: v.ObjectSchema<{
8167
9265
  controlBlock: string;
8168
9266
  }[];
8169
9267
  } | undefined;
8170
- }, "unlockDefinition type does not match addressType">]>, undefined>;
9268
+ stacksMultisig?: {
9269
+ hashMode: "P2SHNonSequential";
9270
+ threshold: number;
9271
+ publicKeys: string[];
9272
+ } | undefined;
9273
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
9274
+ address: string;
9275
+ publicKey: string;
9276
+ purpose: AddressPurpose;
9277
+ addressType: AddressType;
9278
+ walletType: "software" | "ledger" | "keystone" | "multisig";
9279
+ scriptPubKey?: string | undefined;
9280
+ unlockDefinition?: {
9281
+ type: "p2wpkh";
9282
+ } | {
9283
+ type: "p2sh-p2wpkh";
9284
+ redeemScript: string;
9285
+ } | {
9286
+ type: "p2tr-key-path";
9287
+ tapInternalKey: string;
9288
+ } | {
9289
+ type: "p2wsh";
9290
+ witnessScript: string;
9291
+ } | {
9292
+ type: "p2tr-script-path";
9293
+ tapLeafScript: {
9294
+ script: string;
9295
+ controlBlock: string;
9296
+ }[];
9297
+ } | undefined;
9298
+ stacksMultisig?: {
9299
+ hashMode: "P2SHNonSequential";
9300
+ threshold: number;
9301
+ publicKeys: string[];
9302
+ } | undefined;
9303
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
8171
9304
  readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone", "multisig"], undefined>;
8172
9305
  readonly networks: v.ObjectSchema<{
8173
9306
  readonly active: v.ObjectSchema<{
@@ -8343,6 +9476,11 @@ declare const walletConnectV2SuccessResponseSchema: v.ObjectSchema<{
8343
9476
  controlBlock: string;
8344
9477
  }[], 1, undefined>]>;
8345
9478
  }, undefined>], undefined>, undefined>;
9479
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
9480
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
9481
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
9482
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
9483
+ }, undefined>, undefined>;
8346
9484
  }, undefined>, v.CheckAction<{
8347
9485
  address: string;
8348
9486
  publicKey: string;
@@ -8368,6 +9506,11 @@ declare const walletConnectV2SuccessResponseSchema: v.ObjectSchema<{
8368
9506
  controlBlock: string;
8369
9507
  }[];
8370
9508
  } | undefined;
9509
+ stacksMultisig?: {
9510
+ hashMode: "P2SHNonSequential";
9511
+ threshold: number;
9512
+ publicKeys: string[];
9513
+ } | undefined;
8371
9514
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
8372
9515
  address: string;
8373
9516
  publicKey: string;
@@ -8393,16 +9536,51 @@ declare const walletConnectV2SuccessResponseSchema: v.ObjectSchema<{
8393
9536
  controlBlock: string;
8394
9537
  }[];
8395
9538
  } | undefined;
8396
- }, "unlockDefinition type does not match addressType">]>, undefined>;
8397
- readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone", "multisig"], undefined>;
8398
- readonly networks: v.ObjectSchema<{
8399
- readonly active: v.ObjectSchema<{
8400
- readonly bitcoin: v.ObjectSchema<{
8401
- readonly chain: v.LiteralSchema<"bitcoin", undefined>;
8402
- readonly mode: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EnumSchema<{
8403
- readonly mainnet: "mainnet";
8404
- readonly testnet: "testnet";
8405
- readonly testnet4: "testnet4";
9539
+ stacksMultisig?: {
9540
+ hashMode: "P2SHNonSequential";
9541
+ threshold: number;
9542
+ publicKeys: string[];
9543
+ } | undefined;
9544
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
9545
+ address: string;
9546
+ publicKey: string;
9547
+ purpose: AddressPurpose;
9548
+ addressType: AddressType;
9549
+ walletType: "software" | "ledger" | "keystone" | "multisig";
9550
+ scriptPubKey?: string | undefined;
9551
+ unlockDefinition?: {
9552
+ type: "p2wpkh";
9553
+ } | {
9554
+ type: "p2sh-p2wpkh";
9555
+ redeemScript: string;
9556
+ } | {
9557
+ type: "p2tr-key-path";
9558
+ tapInternalKey: string;
9559
+ } | {
9560
+ type: "p2wsh";
9561
+ witnessScript: string;
9562
+ } | {
9563
+ type: "p2tr-script-path";
9564
+ tapLeafScript: {
9565
+ script: string;
9566
+ controlBlock: string;
9567
+ }[];
9568
+ } | undefined;
9569
+ stacksMultisig?: {
9570
+ hashMode: "P2SHNonSequential";
9571
+ threshold: number;
9572
+ publicKeys: string[];
9573
+ } | undefined;
9574
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
9575
+ readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone", "multisig"], undefined>;
9576
+ readonly networks: v.ObjectSchema<{
9577
+ readonly active: v.ObjectSchema<{
9578
+ readonly bitcoin: v.ObjectSchema<{
9579
+ readonly chain: v.LiteralSchema<"bitcoin", undefined>;
9580
+ readonly mode: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EnumSchema<{
9581
+ readonly mainnet: "mainnet";
9582
+ readonly testnet: "testnet";
9583
+ readonly testnet4: "testnet4";
8406
9584
  readonly signet: "signet";
8407
9585
  readonly regtest: "regtest";
8408
9586
  }, undefined>]>;
@@ -8619,6 +9797,11 @@ declare const walletGetAccountResultSchema: v.ObjectSchema<{
8619
9797
  controlBlock: string;
8620
9798
  }[], 1, undefined>]>;
8621
9799
  }, undefined>], undefined>, undefined>;
9800
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
9801
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
9802
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
9803
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
9804
+ }, undefined>, undefined>;
8622
9805
  }, undefined>, v.CheckAction<{
8623
9806
  address: string;
8624
9807
  publicKey: string;
@@ -8644,6 +9827,11 @@ declare const walletGetAccountResultSchema: v.ObjectSchema<{
8644
9827
  controlBlock: string;
8645
9828
  }[];
8646
9829
  } | undefined;
9830
+ stacksMultisig?: {
9831
+ hashMode: "P2SHNonSequential";
9832
+ threshold: number;
9833
+ publicKeys: string[];
9834
+ } | undefined;
8647
9835
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
8648
9836
  address: string;
8649
9837
  publicKey: string;
@@ -8669,7 +9857,42 @@ declare const walletGetAccountResultSchema: v.ObjectSchema<{
8669
9857
  controlBlock: string;
8670
9858
  }[];
8671
9859
  } | undefined;
8672
- }, "unlockDefinition type does not match addressType">]>, undefined>;
9860
+ stacksMultisig?: {
9861
+ hashMode: "P2SHNonSequential";
9862
+ threshold: number;
9863
+ publicKeys: string[];
9864
+ } | undefined;
9865
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
9866
+ address: string;
9867
+ publicKey: string;
9868
+ purpose: AddressPurpose;
9869
+ addressType: AddressType;
9870
+ walletType: "software" | "ledger" | "keystone" | "multisig";
9871
+ scriptPubKey?: string | undefined;
9872
+ unlockDefinition?: {
9873
+ type: "p2wpkh";
9874
+ } | {
9875
+ type: "p2sh-p2wpkh";
9876
+ redeemScript: string;
9877
+ } | {
9878
+ type: "p2tr-key-path";
9879
+ tapInternalKey: string;
9880
+ } | {
9881
+ type: "p2wsh";
9882
+ witnessScript: string;
9883
+ } | {
9884
+ type: "p2tr-script-path";
9885
+ tapLeafScript: {
9886
+ script: string;
9887
+ controlBlock: string;
9888
+ }[];
9889
+ } | undefined;
9890
+ stacksMultisig?: {
9891
+ hashMode: "P2SHNonSequential";
9892
+ threshold: number;
9893
+ publicKeys: string[];
9894
+ } | undefined;
9895
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
8673
9896
  readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone", "multisig"], undefined>;
8674
9897
  readonly network: v.ObjectSchema<{
8675
9898
  readonly bitcoin: v.ObjectSchema<{
@@ -8719,6 +9942,11 @@ declare const walletGetAccountSuccessResponseSchema: v.ObjectSchema<{
8719
9942
  controlBlock: string;
8720
9943
  }[], 1, undefined>]>;
8721
9944
  }, undefined>], undefined>, undefined>;
9945
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
9946
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
9947
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
9948
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
9949
+ }, undefined>, undefined>;
8722
9950
  }, undefined>, v.CheckAction<{
8723
9951
  address: string;
8724
9952
  publicKey: string;
@@ -8744,6 +9972,11 @@ declare const walletGetAccountSuccessResponseSchema: v.ObjectSchema<{
8744
9972
  controlBlock: string;
8745
9973
  }[];
8746
9974
  } | undefined;
9975
+ stacksMultisig?: {
9976
+ hashMode: "P2SHNonSequential";
9977
+ threshold: number;
9978
+ publicKeys: string[];
9979
+ } | undefined;
8747
9980
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
8748
9981
  address: string;
8749
9982
  publicKey: string;
@@ -8769,7 +10002,42 @@ declare const walletGetAccountSuccessResponseSchema: v.ObjectSchema<{
8769
10002
  controlBlock: string;
8770
10003
  }[];
8771
10004
  } | undefined;
8772
- }, "unlockDefinition type does not match addressType">]>, undefined>;
10005
+ stacksMultisig?: {
10006
+ hashMode: "P2SHNonSequential";
10007
+ threshold: number;
10008
+ publicKeys: string[];
10009
+ } | undefined;
10010
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
10011
+ address: string;
10012
+ publicKey: string;
10013
+ purpose: AddressPurpose;
10014
+ addressType: AddressType;
10015
+ walletType: "software" | "ledger" | "keystone" | "multisig";
10016
+ scriptPubKey?: string | undefined;
10017
+ unlockDefinition?: {
10018
+ type: "p2wpkh";
10019
+ } | {
10020
+ type: "p2sh-p2wpkh";
10021
+ redeemScript: string;
10022
+ } | {
10023
+ type: "p2tr-key-path";
10024
+ tapInternalKey: string;
10025
+ } | {
10026
+ type: "p2wsh";
10027
+ witnessScript: string;
10028
+ } | {
10029
+ type: "p2tr-script-path";
10030
+ tapLeafScript: {
10031
+ script: string;
10032
+ controlBlock: string;
10033
+ }[];
10034
+ } | undefined;
10035
+ stacksMultisig?: {
10036
+ hashMode: "P2SHNonSequential";
10037
+ threshold: number;
10038
+ publicKeys: string[];
10039
+ } | undefined;
10040
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
8773
10041
  readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone", "multisig"], undefined>;
8774
10042
  readonly network: v.ObjectSchema<{
8775
10043
  readonly bitcoin: v.ObjectSchema<{
@@ -8840,6 +10108,11 @@ declare const walletGetAccountV2ResultSchema: v.ObjectSchema<{
8840
10108
  controlBlock: string;
8841
10109
  }[], 1, undefined>]>;
8842
10110
  }, undefined>], undefined>, undefined>;
10111
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
10112
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
10113
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
10114
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
10115
+ }, undefined>, undefined>;
8843
10116
  }, undefined>, v.CheckAction<{
8844
10117
  address: string;
8845
10118
  publicKey: string;
@@ -8865,6 +10138,11 @@ declare const walletGetAccountV2ResultSchema: v.ObjectSchema<{
8865
10138
  controlBlock: string;
8866
10139
  }[];
8867
10140
  } | undefined;
10141
+ stacksMultisig?: {
10142
+ hashMode: "P2SHNonSequential";
10143
+ threshold: number;
10144
+ publicKeys: string[];
10145
+ } | undefined;
8868
10146
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
8869
10147
  address: string;
8870
10148
  publicKey: string;
@@ -8890,7 +10168,42 @@ declare const walletGetAccountV2ResultSchema: v.ObjectSchema<{
8890
10168
  controlBlock: string;
8891
10169
  }[];
8892
10170
  } | undefined;
8893
- }, "unlockDefinition type does not match addressType">]>, undefined>;
10171
+ stacksMultisig?: {
10172
+ hashMode: "P2SHNonSequential";
10173
+ threshold: number;
10174
+ publicKeys: string[];
10175
+ } | undefined;
10176
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
10177
+ address: string;
10178
+ publicKey: string;
10179
+ purpose: AddressPurpose;
10180
+ addressType: AddressType;
10181
+ walletType: "software" | "ledger" | "keystone" | "multisig";
10182
+ scriptPubKey?: string | undefined;
10183
+ unlockDefinition?: {
10184
+ type: "p2wpkh";
10185
+ } | {
10186
+ type: "p2sh-p2wpkh";
10187
+ redeemScript: string;
10188
+ } | {
10189
+ type: "p2tr-key-path";
10190
+ tapInternalKey: string;
10191
+ } | {
10192
+ type: "p2wsh";
10193
+ witnessScript: string;
10194
+ } | {
10195
+ type: "p2tr-script-path";
10196
+ tapLeafScript: {
10197
+ script: string;
10198
+ controlBlock: string;
10199
+ }[];
10200
+ } | undefined;
10201
+ stacksMultisig?: {
10202
+ hashMode: "P2SHNonSequential";
10203
+ threshold: number;
10204
+ publicKeys: string[];
10205
+ } | undefined;
10206
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
8894
10207
  readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone", "multisig"], undefined>;
8895
10208
  readonly networks: v.ObjectSchema<{
8896
10209
  readonly active: v.ObjectSchema<{
@@ -9066,6 +10379,11 @@ declare const walletGetAccountV2SuccessResponseSchema: v.ObjectSchema<{
9066
10379
  controlBlock: string;
9067
10380
  }[], 1, undefined>]>;
9068
10381
  }, undefined>], undefined>, undefined>;
10382
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
10383
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
10384
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
10385
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
10386
+ }, undefined>, undefined>;
9069
10387
  }, undefined>, v.CheckAction<{
9070
10388
  address: string;
9071
10389
  publicKey: string;
@@ -9091,6 +10409,11 @@ declare const walletGetAccountV2SuccessResponseSchema: v.ObjectSchema<{
9091
10409
  controlBlock: string;
9092
10410
  }[];
9093
10411
  } | undefined;
10412
+ stacksMultisig?: {
10413
+ hashMode: "P2SHNonSequential";
10414
+ threshold: number;
10415
+ publicKeys: string[];
10416
+ } | undefined;
9094
10417
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
9095
10418
  address: string;
9096
10419
  publicKey: string;
@@ -9116,7 +10439,42 @@ declare const walletGetAccountV2SuccessResponseSchema: v.ObjectSchema<{
9116
10439
  controlBlock: string;
9117
10440
  }[];
9118
10441
  } | undefined;
9119
- }, "unlockDefinition type does not match addressType">]>, undefined>;
10442
+ stacksMultisig?: {
10443
+ hashMode: "P2SHNonSequential";
10444
+ threshold: number;
10445
+ publicKeys: string[];
10446
+ } | undefined;
10447
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
10448
+ address: string;
10449
+ publicKey: string;
10450
+ purpose: AddressPurpose;
10451
+ addressType: AddressType;
10452
+ walletType: "software" | "ledger" | "keystone" | "multisig";
10453
+ scriptPubKey?: string | undefined;
10454
+ unlockDefinition?: {
10455
+ type: "p2wpkh";
10456
+ } | {
10457
+ type: "p2sh-p2wpkh";
10458
+ redeemScript: string;
10459
+ } | {
10460
+ type: "p2tr-key-path";
10461
+ tapInternalKey: string;
10462
+ } | {
10463
+ type: "p2wsh";
10464
+ witnessScript: string;
10465
+ } | {
10466
+ type: "p2tr-script-path";
10467
+ tapLeafScript: {
10468
+ script: string;
10469
+ controlBlock: string;
10470
+ }[];
10471
+ } | undefined;
10472
+ stacksMultisig?: {
10473
+ hashMode: "P2SHNonSequential";
10474
+ threshold: number;
10475
+ publicKeys: string[];
10476
+ } | undefined;
10477
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
9120
10478
  readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone", "multisig"], undefined>;
9121
10479
  readonly networks: v.ObjectSchema<{
9122
10480
  readonly active: v.ObjectSchema<{
@@ -9852,6 +11210,11 @@ declare const walletOpenReceiveResultSchema: v.SchemaWithPipe<readonly [v.Object
9852
11210
  controlBlock: string;
9853
11211
  }[], 1, undefined>]>;
9854
11212
  }, undefined>], undefined>, undefined>;
11213
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
11214
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
11215
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
11216
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
11217
+ }, undefined>, undefined>;
9855
11218
  }, undefined>, v.CheckAction<{
9856
11219
  address: string;
9857
11220
  publicKey: string;
@@ -9877,6 +11240,11 @@ declare const walletOpenReceiveResultSchema: v.SchemaWithPipe<readonly [v.Object
9877
11240
  controlBlock: string;
9878
11241
  }[];
9879
11242
  } | undefined;
11243
+ stacksMultisig?: {
11244
+ hashMode: "P2SHNonSequential";
11245
+ threshold: number;
11246
+ publicKeys: string[];
11247
+ } | undefined;
9880
11248
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
9881
11249
  address: string;
9882
11250
  publicKey: string;
@@ -9902,7 +11270,42 @@ declare const walletOpenReceiveResultSchema: v.SchemaWithPipe<readonly [v.Object
9902
11270
  controlBlock: string;
9903
11271
  }[];
9904
11272
  } | undefined;
9905
- }, "unlockDefinition type does not match addressType">]>;
11273
+ stacksMultisig?: {
11274
+ hashMode: "P2SHNonSequential";
11275
+ threshold: number;
11276
+ publicKeys: string[];
11277
+ } | undefined;
11278
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
11279
+ address: string;
11280
+ publicKey: string;
11281
+ purpose: AddressPurpose;
11282
+ addressType: AddressType;
11283
+ walletType: "software" | "ledger" | "keystone" | "multisig";
11284
+ scriptPubKey?: string | undefined;
11285
+ unlockDefinition?: {
11286
+ type: "p2wpkh";
11287
+ } | {
11288
+ type: "p2sh-p2wpkh";
11289
+ redeemScript: string;
11290
+ } | {
11291
+ type: "p2tr-key-path";
11292
+ tapInternalKey: string;
11293
+ } | {
11294
+ type: "p2wsh";
11295
+ witnessScript: string;
11296
+ } | {
11297
+ type: "p2tr-script-path";
11298
+ tapLeafScript: {
11299
+ script: string;
11300
+ controlBlock: string;
11301
+ }[];
11302
+ } | undefined;
11303
+ stacksMultisig?: {
11304
+ hashMode: "P2SHNonSequential";
11305
+ threshold: number;
11306
+ publicKeys: string[];
11307
+ } | undefined;
11308
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>;
9906
11309
  type WalletOpenReceiveResult = v.InferOutput<typeof walletOpenReceiveResultSchema>;
9907
11310
  declare const walletOpenReceiveSuccessResponseSchema: v.ObjectSchema<{
9908
11311
  readonly id: v.StringSchema<undefined>;
@@ -9937,6 +11340,11 @@ declare const walletOpenReceiveSuccessResponseSchema: v.ObjectSchema<{
9937
11340
  controlBlock: string;
9938
11341
  }[], 1, undefined>]>;
9939
11342
  }, undefined>], undefined>, undefined>;
11343
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
11344
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
11345
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
11346
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
11347
+ }, undefined>, undefined>;
9940
11348
  }, undefined>, v.CheckAction<{
9941
11349
  address: string;
9942
11350
  publicKey: string;
@@ -9962,6 +11370,11 @@ declare const walletOpenReceiveSuccessResponseSchema: v.ObjectSchema<{
9962
11370
  controlBlock: string;
9963
11371
  }[];
9964
11372
  } | undefined;
11373
+ stacksMultisig?: {
11374
+ hashMode: "P2SHNonSequential";
11375
+ threshold: number;
11376
+ publicKeys: string[];
11377
+ } | undefined;
9965
11378
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
9966
11379
  address: string;
9967
11380
  publicKey: string;
@@ -9987,7 +11400,42 @@ declare const walletOpenReceiveSuccessResponseSchema: v.ObjectSchema<{
9987
11400
  controlBlock: string;
9988
11401
  }[];
9989
11402
  } | undefined;
9990
- }, "unlockDefinition type does not match addressType">]>;
11403
+ stacksMultisig?: {
11404
+ hashMode: "P2SHNonSequential";
11405
+ threshold: number;
11406
+ publicKeys: string[];
11407
+ } | undefined;
11408
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
11409
+ address: string;
11410
+ publicKey: string;
11411
+ purpose: AddressPurpose;
11412
+ addressType: AddressType;
11413
+ walletType: "software" | "ledger" | "keystone" | "multisig";
11414
+ scriptPubKey?: string | undefined;
11415
+ unlockDefinition?: {
11416
+ type: "p2wpkh";
11417
+ } | {
11418
+ type: "p2sh-p2wpkh";
11419
+ redeemScript: string;
11420
+ } | {
11421
+ type: "p2tr-key-path";
11422
+ tapInternalKey: string;
11423
+ } | {
11424
+ type: "p2wsh";
11425
+ witnessScript: string;
11426
+ } | {
11427
+ type: "p2tr-script-path";
11428
+ tapLeafScript: {
11429
+ script: string;
11430
+ controlBlock: string;
11431
+ }[];
11432
+ } | undefined;
11433
+ stacksMultisig?: {
11434
+ hashMode: "P2SHNonSequential";
11435
+ threshold: number;
11436
+ publicKeys: string[];
11437
+ } | undefined;
11438
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>;
9991
11439
  readonly '~sats-connect-method': v.LiteralSchema<"wallet_openReceive", undefined>;
9992
11440
  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
9993
11441
  readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
@@ -12118,6 +13566,11 @@ declare const walletSuccessResponseSchema: v.VariantSchema<"~sats-connect-method
12118
13566
  controlBlock: string;
12119
13567
  }[], 1, undefined>]>;
12120
13568
  }, undefined>], undefined>, undefined>;
13569
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
13570
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
13571
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
13572
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
13573
+ }, undefined>, undefined>;
12121
13574
  }, undefined>, v.CheckAction<{
12122
13575
  address: string;
12123
13576
  publicKey: string;
@@ -12143,6 +13596,11 @@ declare const walletSuccessResponseSchema: v.VariantSchema<"~sats-connect-method
12143
13596
  controlBlock: string;
12144
13597
  }[];
12145
13598
  } | undefined;
13599
+ stacksMultisig?: {
13600
+ hashMode: "P2SHNonSequential";
13601
+ threshold: number;
13602
+ publicKeys: string[];
13603
+ } | undefined;
12146
13604
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
12147
13605
  address: string;
12148
13606
  publicKey: string;
@@ -12168,7 +13626,42 @@ declare const walletSuccessResponseSchema: v.VariantSchema<"~sats-connect-method
12168
13626
  controlBlock: string;
12169
13627
  }[];
12170
13628
  } | undefined;
12171
- }, "unlockDefinition type does not match addressType">]>, undefined>;
13629
+ stacksMultisig?: {
13630
+ hashMode: "P2SHNonSequential";
13631
+ threshold: number;
13632
+ publicKeys: string[];
13633
+ } | undefined;
13634
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
13635
+ address: string;
13636
+ publicKey: string;
13637
+ purpose: AddressPurpose;
13638
+ addressType: AddressType;
13639
+ walletType: "software" | "ledger" | "keystone" | "multisig";
13640
+ scriptPubKey?: string | undefined;
13641
+ unlockDefinition?: {
13642
+ type: "p2wpkh";
13643
+ } | {
13644
+ type: "p2sh-p2wpkh";
13645
+ redeemScript: string;
13646
+ } | {
13647
+ type: "p2tr-key-path";
13648
+ tapInternalKey: string;
13649
+ } | {
13650
+ type: "p2wsh";
13651
+ witnessScript: string;
13652
+ } | {
13653
+ type: "p2tr-script-path";
13654
+ tapLeafScript: {
13655
+ script: string;
13656
+ controlBlock: string;
13657
+ }[];
13658
+ } | undefined;
13659
+ stacksMultisig?: {
13660
+ hashMode: "P2SHNonSequential";
13661
+ threshold: number;
13662
+ publicKeys: string[];
13663
+ } | undefined;
13664
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
12172
13665
  readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone", "multisig"], undefined>;
12173
13666
  readonly network: v.ObjectSchema<{
12174
13667
  readonly bitcoin: v.ObjectSchema<{
@@ -12226,6 +13719,11 @@ declare const walletSuccessResponseSchema: v.VariantSchema<"~sats-connect-method
12226
13719
  controlBlock: string;
12227
13720
  }[], 1, undefined>]>;
12228
13721
  }, undefined>], undefined>, undefined>;
13722
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
13723
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
13724
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
13725
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
13726
+ }, undefined>, undefined>;
12229
13727
  }, undefined>, v.CheckAction<{
12230
13728
  address: string;
12231
13729
  publicKey: string;
@@ -12251,6 +13749,11 @@ declare const walletSuccessResponseSchema: v.VariantSchema<"~sats-connect-method
12251
13749
  controlBlock: string;
12252
13750
  }[];
12253
13751
  } | undefined;
13752
+ stacksMultisig?: {
13753
+ hashMode: "P2SHNonSequential";
13754
+ threshold: number;
13755
+ publicKeys: string[];
13756
+ } | undefined;
12254
13757
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
12255
13758
  address: string;
12256
13759
  publicKey: string;
@@ -12276,30 +13779,65 @@ declare const walletSuccessResponseSchema: v.VariantSchema<"~sats-connect-method
12276
13779
  controlBlock: string;
12277
13780
  }[];
12278
13781
  } | undefined;
12279
- }, "unlockDefinition type does not match addressType">]>, undefined>;
12280
- readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone", "multisig"], undefined>;
12281
- readonly networks: v.ObjectSchema<{
12282
- readonly active: v.ObjectSchema<{
12283
- readonly bitcoin: v.ObjectSchema<{
12284
- readonly chain: v.LiteralSchema<"bitcoin", undefined>;
12285
- readonly mode: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EnumSchema<{
12286
- readonly mainnet: "mainnet";
12287
- readonly testnet: "testnet";
12288
- readonly testnet4: "testnet4";
12289
- readonly signet: "signet";
12290
- readonly regtest: "regtest";
12291
- }, undefined>]>;
12292
- readonly xverseApiUrl: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UrlAction<string, undefined>]>;
12293
- readonly electrsApiUrl: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UrlAction<string, undefined>]>;
12294
- readonly id: v.StringSchema<undefined>;
12295
- readonly name: v.StringSchema<undefined>;
12296
- readonly source: v.EnumSchema<{
12297
- readonly builtin: "builtin";
12298
- readonly custom: "custom";
12299
- }, undefined>;
12300
- readonly blockExplorerUrl: v.OptionalSchema<v.UnionSchema<[v.SchemaWithPipe<readonly [v.LiteralSchema<"", undefined>, v.TransformAction<"", undefined>]>, v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UrlAction<string, undefined>]>], undefined>, undefined>;
12301
- }, undefined>;
12302
- readonly spark: v.ObjectSchema<{
13782
+ stacksMultisig?: {
13783
+ hashMode: "P2SHNonSequential";
13784
+ threshold: number;
13785
+ publicKeys: string[];
13786
+ } | undefined;
13787
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
13788
+ address: string;
13789
+ publicKey: string;
13790
+ purpose: AddressPurpose;
13791
+ addressType: AddressType;
13792
+ walletType: "software" | "ledger" | "keystone" | "multisig";
13793
+ scriptPubKey?: string | undefined;
13794
+ unlockDefinition?: {
13795
+ type: "p2wpkh";
13796
+ } | {
13797
+ type: "p2sh-p2wpkh";
13798
+ redeemScript: string;
13799
+ } | {
13800
+ type: "p2tr-key-path";
13801
+ tapInternalKey: string;
13802
+ } | {
13803
+ type: "p2wsh";
13804
+ witnessScript: string;
13805
+ } | {
13806
+ type: "p2tr-script-path";
13807
+ tapLeafScript: {
13808
+ script: string;
13809
+ controlBlock: string;
13810
+ }[];
13811
+ } | undefined;
13812
+ stacksMultisig?: {
13813
+ hashMode: "P2SHNonSequential";
13814
+ threshold: number;
13815
+ publicKeys: string[];
13816
+ } | undefined;
13817
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
13818
+ readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone", "multisig"], undefined>;
13819
+ readonly networks: v.ObjectSchema<{
13820
+ readonly active: v.ObjectSchema<{
13821
+ readonly bitcoin: v.ObjectSchema<{
13822
+ readonly chain: v.LiteralSchema<"bitcoin", undefined>;
13823
+ readonly mode: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EnumSchema<{
13824
+ readonly mainnet: "mainnet";
13825
+ readonly testnet: "testnet";
13826
+ readonly testnet4: "testnet4";
13827
+ readonly signet: "signet";
13828
+ readonly regtest: "regtest";
13829
+ }, undefined>]>;
13830
+ readonly xverseApiUrl: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UrlAction<string, undefined>]>;
13831
+ readonly electrsApiUrl: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UrlAction<string, undefined>]>;
13832
+ readonly id: v.StringSchema<undefined>;
13833
+ readonly name: v.StringSchema<undefined>;
13834
+ readonly source: v.EnumSchema<{
13835
+ readonly builtin: "builtin";
13836
+ readonly custom: "custom";
13837
+ }, undefined>;
13838
+ readonly blockExplorerUrl: v.OptionalSchema<v.UnionSchema<[v.SchemaWithPipe<readonly [v.LiteralSchema<"", undefined>, v.TransformAction<"", undefined>]>, v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UrlAction<string, undefined>]>], undefined>, undefined>;
13839
+ }, undefined>;
13840
+ readonly spark: v.ObjectSchema<{
12303
13841
  readonly chain: v.LiteralSchema<"spark", undefined>;
12304
13842
  readonly mode: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EnumSchema<{
12305
13843
  readonly mainnet: "mainnet";
@@ -12472,6 +14010,11 @@ declare const walletSuccessResponseSchema: v.VariantSchema<"~sats-connect-method
12472
14010
  controlBlock: string;
12473
14011
  }[], 1, undefined>]>;
12474
14012
  }, undefined>], undefined>, undefined>;
14013
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
14014
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
14015
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
14016
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
14017
+ }, undefined>, undefined>;
12475
14018
  }, undefined>, v.CheckAction<{
12476
14019
  address: string;
12477
14020
  publicKey: string;
@@ -12497,6 +14040,11 @@ declare const walletSuccessResponseSchema: v.VariantSchema<"~sats-connect-method
12497
14040
  controlBlock: string;
12498
14041
  }[];
12499
14042
  } | undefined;
14043
+ stacksMultisig?: {
14044
+ hashMode: "P2SHNonSequential";
14045
+ threshold: number;
14046
+ publicKeys: string[];
14047
+ } | undefined;
12500
14048
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
12501
14049
  address: string;
12502
14050
  publicKey: string;
@@ -12522,7 +14070,42 @@ declare const walletSuccessResponseSchema: v.VariantSchema<"~sats-connect-method
12522
14070
  controlBlock: string;
12523
14071
  }[];
12524
14072
  } | undefined;
12525
- }, "unlockDefinition type does not match addressType">]>, undefined>;
14073
+ stacksMultisig?: {
14074
+ hashMode: "P2SHNonSequential";
14075
+ threshold: number;
14076
+ publicKeys: string[];
14077
+ } | undefined;
14078
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
14079
+ address: string;
14080
+ publicKey: string;
14081
+ purpose: AddressPurpose;
14082
+ addressType: AddressType;
14083
+ walletType: "software" | "ledger" | "keystone" | "multisig";
14084
+ scriptPubKey?: string | undefined;
14085
+ unlockDefinition?: {
14086
+ type: "p2wpkh";
14087
+ } | {
14088
+ type: "p2sh-p2wpkh";
14089
+ redeemScript: string;
14090
+ } | {
14091
+ type: "p2tr-key-path";
14092
+ tapInternalKey: string;
14093
+ } | {
14094
+ type: "p2wsh";
14095
+ witnessScript: string;
14096
+ } | {
14097
+ type: "p2tr-script-path";
14098
+ tapLeafScript: {
14099
+ script: string;
14100
+ controlBlock: string;
14101
+ }[];
14102
+ } | undefined;
14103
+ stacksMultisig?: {
14104
+ hashMode: "P2SHNonSequential";
14105
+ threshold: number;
14106
+ publicKeys: string[];
14107
+ } | undefined;
14108
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
12526
14109
  readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone", "multisig"], undefined>;
12527
14110
  readonly network: v.ObjectSchema<{
12528
14111
  readonly bitcoin: v.ObjectSchema<{
@@ -12580,6 +14163,11 @@ declare const walletSuccessResponseSchema: v.VariantSchema<"~sats-connect-method
12580
14163
  controlBlock: string;
12581
14164
  }[], 1, undefined>]>;
12582
14165
  }, undefined>], undefined>, undefined>;
14166
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
14167
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
14168
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
14169
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
14170
+ }, undefined>, undefined>;
12583
14171
  }, undefined>, v.CheckAction<{
12584
14172
  address: string;
12585
14173
  publicKey: string;
@@ -12605,6 +14193,11 @@ declare const walletSuccessResponseSchema: v.VariantSchema<"~sats-connect-method
12605
14193
  controlBlock: string;
12606
14194
  }[];
12607
14195
  } | undefined;
14196
+ stacksMultisig?: {
14197
+ hashMode: "P2SHNonSequential";
14198
+ threshold: number;
14199
+ publicKeys: string[];
14200
+ } | undefined;
12608
14201
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
12609
14202
  address: string;
12610
14203
  publicKey: string;
@@ -12630,7 +14223,42 @@ declare const walletSuccessResponseSchema: v.VariantSchema<"~sats-connect-method
12630
14223
  controlBlock: string;
12631
14224
  }[];
12632
14225
  } | undefined;
12633
- }, "unlockDefinition type does not match addressType">]>, undefined>;
14226
+ stacksMultisig?: {
14227
+ hashMode: "P2SHNonSequential";
14228
+ threshold: number;
14229
+ publicKeys: string[];
14230
+ } | undefined;
14231
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
14232
+ address: string;
14233
+ publicKey: string;
14234
+ purpose: AddressPurpose;
14235
+ addressType: AddressType;
14236
+ walletType: "software" | "ledger" | "keystone" | "multisig";
14237
+ scriptPubKey?: string | undefined;
14238
+ unlockDefinition?: {
14239
+ type: "p2wpkh";
14240
+ } | {
14241
+ type: "p2sh-p2wpkh";
14242
+ redeemScript: string;
14243
+ } | {
14244
+ type: "p2tr-key-path";
14245
+ tapInternalKey: string;
14246
+ } | {
14247
+ type: "p2wsh";
14248
+ witnessScript: string;
14249
+ } | {
14250
+ type: "p2tr-script-path";
14251
+ tapLeafScript: {
14252
+ script: string;
14253
+ controlBlock: string;
14254
+ }[];
14255
+ } | undefined;
14256
+ stacksMultisig?: {
14257
+ hashMode: "P2SHNonSequential";
14258
+ threshold: number;
14259
+ publicKeys: string[];
14260
+ } | undefined;
14261
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
12634
14262
  readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone", "multisig"], undefined>;
12635
14263
  readonly networks: v.ObjectSchema<{
12636
14264
  readonly active: v.ObjectSchema<{
@@ -13056,6 +14684,11 @@ declare const walletSuccessResponseSchema: v.VariantSchema<"~sats-connect-method
13056
14684
  controlBlock: string;
13057
14685
  }[], 1, undefined>]>;
13058
14686
  }, undefined>], undefined>, undefined>;
14687
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
14688
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
14689
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
14690
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
14691
+ }, undefined>, undefined>;
13059
14692
  }, undefined>, v.CheckAction<{
13060
14693
  address: string;
13061
14694
  publicKey: string;
@@ -13081,6 +14714,11 @@ declare const walletSuccessResponseSchema: v.VariantSchema<"~sats-connect-method
13081
14714
  controlBlock: string;
13082
14715
  }[];
13083
14716
  } | undefined;
14717
+ stacksMultisig?: {
14718
+ hashMode: "P2SHNonSequential";
14719
+ threshold: number;
14720
+ publicKeys: string[];
14721
+ } | undefined;
13084
14722
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
13085
14723
  address: string;
13086
14724
  publicKey: string;
@@ -13106,7 +14744,42 @@ declare const walletSuccessResponseSchema: v.VariantSchema<"~sats-connect-method
13106
14744
  controlBlock: string;
13107
14745
  }[];
13108
14746
  } | undefined;
13109
- }, "unlockDefinition type does not match addressType">]>;
14747
+ stacksMultisig?: {
14748
+ hashMode: "P2SHNonSequential";
14749
+ threshold: number;
14750
+ publicKeys: string[];
14751
+ } | undefined;
14752
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
14753
+ address: string;
14754
+ publicKey: string;
14755
+ purpose: AddressPurpose;
14756
+ addressType: AddressType;
14757
+ walletType: "software" | "ledger" | "keystone" | "multisig";
14758
+ scriptPubKey?: string | undefined;
14759
+ unlockDefinition?: {
14760
+ type: "p2wpkh";
14761
+ } | {
14762
+ type: "p2sh-p2wpkh";
14763
+ redeemScript: string;
14764
+ } | {
14765
+ type: "p2tr-key-path";
14766
+ tapInternalKey: string;
14767
+ } | {
14768
+ type: "p2wsh";
14769
+ witnessScript: string;
14770
+ } | {
14771
+ type: "p2tr-script-path";
14772
+ tapLeafScript: {
14773
+ script: string;
14774
+ controlBlock: string;
14775
+ }[];
14776
+ } | undefined;
14777
+ stacksMultisig?: {
14778
+ hashMode: "P2SHNonSequential";
14779
+ threshold: number;
14780
+ publicKeys: string[];
14781
+ } | undefined;
14782
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>;
13110
14783
  readonly '~sats-connect-method': v.LiteralSchema<"wallet_openReceive", undefined>;
13111
14784
  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
13112
14785
  readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
@@ -13158,6 +14831,19 @@ declare const walletSuccessResponseSchema: v.VariantSchema<"~sats-connect-method
13158
14831
  declare const walletTypes: readonly ["software", "ledger", "keystone", "multisig"];
13159
14832
  declare const walletTypeSchema: v.PicklistSchema<readonly ["software", "ledger", "keystone", "multisig"], undefined>;
13160
14833
  type WalletType = v.InferOutput<typeof walletTypeSchema>;
14834
+ /**
14835
+ * Signer set of a Stacks multisig (vault) address.
14836
+ */
14837
+ declare const stacksMultisigSchema: v.ObjectSchema<{
14838
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
14839
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
14840
+ /**
14841
+ * Compressed secp256k1 public keys of the vault members, in the order the vault
14842
+ * address derives from.
14843
+ */
14844
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
14845
+ }, undefined>;
14846
+ type StacksMultisig = v.InferOutput<typeof stacksMultisigSchema>;
13161
14847
  //#endregion
13162
14848
  //#region src/request/shared.d.ts
13163
14849
  declare const rpcIdSchema: v.StringSchema<undefined>;
@@ -14285,6 +15971,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
14285
15971
  controlBlock: string;
14286
15972
  }[], 1, undefined>]>;
14287
15973
  }, undefined>], undefined>, undefined>;
15974
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
15975
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
15976
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
15977
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
15978
+ }, undefined>, undefined>;
14288
15979
  }, undefined>, v.CheckAction<{
14289
15980
  address: string;
14290
15981
  publicKey: string;
@@ -14310,6 +16001,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
14310
16001
  controlBlock: string;
14311
16002
  }[];
14312
16003
  } | undefined;
16004
+ stacksMultisig?: {
16005
+ hashMode: "P2SHNonSequential";
16006
+ threshold: number;
16007
+ publicKeys: string[];
16008
+ } | undefined;
14313
16009
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
14314
16010
  address: string;
14315
16011
  publicKey: string;
@@ -14335,7 +16031,42 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
14335
16031
  controlBlock: string;
14336
16032
  }[];
14337
16033
  } | undefined;
14338
- }, "unlockDefinition type does not match addressType">]>, undefined>;
16034
+ stacksMultisig?: {
16035
+ hashMode: "P2SHNonSequential";
16036
+ threshold: number;
16037
+ publicKeys: string[];
16038
+ } | undefined;
16039
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
16040
+ address: string;
16041
+ publicKey: string;
16042
+ purpose: AddressPurpose;
16043
+ addressType: AddressType;
16044
+ walletType: "software" | "ledger" | "keystone" | "multisig";
16045
+ scriptPubKey?: string | undefined;
16046
+ unlockDefinition?: {
16047
+ type: "p2wpkh";
16048
+ } | {
16049
+ type: "p2sh-p2wpkh";
16050
+ redeemScript: string;
16051
+ } | {
16052
+ type: "p2tr-key-path";
16053
+ tapInternalKey: string;
16054
+ } | {
16055
+ type: "p2wsh";
16056
+ witnessScript: string;
16057
+ } | {
16058
+ type: "p2tr-script-path";
16059
+ tapLeafScript: {
16060
+ script: string;
16061
+ controlBlock: string;
16062
+ }[];
16063
+ } | undefined;
16064
+ stacksMultisig?: {
16065
+ hashMode: "P2SHNonSequential";
16066
+ threshold: number;
16067
+ publicKeys: string[];
16068
+ } | undefined;
16069
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
14339
16070
  readonly '~sats-connect-method': v.LiteralSchema<"getAccounts", undefined>;
14340
16071
  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
14341
16072
  readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
@@ -14379,6 +16110,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
14379
16110
  controlBlock: string;
14380
16111
  }[], 1, undefined>]>;
14381
16112
  }, undefined>], undefined>, undefined>;
16113
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
16114
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
16115
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
16116
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
16117
+ }, undefined>, undefined>;
14382
16118
  }, undefined>, v.CheckAction<{
14383
16119
  address: string;
14384
16120
  publicKey: string;
@@ -14404,6 +16140,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
14404
16140
  controlBlock: string;
14405
16141
  }[];
14406
16142
  } | undefined;
16143
+ stacksMultisig?: {
16144
+ hashMode: "P2SHNonSequential";
16145
+ threshold: number;
16146
+ publicKeys: string[];
16147
+ } | undefined;
14407
16148
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
14408
16149
  address: string;
14409
16150
  publicKey: string;
@@ -14429,7 +16170,42 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
14429
16170
  controlBlock: string;
14430
16171
  }[];
14431
16172
  } | undefined;
14432
- }, "unlockDefinition type does not match addressType">]>, undefined>;
16173
+ stacksMultisig?: {
16174
+ hashMode: "P2SHNonSequential";
16175
+ threshold: number;
16176
+ publicKeys: string[];
16177
+ } | undefined;
16178
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
16179
+ address: string;
16180
+ publicKey: string;
16181
+ purpose: AddressPurpose;
16182
+ addressType: AddressType;
16183
+ walletType: "software" | "ledger" | "keystone" | "multisig";
16184
+ scriptPubKey?: string | undefined;
16185
+ unlockDefinition?: {
16186
+ type: "p2wpkh";
16187
+ } | {
16188
+ type: "p2sh-p2wpkh";
16189
+ redeemScript: string;
16190
+ } | {
16191
+ type: "p2tr-key-path";
16192
+ tapInternalKey: string;
16193
+ } | {
16194
+ type: "p2wsh";
16195
+ witnessScript: string;
16196
+ } | {
16197
+ type: "p2tr-script-path";
16198
+ tapLeafScript: {
16199
+ script: string;
16200
+ controlBlock: string;
16201
+ }[];
16202
+ } | undefined;
16203
+ stacksMultisig?: {
16204
+ hashMode: "P2SHNonSequential";
16205
+ threshold: number;
16206
+ publicKeys: string[];
16207
+ } | undefined;
16208
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
14433
16209
  readonly network: v.ObjectSchema<{
14434
16210
  readonly bitcoin: v.ObjectSchema<{
14435
16211
  readonly name: v.StringSchema<undefined>;
@@ -14485,6 +16261,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
14485
16261
  controlBlock: string;
14486
16262
  }[], 1, undefined>]>;
14487
16263
  }, undefined>], undefined>, undefined>;
16264
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
16265
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
16266
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
16267
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
16268
+ }, undefined>, undefined>;
14488
16269
  }, undefined>, v.CheckAction<{
14489
16270
  address: string;
14490
16271
  publicKey: string;
@@ -14510,6 +16291,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
14510
16291
  controlBlock: string;
14511
16292
  }[];
14512
16293
  } | undefined;
16294
+ stacksMultisig?: {
16295
+ hashMode: "P2SHNonSequential";
16296
+ threshold: number;
16297
+ publicKeys: string[];
16298
+ } | undefined;
14513
16299
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
14514
16300
  address: string;
14515
16301
  publicKey: string;
@@ -14535,7 +16321,42 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
14535
16321
  controlBlock: string;
14536
16322
  }[];
14537
16323
  } | undefined;
14538
- }, "unlockDefinition type does not match addressType">]>, undefined>;
16324
+ stacksMultisig?: {
16325
+ hashMode: "P2SHNonSequential";
16326
+ threshold: number;
16327
+ publicKeys: string[];
16328
+ } | undefined;
16329
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
16330
+ address: string;
16331
+ publicKey: string;
16332
+ purpose: AddressPurpose;
16333
+ addressType: AddressType;
16334
+ walletType: "software" | "ledger" | "keystone" | "multisig";
16335
+ scriptPubKey?: string | undefined;
16336
+ unlockDefinition?: {
16337
+ type: "p2wpkh";
16338
+ } | {
16339
+ type: "p2sh-p2wpkh";
16340
+ redeemScript: string;
16341
+ } | {
16342
+ type: "p2tr-key-path";
16343
+ tapInternalKey: string;
16344
+ } | {
16345
+ type: "p2wsh";
16346
+ witnessScript: string;
16347
+ } | {
16348
+ type: "p2tr-script-path";
16349
+ tapLeafScript: {
16350
+ script: string;
16351
+ controlBlock: string;
16352
+ }[];
16353
+ } | undefined;
16354
+ stacksMultisig?: {
16355
+ hashMode: "P2SHNonSequential";
16356
+ threshold: number;
16357
+ publicKeys: string[];
16358
+ } | undefined;
16359
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
14539
16360
  readonly networks: v.ObjectSchema<{
14540
16361
  readonly active: v.ObjectSchema<{
14541
16362
  readonly bitcoin: v.ObjectSchema<{
@@ -14895,12 +16716,21 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
14895
16716
  }, undefined>, v.ObjectSchema<{
14896
16717
  readonly id: v.StringSchema<undefined>;
14897
16718
  readonly result: v.ObjectSchema<{
14898
- readonly addresses: v.ArraySchema<v.ObjectSchema<{
16719
+ readonly addresses: v.ArraySchema<v.UnionSchema<[v.ObjectSchema<{
14899
16720
  readonly address: v.StringSchema<undefined>;
14900
16721
  readonly publicKey: v.StringSchema<undefined>;
14901
16722
  readonly gaiaHubUrl: v.StringSchema<undefined>;
14902
16723
  readonly gaiaAppKey: v.StringSchema<undefined>;
14903
- }, undefined>, undefined>;
16724
+ readonly walletType: v.OptionalSchema<v.PicklistSchema<("software" | "ledger" | "keystone")[], undefined>, undefined>;
16725
+ }, undefined>, v.StrictObjectSchema<{
16726
+ readonly address: v.StringSchema<undefined>;
16727
+ readonly walletType: v.LiteralSchema<"multisig", undefined>;
16728
+ readonly multisig: v.ObjectSchema<{
16729
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
16730
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
16731
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
16732
+ }, undefined>;
16733
+ }, undefined>], undefined>, undefined>;
14904
16734
  readonly network: v.ObjectSchema<{
14905
16735
  readonly bitcoin: v.ObjectSchema<{
14906
16736
  readonly name: v.EnumSchema<typeof BitcoinNetworkType, undefined>;
@@ -14956,6 +16786,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
14956
16786
  controlBlock: string;
14957
16787
  }[], 1, undefined>]>;
14958
16788
  }, undefined>], undefined>, undefined>;
16789
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
16790
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
16791
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
16792
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
16793
+ }, undefined>, undefined>;
14959
16794
  }, undefined>, v.CheckAction<{
14960
16795
  address: string;
14961
16796
  publicKey: string;
@@ -14981,6 +16816,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
14981
16816
  controlBlock: string;
14982
16817
  }[];
14983
16818
  } | undefined;
16819
+ stacksMultisig?: {
16820
+ hashMode: "P2SHNonSequential";
16821
+ threshold: number;
16822
+ publicKeys: string[];
16823
+ } | undefined;
14984
16824
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
14985
16825
  address: string;
14986
16826
  publicKey: string;
@@ -15006,7 +16846,42 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
15006
16846
  controlBlock: string;
15007
16847
  }[];
15008
16848
  } | undefined;
15009
- }, "unlockDefinition type does not match addressType">]>, undefined>;
16849
+ stacksMultisig?: {
16850
+ hashMode: "P2SHNonSequential";
16851
+ threshold: number;
16852
+ publicKeys: string[];
16853
+ } | undefined;
16854
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
16855
+ address: string;
16856
+ publicKey: string;
16857
+ purpose: AddressPurpose;
16858
+ addressType: AddressType;
16859
+ walletType: "software" | "ledger" | "keystone" | "multisig";
16860
+ scriptPubKey?: string | undefined;
16861
+ unlockDefinition?: {
16862
+ type: "p2wpkh";
16863
+ } | {
16864
+ type: "p2sh-p2wpkh";
16865
+ redeemScript: string;
16866
+ } | {
16867
+ type: "p2tr-key-path";
16868
+ tapInternalKey: string;
16869
+ } | {
16870
+ type: "p2wsh";
16871
+ witnessScript: string;
16872
+ } | {
16873
+ type: "p2tr-script-path";
16874
+ tapLeafScript: {
16875
+ script: string;
16876
+ controlBlock: string;
16877
+ }[];
16878
+ } | undefined;
16879
+ stacksMultisig?: {
16880
+ hashMode: "P2SHNonSequential";
16881
+ threshold: number;
16882
+ publicKeys: string[];
16883
+ } | undefined;
16884
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
15010
16885
  readonly network: v.ObjectSchema<{
15011
16886
  readonly bitcoin: v.ObjectSchema<{
15012
16887
  readonly name: v.EnumSchema<typeof BitcoinNetworkType, undefined>;
@@ -15076,6 +16951,7 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
15076
16951
  readonly id: v.StringSchema<undefined>;
15077
16952
  readonly result: v.ObjectSchema<{
15078
16953
  readonly transactions: v.ArraySchema<v.StringSchema<undefined>, undefined>;
16954
+ readonly txids: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
15079
16955
  }, undefined>;
15080
16956
  readonly '~sats-connect-method': v.LiteralSchema<"stx_signTransactions", undefined>;
15081
16957
  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
@@ -15135,6 +17011,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
15135
17011
  controlBlock: string;
15136
17012
  }[], 1, undefined>]>;
15137
17013
  }, undefined>], undefined>, undefined>;
17014
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
17015
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
17016
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
17017
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
17018
+ }, undefined>, undefined>;
15138
17019
  }, undefined>, v.CheckAction<{
15139
17020
  address: string;
15140
17021
  publicKey: string;
@@ -15160,6 +17041,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
15160
17041
  controlBlock: string;
15161
17042
  }[];
15162
17043
  } | undefined;
17044
+ stacksMultisig?: {
17045
+ hashMode: "P2SHNonSequential";
17046
+ threshold: number;
17047
+ publicKeys: string[];
17048
+ } | undefined;
15163
17049
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
15164
17050
  address: string;
15165
17051
  publicKey: string;
@@ -15185,7 +17071,42 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
15185
17071
  controlBlock: string;
15186
17072
  }[];
15187
17073
  } | undefined;
15188
- }, "unlockDefinition type does not match addressType">]>, undefined>;
17074
+ stacksMultisig?: {
17075
+ hashMode: "P2SHNonSequential";
17076
+ threshold: number;
17077
+ publicKeys: string[];
17078
+ } | undefined;
17079
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
17080
+ address: string;
17081
+ publicKey: string;
17082
+ purpose: AddressPurpose;
17083
+ addressType: AddressType;
17084
+ walletType: "software" | "ledger" | "keystone" | "multisig";
17085
+ scriptPubKey?: string | undefined;
17086
+ unlockDefinition?: {
17087
+ type: "p2wpkh";
17088
+ } | {
17089
+ type: "p2sh-p2wpkh";
17090
+ redeemScript: string;
17091
+ } | {
17092
+ type: "p2tr-key-path";
17093
+ tapInternalKey: string;
17094
+ } | {
17095
+ type: "p2wsh";
17096
+ witnessScript: string;
17097
+ } | {
17098
+ type: "p2tr-script-path";
17099
+ tapLeafScript: {
17100
+ script: string;
17101
+ controlBlock: string;
17102
+ }[];
17103
+ } | undefined;
17104
+ stacksMultisig?: {
17105
+ hashMode: "P2SHNonSequential";
17106
+ threshold: number;
17107
+ publicKeys: string[];
17108
+ } | undefined;
17109
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
15189
17110
  readonly network: v.ObjectSchema<{
15190
17111
  readonly bitcoin: v.ObjectSchema<{
15191
17112
  readonly name: v.EnumSchema<typeof BitcoinNetworkType, undefined>;
@@ -15241,6 +17162,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
15241
17162
  controlBlock: string;
15242
17163
  }[], 1, undefined>]>;
15243
17164
  }, undefined>], undefined>, undefined>;
17165
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
17166
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
17167
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
17168
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
17169
+ }, undefined>, undefined>;
15244
17170
  }, undefined>, v.CheckAction<{
15245
17171
  address: string;
15246
17172
  publicKey: string;
@@ -15266,6 +17192,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
15266
17192
  controlBlock: string;
15267
17193
  }[];
15268
17194
  } | undefined;
17195
+ stacksMultisig?: {
17196
+ hashMode: "P2SHNonSequential";
17197
+ threshold: number;
17198
+ publicKeys: string[];
17199
+ } | undefined;
15269
17200
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
15270
17201
  address: string;
15271
17202
  publicKey: string;
@@ -15291,7 +17222,42 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
15291
17222
  controlBlock: string;
15292
17223
  }[];
15293
17224
  } | undefined;
15294
- }, "unlockDefinition type does not match addressType">]>, undefined>;
17225
+ stacksMultisig?: {
17226
+ hashMode: "P2SHNonSequential";
17227
+ threshold: number;
17228
+ publicKeys: string[];
17229
+ } | undefined;
17230
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
17231
+ address: string;
17232
+ publicKey: string;
17233
+ purpose: AddressPurpose;
17234
+ addressType: AddressType;
17235
+ walletType: "software" | "ledger" | "keystone" | "multisig";
17236
+ scriptPubKey?: string | undefined;
17237
+ unlockDefinition?: {
17238
+ type: "p2wpkh";
17239
+ } | {
17240
+ type: "p2sh-p2wpkh";
17241
+ redeemScript: string;
17242
+ } | {
17243
+ type: "p2tr-key-path";
17244
+ tapInternalKey: string;
17245
+ } | {
17246
+ type: "p2wsh";
17247
+ witnessScript: string;
17248
+ } | {
17249
+ type: "p2tr-script-path";
17250
+ tapLeafScript: {
17251
+ script: string;
17252
+ controlBlock: string;
17253
+ }[];
17254
+ } | undefined;
17255
+ stacksMultisig?: {
17256
+ hashMode: "P2SHNonSequential";
17257
+ threshold: number;
17258
+ publicKeys: string[];
17259
+ } | undefined;
17260
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
15295
17261
  readonly network: v.ObjectSchema<{
15296
17262
  readonly chain: v.LiteralSchema<"spark", undefined>;
15297
17263
  readonly mode: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EnumSchema<{
@@ -15842,6 +17808,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
15842
17808
  controlBlock: string;
15843
17809
  }[], 1, undefined>]>;
15844
17810
  }, undefined>], undefined>, undefined>;
17811
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
17812
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
17813
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
17814
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
17815
+ }, undefined>, undefined>;
15845
17816
  }, undefined>, v.CheckAction<{
15846
17817
  address: string;
15847
17818
  publicKey: string;
@@ -15867,6 +17838,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
15867
17838
  controlBlock: string;
15868
17839
  }[];
15869
17840
  } | undefined;
17841
+ stacksMultisig?: {
17842
+ hashMode: "P2SHNonSequential";
17843
+ threshold: number;
17844
+ publicKeys: string[];
17845
+ } | undefined;
15870
17846
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
15871
17847
  address: string;
15872
17848
  publicKey: string;
@@ -15892,7 +17868,42 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
15892
17868
  controlBlock: string;
15893
17869
  }[];
15894
17870
  } | undefined;
15895
- }, "unlockDefinition type does not match addressType">]>, undefined>;
17871
+ stacksMultisig?: {
17872
+ hashMode: "P2SHNonSequential";
17873
+ threshold: number;
17874
+ publicKeys: string[];
17875
+ } | undefined;
17876
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
17877
+ address: string;
17878
+ publicKey: string;
17879
+ purpose: AddressPurpose;
17880
+ addressType: AddressType;
17881
+ walletType: "software" | "ledger" | "keystone" | "multisig";
17882
+ scriptPubKey?: string | undefined;
17883
+ unlockDefinition?: {
17884
+ type: "p2wpkh";
17885
+ } | {
17886
+ type: "p2sh-p2wpkh";
17887
+ redeemScript: string;
17888
+ } | {
17889
+ type: "p2tr-key-path";
17890
+ tapInternalKey: string;
17891
+ } | {
17892
+ type: "p2wsh";
17893
+ witnessScript: string;
17894
+ } | {
17895
+ type: "p2tr-script-path";
17896
+ tapLeafScript: {
17897
+ script: string;
17898
+ controlBlock: string;
17899
+ }[];
17900
+ } | undefined;
17901
+ stacksMultisig?: {
17902
+ hashMode: "P2SHNonSequential";
17903
+ threshold: number;
17904
+ publicKeys: string[];
17905
+ } | undefined;
17906
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
15896
17907
  readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone", "multisig"], undefined>;
15897
17908
  readonly network: v.ObjectSchema<{
15898
17909
  readonly bitcoin: v.ObjectSchema<{
@@ -15950,6 +17961,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
15950
17961
  controlBlock: string;
15951
17962
  }[], 1, undefined>]>;
15952
17963
  }, undefined>], undefined>, undefined>;
17964
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
17965
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
17966
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
17967
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
17968
+ }, undefined>, undefined>;
15953
17969
  }, undefined>, v.CheckAction<{
15954
17970
  address: string;
15955
17971
  publicKey: string;
@@ -15975,6 +17991,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
15975
17991
  controlBlock: string;
15976
17992
  }[];
15977
17993
  } | undefined;
17994
+ stacksMultisig?: {
17995
+ hashMode: "P2SHNonSequential";
17996
+ threshold: number;
17997
+ publicKeys: string[];
17998
+ } | undefined;
15978
17999
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
15979
18000
  address: string;
15980
18001
  publicKey: string;
@@ -16000,7 +18021,42 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
16000
18021
  controlBlock: string;
16001
18022
  }[];
16002
18023
  } | undefined;
16003
- }, "unlockDefinition type does not match addressType">]>, undefined>;
18024
+ stacksMultisig?: {
18025
+ hashMode: "P2SHNonSequential";
18026
+ threshold: number;
18027
+ publicKeys: string[];
18028
+ } | undefined;
18029
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
18030
+ address: string;
18031
+ publicKey: string;
18032
+ purpose: AddressPurpose;
18033
+ addressType: AddressType;
18034
+ walletType: "software" | "ledger" | "keystone" | "multisig";
18035
+ scriptPubKey?: string | undefined;
18036
+ unlockDefinition?: {
18037
+ type: "p2wpkh";
18038
+ } | {
18039
+ type: "p2sh-p2wpkh";
18040
+ redeemScript: string;
18041
+ } | {
18042
+ type: "p2tr-key-path";
18043
+ tapInternalKey: string;
18044
+ } | {
18045
+ type: "p2wsh";
18046
+ witnessScript: string;
18047
+ } | {
18048
+ type: "p2tr-script-path";
18049
+ tapLeafScript: {
18050
+ script: string;
18051
+ controlBlock: string;
18052
+ }[];
18053
+ } | undefined;
18054
+ stacksMultisig?: {
18055
+ hashMode: "P2SHNonSequential";
18056
+ threshold: number;
18057
+ publicKeys: string[];
18058
+ } | undefined;
18059
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
16004
18060
  readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone", "multisig"], undefined>;
16005
18061
  readonly networks: v.ObjectSchema<{
16006
18062
  readonly active: v.ObjectSchema<{
@@ -16196,6 +18252,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
16196
18252
  controlBlock: string;
16197
18253
  }[], 1, undefined>]>;
16198
18254
  }, undefined>], undefined>, undefined>;
18255
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
18256
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
18257
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
18258
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
18259
+ }, undefined>, undefined>;
16199
18260
  }, undefined>, v.CheckAction<{
16200
18261
  address: string;
16201
18262
  publicKey: string;
@@ -16221,6 +18282,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
16221
18282
  controlBlock: string;
16222
18283
  }[];
16223
18284
  } | undefined;
18285
+ stacksMultisig?: {
18286
+ hashMode: "P2SHNonSequential";
18287
+ threshold: number;
18288
+ publicKeys: string[];
18289
+ } | undefined;
16224
18290
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
16225
18291
  address: string;
16226
18292
  publicKey: string;
@@ -16246,7 +18312,42 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
16246
18312
  controlBlock: string;
16247
18313
  }[];
16248
18314
  } | undefined;
16249
- }, "unlockDefinition type does not match addressType">]>, undefined>;
18315
+ stacksMultisig?: {
18316
+ hashMode: "P2SHNonSequential";
18317
+ threshold: number;
18318
+ publicKeys: string[];
18319
+ } | undefined;
18320
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
18321
+ address: string;
18322
+ publicKey: string;
18323
+ purpose: AddressPurpose;
18324
+ addressType: AddressType;
18325
+ walletType: "software" | "ledger" | "keystone" | "multisig";
18326
+ scriptPubKey?: string | undefined;
18327
+ unlockDefinition?: {
18328
+ type: "p2wpkh";
18329
+ } | {
18330
+ type: "p2sh-p2wpkh";
18331
+ redeemScript: string;
18332
+ } | {
18333
+ type: "p2tr-key-path";
18334
+ tapInternalKey: string;
18335
+ } | {
18336
+ type: "p2wsh";
18337
+ witnessScript: string;
18338
+ } | {
18339
+ type: "p2tr-script-path";
18340
+ tapLeafScript: {
18341
+ script: string;
18342
+ controlBlock: string;
18343
+ }[];
18344
+ } | undefined;
18345
+ stacksMultisig?: {
18346
+ hashMode: "P2SHNonSequential";
18347
+ threshold: number;
18348
+ publicKeys: string[];
18349
+ } | undefined;
18350
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
16250
18351
  readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone", "multisig"], undefined>;
16251
18352
  readonly network: v.ObjectSchema<{
16252
18353
  readonly bitcoin: v.ObjectSchema<{
@@ -16304,6 +18405,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
16304
18405
  controlBlock: string;
16305
18406
  }[], 1, undefined>]>;
16306
18407
  }, undefined>], undefined>, undefined>;
18408
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
18409
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
18410
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
18411
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
18412
+ }, undefined>, undefined>;
16307
18413
  }, undefined>, v.CheckAction<{
16308
18414
  address: string;
16309
18415
  publicKey: string;
@@ -16329,6 +18435,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
16329
18435
  controlBlock: string;
16330
18436
  }[];
16331
18437
  } | undefined;
18438
+ stacksMultisig?: {
18439
+ hashMode: "P2SHNonSequential";
18440
+ threshold: number;
18441
+ publicKeys: string[];
18442
+ } | undefined;
16332
18443
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
16333
18444
  address: string;
16334
18445
  publicKey: string;
@@ -16354,7 +18465,42 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
16354
18465
  controlBlock: string;
16355
18466
  }[];
16356
18467
  } | undefined;
16357
- }, "unlockDefinition type does not match addressType">]>, undefined>;
18468
+ stacksMultisig?: {
18469
+ hashMode: "P2SHNonSequential";
18470
+ threshold: number;
18471
+ publicKeys: string[];
18472
+ } | undefined;
18473
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
18474
+ address: string;
18475
+ publicKey: string;
18476
+ purpose: AddressPurpose;
18477
+ addressType: AddressType;
18478
+ walletType: "software" | "ledger" | "keystone" | "multisig";
18479
+ scriptPubKey?: string | undefined;
18480
+ unlockDefinition?: {
18481
+ type: "p2wpkh";
18482
+ } | {
18483
+ type: "p2sh-p2wpkh";
18484
+ redeemScript: string;
18485
+ } | {
18486
+ type: "p2tr-key-path";
18487
+ tapInternalKey: string;
18488
+ } | {
18489
+ type: "p2wsh";
18490
+ witnessScript: string;
18491
+ } | {
18492
+ type: "p2tr-script-path";
18493
+ tapLeafScript: {
18494
+ script: string;
18495
+ controlBlock: string;
18496
+ }[];
18497
+ } | undefined;
18498
+ stacksMultisig?: {
18499
+ hashMode: "P2SHNonSequential";
18500
+ threshold: number;
18501
+ publicKeys: string[];
18502
+ } | undefined;
18503
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
16358
18504
  readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone", "multisig"], undefined>;
16359
18505
  readonly networks: v.ObjectSchema<{
16360
18506
  readonly active: v.ObjectSchema<{
@@ -16780,6 +18926,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
16780
18926
  controlBlock: string;
16781
18927
  }[], 1, undefined>]>;
16782
18928
  }, undefined>], undefined>, undefined>;
18929
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
18930
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
18931
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
18932
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
18933
+ }, undefined>, undefined>;
16783
18934
  }, undefined>, v.CheckAction<{
16784
18935
  address: string;
16785
18936
  publicKey: string;
@@ -16805,6 +18956,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
16805
18956
  controlBlock: string;
16806
18957
  }[];
16807
18958
  } | undefined;
18959
+ stacksMultisig?: {
18960
+ hashMode: "P2SHNonSequential";
18961
+ threshold: number;
18962
+ publicKeys: string[];
18963
+ } | undefined;
16808
18964
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
16809
18965
  address: string;
16810
18966
  publicKey: string;
@@ -16830,7 +18986,42 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
16830
18986
  controlBlock: string;
16831
18987
  }[];
16832
18988
  } | undefined;
16833
- }, "unlockDefinition type does not match addressType">]>;
18989
+ stacksMultisig?: {
18990
+ hashMode: "P2SHNonSequential";
18991
+ threshold: number;
18992
+ publicKeys: string[];
18993
+ } | undefined;
18994
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
18995
+ address: string;
18996
+ publicKey: string;
18997
+ purpose: AddressPurpose;
18998
+ addressType: AddressType;
18999
+ walletType: "software" | "ledger" | "keystone" | "multisig";
19000
+ scriptPubKey?: string | undefined;
19001
+ unlockDefinition?: {
19002
+ type: "p2wpkh";
19003
+ } | {
19004
+ type: "p2sh-p2wpkh";
19005
+ redeemScript: string;
19006
+ } | {
19007
+ type: "p2tr-key-path";
19008
+ tapInternalKey: string;
19009
+ } | {
19010
+ type: "p2wsh";
19011
+ witnessScript: string;
19012
+ } | {
19013
+ type: "p2tr-script-path";
19014
+ tapLeafScript: {
19015
+ script: string;
19016
+ controlBlock: string;
19017
+ }[];
19018
+ } | undefined;
19019
+ stacksMultisig?: {
19020
+ hashMode: "P2SHNonSequential";
19021
+ threshold: number;
19022
+ publicKeys: string[];
19023
+ } | undefined;
19024
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>;
16834
19025
  readonly '~sats-connect-method': v.LiteralSchema<"wallet_openReceive", undefined>;
16835
19026
  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
16836
19027
  readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
@@ -17112,6 +19303,10 @@ type SignMultipleTransactionOptions = RequestOptions<SignMultipleTransactionsPay
17112
19303
  declare const sendBtcTransaction: (options: SendBtcTransactionOptions) => Promise<void>;
17113
19304
  //#endregion
17114
19305
  //#region src/transactions/signMultipleTransactions.d.ts
19306
+ /**
19307
+ * For vault (multisig) accounts the wallet returns the finalized PSBTs without
19308
+ * broadcasting them, so every `txId` in the response is empty.
19309
+ */
17115
19310
  declare const signMultipleTransactions: (options: SignMultipleTransactionOptions) => Promise<void>;
17116
19311
  //#endregion
17117
19312
  //#region src/transactions/signTransaction.d.ts
@@ -17152,6 +19347,11 @@ declare const accountChangeSchema: v.ObjectSchema<{
17152
19347
  controlBlock: string;
17153
19348
  }[], 1, undefined>]>;
17154
19349
  }, undefined>], undefined>, undefined>;
19350
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
19351
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
19352
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
19353
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
19354
+ }, undefined>, undefined>;
17155
19355
  }, undefined>, v.CheckAction<{
17156
19356
  address: string;
17157
19357
  publicKey: string;
@@ -17177,6 +19377,11 @@ declare const accountChangeSchema: v.ObjectSchema<{
17177
19377
  controlBlock: string;
17178
19378
  }[];
17179
19379
  } | undefined;
19380
+ stacksMultisig?: {
19381
+ hashMode: "P2SHNonSequential";
19382
+ threshold: number;
19383
+ publicKeys: string[];
19384
+ } | undefined;
17180
19385
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
17181
19386
  address: string;
17182
19387
  publicKey: string;
@@ -17202,7 +19407,42 @@ declare const accountChangeSchema: v.ObjectSchema<{
17202
19407
  controlBlock: string;
17203
19408
  }[];
17204
19409
  } | undefined;
17205
- }, "unlockDefinition type does not match addressType">]>, undefined>, undefined>;
19410
+ stacksMultisig?: {
19411
+ hashMode: "P2SHNonSequential";
19412
+ threshold: number;
19413
+ publicKeys: string[];
19414
+ } | undefined;
19415
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
19416
+ address: string;
19417
+ publicKey: string;
19418
+ purpose: AddressPurpose;
19419
+ addressType: AddressType;
19420
+ walletType: "software" | "ledger" | "keystone" | "multisig";
19421
+ scriptPubKey?: string | undefined;
19422
+ unlockDefinition?: {
19423
+ type: "p2wpkh";
19424
+ } | {
19425
+ type: "p2sh-p2wpkh";
19426
+ redeemScript: string;
19427
+ } | {
19428
+ type: "p2tr-key-path";
19429
+ tapInternalKey: string;
19430
+ } | {
19431
+ type: "p2wsh";
19432
+ witnessScript: string;
19433
+ } | {
19434
+ type: "p2tr-script-path";
19435
+ tapLeafScript: {
19436
+ script: string;
19437
+ controlBlock: string;
19438
+ }[];
19439
+ } | undefined;
19440
+ stacksMultisig?: {
19441
+ hashMode: "P2SHNonSequential";
19442
+ threshold: number;
19443
+ publicKeys: string[];
19444
+ } | undefined;
19445
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>, undefined>;
17206
19446
  }, undefined>;
17207
19447
  type AccountChangeEvent = v.InferOutput<typeof accountChangeSchema>;
17208
19448
  declare const networkChangeEventName = "networkChange";
@@ -17245,6 +19485,11 @@ declare const networkChangeSchema: v.ObjectSchema<{
17245
19485
  controlBlock: string;
17246
19486
  }[], 1, undefined>]>;
17247
19487
  }, undefined>], undefined>, undefined>;
19488
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
19489
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
19490
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
19491
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
19492
+ }, undefined>, undefined>;
17248
19493
  }, undefined>, v.CheckAction<{
17249
19494
  address: string;
17250
19495
  publicKey: string;
@@ -17270,6 +19515,11 @@ declare const networkChangeSchema: v.ObjectSchema<{
17270
19515
  controlBlock: string;
17271
19516
  }[];
17272
19517
  } | undefined;
19518
+ stacksMultisig?: {
19519
+ hashMode: "P2SHNonSequential";
19520
+ threshold: number;
19521
+ publicKeys: string[];
19522
+ } | undefined;
17273
19523
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
17274
19524
  address: string;
17275
19525
  publicKey: string;
@@ -17295,7 +19545,42 @@ declare const networkChangeSchema: v.ObjectSchema<{
17295
19545
  controlBlock: string;
17296
19546
  }[];
17297
19547
  } | undefined;
17298
- }, "unlockDefinition type does not match addressType">]>, undefined>, undefined>;
19548
+ stacksMultisig?: {
19549
+ hashMode: "P2SHNonSequential";
19550
+ threshold: number;
19551
+ publicKeys: string[];
19552
+ } | undefined;
19553
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
19554
+ address: string;
19555
+ publicKey: string;
19556
+ purpose: AddressPurpose;
19557
+ addressType: AddressType;
19558
+ walletType: "software" | "ledger" | "keystone" | "multisig";
19559
+ scriptPubKey?: string | undefined;
19560
+ unlockDefinition?: {
19561
+ type: "p2wpkh";
19562
+ } | {
19563
+ type: "p2sh-p2wpkh";
19564
+ redeemScript: string;
19565
+ } | {
19566
+ type: "p2tr-key-path";
19567
+ tapInternalKey: string;
19568
+ } | {
19569
+ type: "p2wsh";
19570
+ witnessScript: string;
19571
+ } | {
19572
+ type: "p2tr-script-path";
19573
+ tapLeafScript: {
19574
+ script: string;
19575
+ controlBlock: string;
19576
+ }[];
19577
+ } | undefined;
19578
+ stacksMultisig?: {
19579
+ hashMode: "P2SHNonSequential";
19580
+ threshold: number;
19581
+ publicKeys: string[];
19582
+ } | undefined;
19583
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>, undefined>;
17299
19584
  }, undefined>;
17300
19585
  type NetworkChangeEvent = v.InferOutput<typeof networkChangeSchema>;
17301
19586
  declare const networkChangeEventNameV2 = "networkChangeV2";
@@ -17402,6 +19687,11 @@ declare const networkChangeV2Schema: v.ObjectSchema<{
17402
19687
  controlBlock: string;
17403
19688
  }[], 1, undefined>]>;
17404
19689
  }, undefined>], undefined>, undefined>;
19690
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
19691
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
19692
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
19693
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
19694
+ }, undefined>, undefined>;
17405
19695
  }, undefined>, v.CheckAction<{
17406
19696
  address: string;
17407
19697
  publicKey: string;
@@ -17427,6 +19717,11 @@ declare const networkChangeV2Schema: v.ObjectSchema<{
17427
19717
  controlBlock: string;
17428
19718
  }[];
17429
19719
  } | undefined;
19720
+ stacksMultisig?: {
19721
+ hashMode: "P2SHNonSequential";
19722
+ threshold: number;
19723
+ publicKeys: string[];
19724
+ } | undefined;
17430
19725
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
17431
19726
  address: string;
17432
19727
  publicKey: string;
@@ -17452,7 +19747,42 @@ declare const networkChangeV2Schema: v.ObjectSchema<{
17452
19747
  controlBlock: string;
17453
19748
  }[];
17454
19749
  } | undefined;
17455
- }, "unlockDefinition type does not match addressType">]>, undefined>, undefined>;
19750
+ stacksMultisig?: {
19751
+ hashMode: "P2SHNonSequential";
19752
+ threshold: number;
19753
+ publicKeys: string[];
19754
+ } | undefined;
19755
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
19756
+ address: string;
19757
+ publicKey: string;
19758
+ purpose: AddressPurpose;
19759
+ addressType: AddressType;
19760
+ walletType: "software" | "ledger" | "keystone" | "multisig";
19761
+ scriptPubKey?: string | undefined;
19762
+ unlockDefinition?: {
19763
+ type: "p2wpkh";
19764
+ } | {
19765
+ type: "p2sh-p2wpkh";
19766
+ redeemScript: string;
19767
+ } | {
19768
+ type: "p2tr-key-path";
19769
+ tapInternalKey: string;
19770
+ } | {
19771
+ type: "p2wsh";
19772
+ witnessScript: string;
19773
+ } | {
19774
+ type: "p2tr-script-path";
19775
+ tapLeafScript: {
19776
+ script: string;
19777
+ controlBlock: string;
19778
+ }[];
19779
+ } | undefined;
19780
+ stacksMultisig?: {
19781
+ hashMode: "P2SHNonSequential";
19782
+ threshold: number;
19783
+ publicKeys: string[];
19784
+ } | undefined;
19785
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>, undefined>;
17456
19786
  }, undefined>;
17457
19787
  type NetworkChangeEventV2 = v.InferOutput<typeof networkChangeSchema>;
17458
19788
  declare const disconnectEventName = "disconnect";
@@ -17493,6 +19823,11 @@ declare const walletEventSchema: v.VariantSchema<"type", [v.ObjectSchema<{
17493
19823
  controlBlock: string;
17494
19824
  }[], 1, undefined>]>;
17495
19825
  }, undefined>], undefined>, undefined>;
19826
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
19827
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
19828
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
19829
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
19830
+ }, undefined>, undefined>;
17496
19831
  }, undefined>, v.CheckAction<{
17497
19832
  address: string;
17498
19833
  publicKey: string;
@@ -17518,6 +19853,11 @@ declare const walletEventSchema: v.VariantSchema<"type", [v.ObjectSchema<{
17518
19853
  controlBlock: string;
17519
19854
  }[];
17520
19855
  } | undefined;
19856
+ stacksMultisig?: {
19857
+ hashMode: "P2SHNonSequential";
19858
+ threshold: number;
19859
+ publicKeys: string[];
19860
+ } | undefined;
17521
19861
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
17522
19862
  address: string;
17523
19863
  publicKey: string;
@@ -17543,7 +19883,42 @@ declare const walletEventSchema: v.VariantSchema<"type", [v.ObjectSchema<{
17543
19883
  controlBlock: string;
17544
19884
  }[];
17545
19885
  } | undefined;
17546
- }, "unlockDefinition type does not match addressType">]>, undefined>, undefined>;
19886
+ stacksMultisig?: {
19887
+ hashMode: "P2SHNonSequential";
19888
+ threshold: number;
19889
+ publicKeys: string[];
19890
+ } | undefined;
19891
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
19892
+ address: string;
19893
+ publicKey: string;
19894
+ purpose: AddressPurpose;
19895
+ addressType: AddressType;
19896
+ walletType: "software" | "ledger" | "keystone" | "multisig";
19897
+ scriptPubKey?: string | undefined;
19898
+ unlockDefinition?: {
19899
+ type: "p2wpkh";
19900
+ } | {
19901
+ type: "p2sh-p2wpkh";
19902
+ redeemScript: string;
19903
+ } | {
19904
+ type: "p2tr-key-path";
19905
+ tapInternalKey: string;
19906
+ } | {
19907
+ type: "p2wsh";
19908
+ witnessScript: string;
19909
+ } | {
19910
+ type: "p2tr-script-path";
19911
+ tapLeafScript: {
19912
+ script: string;
19913
+ controlBlock: string;
19914
+ }[];
19915
+ } | undefined;
19916
+ stacksMultisig?: {
19917
+ hashMode: "P2SHNonSequential";
19918
+ threshold: number;
19919
+ publicKeys: string[];
19920
+ } | undefined;
19921
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>, undefined>;
17547
19922
  }, undefined>, v.ObjectSchema<{
17548
19923
  readonly type: v.LiteralSchema<"networkChange", undefined>;
17549
19924
  readonly bitcoin: v.ObjectSchema<{
@@ -17583,6 +19958,11 @@ declare const walletEventSchema: v.VariantSchema<"type", [v.ObjectSchema<{
17583
19958
  controlBlock: string;
17584
19959
  }[], 1, undefined>]>;
17585
19960
  }, undefined>], undefined>, undefined>;
19961
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
19962
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
19963
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
19964
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
19965
+ }, undefined>, undefined>;
17586
19966
  }, undefined>, v.CheckAction<{
17587
19967
  address: string;
17588
19968
  publicKey: string;
@@ -17608,6 +19988,11 @@ declare const walletEventSchema: v.VariantSchema<"type", [v.ObjectSchema<{
17608
19988
  controlBlock: string;
17609
19989
  }[];
17610
19990
  } | undefined;
19991
+ stacksMultisig?: {
19992
+ hashMode: "P2SHNonSequential";
19993
+ threshold: number;
19994
+ publicKeys: string[];
19995
+ } | undefined;
17611
19996
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
17612
19997
  address: string;
17613
19998
  publicKey: string;
@@ -17633,7 +20018,42 @@ declare const walletEventSchema: v.VariantSchema<"type", [v.ObjectSchema<{
17633
20018
  controlBlock: string;
17634
20019
  }[];
17635
20020
  } | undefined;
17636
- }, "unlockDefinition type does not match addressType">]>, undefined>, undefined>;
20021
+ stacksMultisig?: {
20022
+ hashMode: "P2SHNonSequential";
20023
+ threshold: number;
20024
+ publicKeys: string[];
20025
+ } | undefined;
20026
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
20027
+ address: string;
20028
+ publicKey: string;
20029
+ purpose: AddressPurpose;
20030
+ addressType: AddressType;
20031
+ walletType: "software" | "ledger" | "keystone" | "multisig";
20032
+ scriptPubKey?: string | undefined;
20033
+ unlockDefinition?: {
20034
+ type: "p2wpkh";
20035
+ } | {
20036
+ type: "p2sh-p2wpkh";
20037
+ redeemScript: string;
20038
+ } | {
20039
+ type: "p2tr-key-path";
20040
+ tapInternalKey: string;
20041
+ } | {
20042
+ type: "p2wsh";
20043
+ witnessScript: string;
20044
+ } | {
20045
+ type: "p2tr-script-path";
20046
+ tapLeafScript: {
20047
+ script: string;
20048
+ controlBlock: string;
20049
+ }[];
20050
+ } | undefined;
20051
+ stacksMultisig?: {
20052
+ hashMode: "P2SHNonSequential";
20053
+ threshold: number;
20054
+ publicKeys: string[];
20055
+ } | undefined;
20056
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>, undefined>;
17637
20057
  }, undefined>, v.ObjectSchema<{
17638
20058
  readonly type: v.LiteralSchema<"disconnect", undefined>;
17639
20059
  }, undefined>], undefined>;
@@ -17729,4 +20149,4 @@ declare class BaseAdapter extends SatsConnectAdapter {
17729
20149
  declare const DefaultAdaptersInfo: Record<string, Provider>;
17730
20150
  declare const defaultAdapters: Record<string, new () => SatsConnectAdapter>;
17731
20151
  //#endregion
17732
- export { AccountChangeCallback, AccountChangeEvent, AddListener, Address, AddressPurpose, AddressType, type AllResolvedNetworks, BaseAdapter, BitcoinGetAccountsParams, BitcoinGetAccountsRequest, BitcoinGetAccountsResult, BitcoinGetAccountsSuccessResponse, BitcoinGetAddressesParams, BitcoinGetAddressesRequest, BitcoinGetAddressesResult, BitcoinGetAddressesSuccessResponse, BitcoinGetAddressesV2Params, BitcoinGetAddressesV2Request, BitcoinGetAddressesV2Result, BitcoinGetAddressesV2SuccessResponse, BitcoinGetBalanceParams, BitcoinGetBalanceRequest, BitcoinGetBalanceResult, BitcoinGetBalanceSuccessResponse, BitcoinGetBalanceV2Params, BitcoinGetBalanceV2Request, BitcoinGetBalanceV2Result, BitcoinGetBalanceV2SuccessResponse, BitcoinGetInfoParams, BitcoinGetInfoRequest, BitcoinGetInfoResult, BitcoinGetInfoSuccessResponse, BitcoinMethod, BitcoinNetwork, type BitcoinNetworkConfigurationOptions, BitcoinNetworkType, BitcoinProvider, BitcoinRequests, BitcoinSendTransferParams, BitcoinSendTransferRequest, BitcoinSendTransferResult, BitcoinSendTransferSuccessResponse, BitcoinSendTransferV2Params, BitcoinSendTransferV2Request, BitcoinSendTransferV2Result, BitcoinSendTransferV2SuccessResponse, BitcoinSignMessageParams, BitcoinSignMessageRequest, BitcoinSignMessageResult, BitcoinSignMessageSuccessResponse, BitcoinSignMessageV2Params, BitcoinSignMessageV2Request, BitcoinSignMessageV2Result, BitcoinSignMessageV2SuccessResponse, BitcoinSignMultipleMessagesParams, BitcoinSignMultipleMessagesRequest, BitcoinSignMultipleMessagesResult, BitcoinSignMultipleMessagesSuccessResponse, BitcoinSignMultipleMessagesV2Params, BitcoinSignMultipleMessagesV2Request, BitcoinSignMultipleMessagesV2Result, BitcoinSignMultipleMessagesV2SuccessResponse, BitcoinSignPsbtParams, BitcoinSignPsbtRequest, BitcoinSignPsbtResult, BitcoinSignPsbtSuccessResponse, BitcoinSignPsbtV2Params, BitcoinSignPsbtV2Request, BitcoinSignPsbtV2Result, BitcoinSignPsbtV2SuccessResponse, BitcoinSuccessResponses, Capability, CreateInscriptionOptions, CreateInscriptionPayload, CreateInscriptionResponse, CreateRepeatInscriptionsOptions, CreateRepeatInscriptionsPayload, CreateRepeatInscriptionsResponse, DefaultAdaptersInfo, DisconnectCallback, DisconnectEvent, GetAddressOptions, GetAddressPayload, GetAddressResponse, GetCapabilitiesOptions, GetCapabilitiesPayload, GetCapabilitiesResponse, InputToSign, ListenerInfo, MessageSigningProtocols, Method, NetworkChangeCallback, NetworkChangeEvent, NetworkChangeEventV2, type NetworkConfigurationOptions, OrdinalsGetInscriptionsParams, OrdinalsGetInscriptionsRequest, OrdinalsGetInscriptionsResult, OrdinalsGetInscriptionsSuccessResponse, OrdinalsMethod, OrdinalsRequests, OrdinalsSendInscriptionsParams, OrdinalsSendInscriptionsRequest, OrdinalsSendInscriptionsResult, OrdinalsSendInscriptionsSuccessResponse, OrdinalsSuccessResponses, type PermissionWithoutClientId, Provider, ProviderPlatform, PsbtPayload, Recipient, RequestOptions, RequestPayload, RequestReturn, RpcErrorCode, RpcId, RpcRequest, RpcRequestParams, RpcRequests, RpcSuccessResponse, RpcSuccessResponseResult, RpcSuccessResponses, RunesEstimateEtchParams, RunesEstimateEtchRequest, RunesEstimateEtchResult, RunesEstimateEtchSuccessResponse, RunesEstimateMintParams, RunesEstimateMintRequest, RunesEstimateMintResult, RunesEstimateMintSuccessResponse, RunesEstimateRbfOrderParams, RunesEstimateRbfOrderRequest, RunesEstimateRbfOrderResult, RunesEstimateRbfOrderSuccessResponse, RunesEtchParams, RunesEtchRequest, RunesEtchResult, RunesEtchSuccessResponse, RunesGetBalanceParams, RunesGetBalanceRequest, RunesGetBalanceResult, RunesGetBalanceSuccessResponse, RunesGetOrderParams, RunesGetOrderRequest, RunesGetOrderResult, RunesGetOrderSuccessResponse, RunesMethod, RunesMintParams, RunesMintRequest, RunesMintResult, RunesMintSuccessResponse, RunesRbfOrderParams, RunesRbfOrderRequest, RunesRbfOrderResult, RunesRbfOrderSuccessResponse, RunesRequests, RunesSuccessResponses, RunesTransferParams, RunesTransferRequest, RunesTransferResult, RunesTransferSuccessResponse, SatsConnectAdapter, SendBtcTransactionOptions, SendBtcTransactionPayload, SendBtcTransactionResponse, SerializedRecipient, SerializedSendBtcTransactionPayload, SignMessageOptions, SignMessagePayload, SignMessageResponse, SignMultiplePsbtPayload, SignMultipleTransactionOptions, SignMultipleTransactionsPayload, SignMultipleTransactionsResponse, SignTransactionOptions, SignTransactionPayload, SignTransactionResponse, SparkFlashnetClawbackFundsParams, SparkFlashnetClawbackFundsRequest, SparkFlashnetClawbackFundsResult, SparkFlashnetClawbackFundsSuccessResponse, SparkFlashnetExecuteRouteSwapParams, SparkFlashnetExecuteRouteSwapRequest, SparkFlashnetExecuteRouteSwapResult, SparkFlashnetExecuteRouteSwapSuccessResponse, SparkFlashnetExecuteSwapParams, SparkFlashnetExecuteSwapRequest, SparkFlashnetExecuteSwapResult, SparkFlashnetExecuteSwapSuccessResponse, SparkFlashnetGetJwtParams, SparkFlashnetGetJwtRequest, SparkFlashnetGetJwtResult, SparkFlashnetGetJwtSuccessResponse, SparkFlashnetSignIntentParams, SparkFlashnetSignIntentRequest, SparkFlashnetSignIntentResult, SparkFlashnetSignIntentSuccessResponse, SparkFlashnetSignStructuredMessageParams, SparkFlashnetSignStructuredMessageRequest, SparkFlashnetSignStructuredMessageResult, SparkFlashnetSignStructuredMessageSuccessResponse, SparkGetAddressesParams, SparkGetAddressesRequest, SparkGetAddressesResult, SparkGetAddressesSuccessResponse, SparkGetAddressesV2Params, SparkGetAddressesV2Request, SparkGetAddressesV2Result, SparkGetAddressesV2SuccessResponse, SparkGetBalanceParams, SparkGetBalanceRequest, SparkGetBalanceResult, SparkGetBalanceSuccessResponse, SparkGetClawbackEligibleTransfersParams, SparkGetClawbackEligibleTransfersRequest, SparkGetClawbackEligibleTransfersResult, SparkGetClawbackEligibleTransfersSuccessResponse, SparkMethod, type SparkNetworkConfigurationOptions, SparkNetworkType, SparkRequests, SparkSignMessageParams, SparkSignMessageRequest, SparkSignMessageResult, SparkSignMessageSuccessResponse, SparkSuccessResponses, SparkTransferParams, SparkTransferRequest, SparkTransferResult, SparkTransferSuccessResponse, SparkTransferTokenParams, SparkTransferTokenRequest, SparkTransferTokenResult, SparkTransferTokenSuccessResponse, SpecErrorObject, SpecErrorResponse, SpecId, SpecRequest, SpecResponse, SpecSuccessResponse, SpecSuccessWithExtensionsResponse, StacksCallContractParams, StacksCallContractRequest, StacksCallContractResult, StacksCallContractSuccessResponse, StacksDeployContractParams, StacksDeployContractRequest, StacksDeployContractResult, StacksDeployContractSuccessResponse, StacksGetAccountsParams, StacksGetAccountsRequest, StacksGetAccountsResult, StacksGetAccountsSuccessResponse, StacksGetAddressesParams, StacksGetAddressesRequest, StacksGetAddressesResult, StacksGetAddressesSuccessResponse, StacksMethod, type StacksNetworkConfigurationOptions, StacksNetworkType, StacksRequests, StacksSignMessageParams, StacksSignMessageRequest, StacksSignMessageResult, StacksSignMessageSuccessResponse, StacksSignStructuredMessageParams, StacksSignStructuredMessageRequest, StacksSignStructuredMessageResult, StacksSignStructuredMessageSuccessResponse, StacksSignTransactionParams, StacksSignTransactionRequest, StacksSignTransactionResult, StacksSignTransactionSuccessResponse, StacksSignTransactionsParams, StacksSignTransactionsRequest, StacksSignTransactionsResult, StacksSignTransactionsSuccessResponse, StacksSuccessResponses, StacksTransferStxParams, StacksTransferStxRequest, StacksTransferStxResult, StacksTransferStxSuccessResponse, type StarknetNetworkConfigurationOptions, StarknetNetworkType, SupportState, SupportedWallet, UnlockDefinition, WalletAddNetworkParams, WalletAddNetworkRequest, WalletAddNetworkResult, WalletAddNetworkSuccessResponse, WalletAddNetworkV2Params, WalletAddNetworkV2Request, WalletAddNetworkV2Result, WalletAddNetworkV2SuccessResponse, WalletChangeNetworkParams, WalletChangeNetworkRequest, WalletChangeNetworkResult, WalletChangeNetworkSuccessResponse, WalletConnectParams, WalletConnectRequest, WalletConnectResult, WalletConnectSuccessResponse, WalletConnectV2Params, WalletConnectV2Request, WalletConnectV2Result, WalletConnectV2SuccessResponse, WalletDisconnectParams, WalletDisconnectRequest, WalletDisconnectResult, WalletDisconnectSuccessResponse, WalletEvent, WalletGetAccountParams, WalletGetAccountRequest, WalletGetAccountResult, WalletGetAccountSuccessResponse, WalletGetAccountV2Params, WalletGetAccountV2Request, WalletGetAccountV2Result, WalletGetAccountV2SuccessResponse, WalletGetCurrentPermissionsParams, WalletGetCurrentPermissionsRequest, WalletGetCurrentPermissionsResult, WalletGetCurrentPermissionsSuccessResponse, WalletGetNetworkParams, WalletGetNetworkRequest, WalletGetNetworkResult, WalletGetNetworkSuccessResponse, WalletGetNetworksParams, WalletGetNetworksRequest, WalletGetNetworksResult, WalletGetNetworksSuccessResponse, WalletGetWalletTypeParams, WalletGetWalletTypeRequest, WalletGetWalletTypeResult, WalletGetWalletTypeSuccessResponse, WalletMethod, WalletOpenBridgeParams, WalletOpenBridgeRequest, WalletOpenBridgeResult, WalletOpenBridgeSuccessResponse, WalletOpenBuyParams, WalletOpenBuyRequest, WalletOpenBuyResult, WalletOpenBuySuccessResponse, WalletOpenParams, WalletOpenReceiveParams, WalletOpenReceiveRequest, WalletOpenReceiveResult, WalletOpenReceiveSuccessResponse, WalletOpenRequest, WalletOpenResult, WalletOpenSuccessResponse, WalletRenouncePermissionsParams, WalletRenouncePermissionsRequest, WalletRenouncePermissionsResult, WalletRenouncePermissionsSuccessResponse, WalletRequestPermissionsParams, WalletRequestPermissionsRequest, WalletRequestPermissionsResult, WalletRequestPermissionsSuccessResponse, WalletRequests, WalletSuccessResponses, WalletSwitchNetworkParams, WalletSwitchNetworkRequest, WalletSwitchNetworkResult, WalletSwitchNetworkSuccessResponse, WalletType, Warning, accountChangeEventName, accountChangeSchema, addListener, addressSchema, allResolvedNetworksSchema, bitcoinGetAccountsParamsSchema, bitcoinGetAccountsRequestSchema, bitcoinGetAccountsResultSchema, bitcoinGetAccountsSuccessResponseSchema, bitcoinGetAddressesParamsSchema, bitcoinGetAddressesRequestSchema, bitcoinGetAddressesResultSchema, bitcoinGetAddressesSuccessResponseSchema, bitcoinGetAddressesV2ParamsSchema, bitcoinGetAddressesV2RequestSchema, bitcoinGetAddressesV2ResultSchema, bitcoinGetAddressesV2SuccessResponseSchema, bitcoinGetBalanceParamsSchema, bitcoinGetBalanceRequestSchema, bitcoinGetBalanceResultSchema, bitcoinGetBalanceSuccessResponseSchema, bitcoinGetBalanceV2ParamsSchema, bitcoinGetBalanceV2RequestSchema, bitcoinGetBalanceV2ResultSchema, bitcoinGetBalanceV2SuccessResponseSchema, bitcoinGetInfoParamsSchema, bitcoinGetInfoRequestSchema, bitcoinGetInfoResultSchema, bitcoinGetInfoSuccessResponseSchema, bitcoinMethods, bitcoinModeToLegacyBitcoinNetworkType, bitcoinNetworkConfigurationOptionsSchema, bitcoinRequestSchema, bitcoinSendTransferParamsSchema, bitcoinSendTransferRequestSchema, bitcoinSendTransferResultSchema, bitcoinSendTransferSuccessResponseSchema, bitcoinSendTransferV2ParamsSchema, bitcoinSendTransferV2RequestSchema, bitcoinSendTransferV2ResultSchema, bitcoinSendTransferV2SuccessResponseSchema, bitcoinSignMessageParamsSchema, bitcoinSignMessageRequestSchema, bitcoinSignMessageResultSchema, bitcoinSignMessageSuccessResponseSchema, bitcoinSignMessageV2ParamsSchema, bitcoinSignMessageV2RequestSchema, bitcoinSignMessageV2ResultSchema, bitcoinSignMessageV2SuccessResponseSchema, bitcoinSignMultipleMessagesParamsSchema, bitcoinSignMultipleMessagesRequestSchema, bitcoinSignMultipleMessagesResultSchema, bitcoinSignMultipleMessagesSuccessResponseSchema, bitcoinSignMultipleMessagesV2ParamsSchema, bitcoinSignMultipleMessagesV2RequestSchema, bitcoinSignMultipleMessagesV2ResultSchema, bitcoinSignMultipleMessagesV2SuccessResponseSchema, bitcoinSignPsbtParamsSchema, bitcoinSignPsbtRequestSchema, bitcoinSignPsbtResultSchema, bitcoinSignPsbtSuccessResponseSchema, bitcoinSignPsbtV2ParamsSchema, bitcoinSignPsbtV2RequestSchema, bitcoinSignPsbtV2ResultSchema, bitcoinSignPsbtV2SuccessResponseSchema, bitcoinSuccessResponseSchema, createInscription, createRepeatInscriptions, createRpcRequest, createRpcSuccessResponse, defaultAdapters, defineMethodSupport, disconnectEventName, disconnectSchema, getAddress, getCapabilities, getDefaultProvider, getProviderById, getProviderOrThrow, getProviders, getSupportedWallets, isProviderInstalled, methods, networkChangeEventName, networkChangeEventNameV2, networkChangeSchema, networkChangeV2Schema, networkConfigurationOptionsSchema, ordinalsGetInscriptionsParamsSchema, ordinalsGetInscriptionsRequestSchema, ordinalsGetInscriptionsResultSchema, ordinalsGetInscriptionsSuccessResponseSchema, ordinalsMethods, ordinalsRequestSchema, ordinalsSendInscriptionsParamsSchema, ordinalsSendInscriptionsRequestSchema, ordinalsSendInscriptionsResultSchema, ordinalsSendInscriptionsSuccessResponseSchema, ordinalsSuccessResponseSchema, permissionRequestParamsSchema, removeDefaultProvider, request, rpcIdSchema, rpcRequestSchema, rpcSuccessResponseSchema, runesEstimateEtchParamsSchema, runesEstimateEtchRequestSchema, runesEstimateEtchResultSchema, runesEstimateEtchSuccessResponseSchema, runesEstimateMintParamsSchema, runesEstimateMintRequestSchema, runesEstimateMintResultSchema, runesEstimateMintSuccessResponseSchema, runesEstimateRbfOrderParamsSchema, runesEstimateRbfOrderRequestSchema, runesEstimateRbfOrderResultSchema, runesEstimateRbfOrderSuccessResponseSchema, runesEtchParamsSchema, runesEtchRequestSchema, runesEtchResultSchema, runesEtchSuccessResponseSchema, runesGetBalanceParamsSchema, runesGetBalanceRequestSchema, runesGetBalanceResultSchema, runesGetBalanceSuccessResponseSchema, runesGetOrderParamsSchema, runesGetOrderRequestSchema, runesGetOrderResultSchema, runesGetOrderSuccessResponseSchema, runesMethods, runesMintParamsSchema, runesMintRequestSchema, runesMintResultSchema, runesMintSuccessResponseSchema, runesRbfOrderParamsSchema, runesRbfOrderRequestSchema, runesRbfOrderResultSchema, runesRbfOrderSuccessResponseSchema, runesRequestSchema, runesSuccessResponseSchema, runesTransferParamsSchema, runesTransferRequestSchema, runesTransferResultSchema, runesTransferSuccessResponseSchema, sendBtcTransaction, setDefaultProvider, signMessage, signMultipleTransactions, signTransaction, sparkFlashnetClawbackFundsParamsSchema, sparkFlashnetClawbackFundsRequestSchema, sparkFlashnetClawbackFundsResultSchema, sparkFlashnetClawbackFundsSuccessResponseSchema, sparkFlashnetExecuteRouteSwapParamsSchema, sparkFlashnetExecuteRouteSwapRequestSchema, sparkFlashnetExecuteRouteSwapResultSchema, sparkFlashnetExecuteRouteSwapSuccessResponseSchema, sparkFlashnetExecuteSwapParamsSchema, sparkFlashnetExecuteSwapRequestSchema, sparkFlashnetExecuteSwapResultSchema, sparkFlashnetExecuteSwapSuccessResponseSchema, sparkFlashnetGetJwtParamsSchema, sparkFlashnetGetJwtRequestSchema, sparkFlashnetGetJwtResultSchema, sparkFlashnetGetJwtSuccessResponseSchema, sparkFlashnetSignIntentParamsSchema, sparkFlashnetSignIntentRequestSchema, sparkFlashnetSignIntentResultSchema, sparkFlashnetSignIntentSuccessResponseSchema, sparkFlashnetSignStructuredMessageParamsSchema, sparkFlashnetSignStructuredMessageRequestSchema, sparkFlashnetSignStructuredMessageResultSchema, sparkFlashnetSignStructuredMessageSuccessResponseSchema, sparkGetAddressesParamsSchema, sparkGetAddressesRequestSchema, sparkGetAddressesResultSchema, sparkGetAddressesSuccessResponseSchema, sparkGetAddressesV2ParamsSchema, sparkGetAddressesV2RequestSchema, sparkGetAddressesV2ResultSchema, sparkGetAddressesV2SuccessResponseSchema, sparkGetBalanceParamsSchema, sparkGetBalanceRequestSchema, sparkGetBalanceResultSchema, sparkGetBalanceSuccessResponseSchema, sparkGetClawbackEligibleTransfersParamsSchema, sparkGetClawbackEligibleTransfersRequestSchema, sparkGetClawbackEligibleTransfersResultSchema, sparkGetClawbackEligibleTransfersSuccessResponseSchema, sparkMethods, sparkModeToLegacySparkNetworkType, sparkNetworkConfigurationOptionsSchema, sparkRequestSchema, sparkSignMessageParamsSchema, sparkSignMessageRequestSchema, sparkSignMessageResultSchema, sparkSignMessageSuccessResponseSchema, sparkSuccessResponseSchema, sparkTransferParamsSchema, sparkTransferRequestSchema, sparkTransferResultSchema, sparkTransferSuccessResponseSchema, sparkTransferTokenParamsSchema, sparkTransferTokenRequestSchema, sparkTransferTokenResultSchema, sparkTransferTokenSuccessResponseSchema, specErrorObjectSchema, specErrorResponseSchema, specIdSchema, specRequestSchema, specResponseSchema, specSuccessResponseSchema, specSuccessWithExtensionsResponseSchema, stacksCallContractParamsSchema, stacksCallContractRequestSchema, stacksCallContractResultSchema, stacksCallContractSuccessResponseSchema, stacksDeployContractParamsSchema, stacksDeployContractRequestSchema, stacksDeployContractResultSchema, stacksDeployContractSuccessResponseSchema, stacksGetAccountsParamsSchema, stacksGetAccountsRequestSchema, stacksGetAccountsResultSchema, stacksGetAccountsSuccessResponseSchema, stacksGetAddressesParamsSchema, stacksGetAddressesRequestSchema, stacksGetAddressesResultSchema, stacksGetAddressesSuccessResponseSchema, stacksMethods, stacksModeToLegacyStacksNetworkType, stacksNetworkConfigurationOptionsSchema, stacksRequestSchema, stacksSignMessageParamsSchema, stacksSignMessageRequestSchema, stacksSignMessageResultSchema, stacksSignMessageSuccessResponseSchema, stacksSignStructuredMessageParamsSchema, stacksSignStructuredMessageRequestSchema, stacksSignStructuredMessageResultSchema, stacksSignStructuredMessageSuccessResponseSchema, stacksSignTransactionParamsSchema, stacksSignTransactionRequestSchema, stacksSignTransactionResultSchema, stacksSignTransactionSuccessResponseSchema, stacksSignTransactionsParamsSchema, stacksSignTransactionsRequestSchema, stacksSignTransactionsResultSchema, stacksSignTransactionsSuccessResponseSchema, stacksSuccessResponseSchema, stacksTransferStxParamsSchema, stacksTransferStxRequestSchema, stacksTransferStxResultSchema, stacksTransferStxSuccessResponseSchema, starknetNetworkConfigurationOptionsSchema, supportStates, unlockDefinitionSchema, walletAddNetworkParamsSchema, walletAddNetworkRequestSchema, walletAddNetworkResultSchema, walletAddNetworkSuccessResponseSchema, walletAddNetworkV2ParamsSchema, walletAddNetworkV2RequestSchema, walletAddNetworkV2ResultSchema, walletAddNetworkV2SuccessResponseSchema, walletChangeNetworkParamsSchema, walletChangeNetworkRequestSchema, walletChangeNetworkResultSchema, walletChangeNetworkSuccessResponseSchema, walletConnectParamsSchema, walletConnectRequestSchema, walletConnectResultSchema, walletConnectSuccessResponseSchema, walletConnectV2ParamsSchema, walletConnectV2RequestSchema, walletConnectV2ResultSchema, walletConnectV2SuccessResponseSchema, walletDisconnectParamsSchema, walletDisconnectRequestSchema, walletDisconnectResultSchema, walletDisconnectSuccessResponseSchema, walletEventSchema, walletGetAccountParamsSchema, walletGetAccountRequestSchema, walletGetAccountResultSchema, walletGetAccountSuccessResponseSchema, walletGetAccountV2ParamsSchema, walletGetAccountV2RequestSchema, walletGetAccountV2ResultSchema, walletGetAccountV2SuccessResponseSchema, walletGetCurrentPermissionsParamsSchema, walletGetCurrentPermissionsRequestSchema, walletGetCurrentPermissionsResultSchema, walletGetCurrentPermissionsSuccessResponseSchema, walletGetNetworkParamsSchema, walletGetNetworkRequestSchema, walletGetNetworkResultSchema, walletGetNetworkSuccessResponseSchema, walletGetNetworksParamsSchema, walletGetNetworksRequestSchema, walletGetNetworksResultSchema, walletGetNetworksSuccessResponseSchema, walletGetWalletTypeParamsSchema, walletGetWalletTypeRequestSchema, walletGetWalletTypeResultSchema, walletGetWalletTypeSuccessResponseSchema, walletMethods, walletOpenBridgeParamsSchema, walletOpenBridgeRequestSchema, walletOpenBridgeResultSchema, walletOpenBridgeSuccessResponseSchema, walletOpenBuyParamsSchema, walletOpenBuyRequestSchema, walletOpenBuyResultSchema, walletOpenBuySuccessResponseSchema, walletOpenParamsSchema, walletOpenReceiveParamsSchema, walletOpenReceiveRequestSchema, walletOpenReceiveResultSchema, walletOpenReceiveSuccessResponseSchema, walletOpenRequestSchema, walletOpenResultSchema, walletOpenSuccessResponseSchema, walletRenouncePermissionsParamsSchema, walletRenouncePermissionsRequestSchema, walletRenouncePermissionsResultSchema, walletRenouncePermissionsSuccessResponseSchema, walletRequestPermissionsParamsSchema, walletRequestPermissionsRequestSchema, walletRequestPermissionsResultSchema, walletRequestPermissionsSuccessResponseSchema, walletRequestSchema, walletSuccessResponseSchema, walletSwitchNetworkParamsSchema, walletSwitchNetworkRequestSchema, walletSwitchNetworkResultSchema, walletSwitchNetworkSuccessResponseSchema, walletTypeSchema, walletTypes };
20152
+ export { AccountChangeCallback, AccountChangeEvent, AddListener, Address, AddressPurpose, AddressType, type AllResolvedNetworks, BaseAdapter, BitcoinGetAccountsParams, BitcoinGetAccountsRequest, BitcoinGetAccountsResult, BitcoinGetAccountsSuccessResponse, BitcoinGetAddressesParams, BitcoinGetAddressesRequest, BitcoinGetAddressesResult, BitcoinGetAddressesSuccessResponse, BitcoinGetAddressesV2Params, BitcoinGetAddressesV2Request, BitcoinGetAddressesV2Result, BitcoinGetAddressesV2SuccessResponse, BitcoinGetBalanceParams, BitcoinGetBalanceRequest, BitcoinGetBalanceResult, BitcoinGetBalanceSuccessResponse, BitcoinGetBalanceV2Params, BitcoinGetBalanceV2Request, BitcoinGetBalanceV2Result, BitcoinGetBalanceV2SuccessResponse, BitcoinGetInfoParams, BitcoinGetInfoRequest, BitcoinGetInfoResult, BitcoinGetInfoSuccessResponse, BitcoinMethod, BitcoinNetwork, type BitcoinNetworkConfigurationOptions, BitcoinNetworkType, BitcoinProvider, BitcoinRequests, BitcoinSendTransferParams, BitcoinSendTransferRequest, BitcoinSendTransferResult, BitcoinSendTransferSuccessResponse, BitcoinSendTransferV2Params, BitcoinSendTransferV2Request, BitcoinSendTransferV2Result, BitcoinSendTransferV2SuccessResponse, BitcoinSignMessageParams, BitcoinSignMessageRequest, BitcoinSignMessageResult, BitcoinSignMessageSuccessResponse, BitcoinSignMessageV2Params, BitcoinSignMessageV2Request, BitcoinSignMessageV2Result, BitcoinSignMessageV2SuccessResponse, BitcoinSignMultipleMessagesParams, BitcoinSignMultipleMessagesRequest, BitcoinSignMultipleMessagesResult, BitcoinSignMultipleMessagesSuccessResponse, BitcoinSignMultipleMessagesV2Params, BitcoinSignMultipleMessagesV2Request, BitcoinSignMultipleMessagesV2Result, BitcoinSignMultipleMessagesV2SuccessResponse, BitcoinSignPsbtParams, BitcoinSignPsbtRequest, BitcoinSignPsbtResult, BitcoinSignPsbtSuccessResponse, BitcoinSignPsbtV2Params, BitcoinSignPsbtV2Request, BitcoinSignPsbtV2Result, BitcoinSignPsbtV2SuccessResponse, BitcoinSuccessResponses, Capability, CreateInscriptionOptions, CreateInscriptionPayload, CreateInscriptionResponse, CreateRepeatInscriptionsOptions, CreateRepeatInscriptionsPayload, CreateRepeatInscriptionsResponse, DefaultAdaptersInfo, DisconnectCallback, DisconnectEvent, GetAddressOptions, GetAddressPayload, GetAddressResponse, GetCapabilitiesOptions, GetCapabilitiesPayload, GetCapabilitiesResponse, InputToSign, ListenerInfo, MessageSigningProtocols, Method, NetworkChangeCallback, NetworkChangeEvent, NetworkChangeEventV2, type NetworkConfigurationOptions, OrdinalsGetInscriptionsParams, OrdinalsGetInscriptionsRequest, OrdinalsGetInscriptionsResult, OrdinalsGetInscriptionsSuccessResponse, OrdinalsMethod, OrdinalsRequests, OrdinalsSendInscriptionsParams, OrdinalsSendInscriptionsRequest, OrdinalsSendInscriptionsResult, OrdinalsSendInscriptionsSuccessResponse, OrdinalsSuccessResponses, type PermissionWithoutClientId, Provider, ProviderPlatform, PsbtPayload, Recipient, RequestOptions, RequestPayload, RequestReturn, RpcErrorCode, RpcId, RpcRequest, RpcRequestParams, RpcRequests, RpcSuccessResponse, RpcSuccessResponseResult, RpcSuccessResponses, RunesEstimateEtchParams, RunesEstimateEtchRequest, RunesEstimateEtchResult, RunesEstimateEtchSuccessResponse, RunesEstimateMintParams, RunesEstimateMintRequest, RunesEstimateMintResult, RunesEstimateMintSuccessResponse, RunesEstimateRbfOrderParams, RunesEstimateRbfOrderRequest, RunesEstimateRbfOrderResult, RunesEstimateRbfOrderSuccessResponse, RunesEtchParams, RunesEtchRequest, RunesEtchResult, RunesEtchSuccessResponse, RunesGetBalanceParams, RunesGetBalanceRequest, RunesGetBalanceResult, RunesGetBalanceSuccessResponse, RunesGetOrderParams, RunesGetOrderRequest, RunesGetOrderResult, RunesGetOrderSuccessResponse, RunesMethod, RunesMintParams, RunesMintRequest, RunesMintResult, RunesMintSuccessResponse, RunesRbfOrderParams, RunesRbfOrderRequest, RunesRbfOrderResult, RunesRbfOrderSuccessResponse, RunesRequests, RunesSuccessResponses, RunesTransferParams, RunesTransferRequest, RunesTransferResult, RunesTransferSuccessResponse, SatsConnectAdapter, SendBtcTransactionOptions, SendBtcTransactionPayload, SendBtcTransactionResponse, SerializedRecipient, SerializedSendBtcTransactionPayload, SignMessageOptions, SignMessagePayload, SignMessageResponse, SignMultiplePsbtPayload, SignMultipleTransactionOptions, SignMultipleTransactionsPayload, SignMultipleTransactionsResponse, SignTransactionOptions, SignTransactionPayload, SignTransactionResponse, SparkFlashnetClawbackFundsParams, SparkFlashnetClawbackFundsRequest, SparkFlashnetClawbackFundsResult, SparkFlashnetClawbackFundsSuccessResponse, SparkFlashnetExecuteRouteSwapParams, SparkFlashnetExecuteRouteSwapRequest, SparkFlashnetExecuteRouteSwapResult, SparkFlashnetExecuteRouteSwapSuccessResponse, SparkFlashnetExecuteSwapParams, SparkFlashnetExecuteSwapRequest, SparkFlashnetExecuteSwapResult, SparkFlashnetExecuteSwapSuccessResponse, SparkFlashnetGetJwtParams, SparkFlashnetGetJwtRequest, SparkFlashnetGetJwtResult, SparkFlashnetGetJwtSuccessResponse, SparkFlashnetSignIntentParams, SparkFlashnetSignIntentRequest, SparkFlashnetSignIntentResult, SparkFlashnetSignIntentSuccessResponse, SparkFlashnetSignStructuredMessageParams, SparkFlashnetSignStructuredMessageRequest, SparkFlashnetSignStructuredMessageResult, SparkFlashnetSignStructuredMessageSuccessResponse, SparkGetAddressesParams, SparkGetAddressesRequest, SparkGetAddressesResult, SparkGetAddressesSuccessResponse, SparkGetAddressesV2Params, SparkGetAddressesV2Request, SparkGetAddressesV2Result, SparkGetAddressesV2SuccessResponse, SparkGetBalanceParams, SparkGetBalanceRequest, SparkGetBalanceResult, SparkGetBalanceSuccessResponse, SparkGetClawbackEligibleTransfersParams, SparkGetClawbackEligibleTransfersRequest, SparkGetClawbackEligibleTransfersResult, SparkGetClawbackEligibleTransfersSuccessResponse, SparkMethod, type SparkNetworkConfigurationOptions, SparkNetworkType, SparkRequests, SparkSignMessageParams, SparkSignMessageRequest, SparkSignMessageResult, SparkSignMessageSuccessResponse, SparkSuccessResponses, SparkTransferParams, SparkTransferRequest, SparkTransferResult, SparkTransferSuccessResponse, SparkTransferTokenParams, SparkTransferTokenRequest, SparkTransferTokenResult, SparkTransferTokenSuccessResponse, SpecErrorObject, SpecErrorResponse, SpecId, SpecRequest, SpecResponse, SpecSuccessResponse, SpecSuccessWithExtensionsResponse, StacksAccount, StacksCallContractParams, StacksCallContractRequest, StacksCallContractResult, StacksCallContractSuccessResponse, StacksDeployContractParams, StacksDeployContractRequest, StacksDeployContractResult, StacksDeployContractSuccessResponse, StacksGetAccountsParams, StacksGetAccountsRequest, StacksGetAccountsResult, StacksGetAccountsSuccessResponse, StacksGetAddressesParams, StacksGetAddressesRequest, StacksGetAddressesResult, StacksGetAddressesSuccessResponse, StacksLegacyAccount, StacksMethod, StacksMultisig, StacksMultisigAccount, type StacksNetworkConfigurationOptions, StacksNetworkType, StacksRequests, StacksSignMessageParams, StacksSignMessageRequest, StacksSignMessageResult, StacksSignMessageSuccessResponse, StacksSignStructuredMessageParams, StacksSignStructuredMessageRequest, StacksSignStructuredMessageResult, StacksSignStructuredMessageSuccessResponse, StacksSignTransactionParams, StacksSignTransactionRequest, StacksSignTransactionResult, StacksSignTransactionSuccessResponse, StacksSignTransactionsBroadcastErrorData, StacksSignTransactionsParams, StacksSignTransactionsRequest, StacksSignTransactionsResult, StacksSignTransactionsSuccessResponse, StacksSuccessResponses, StacksTransferStxParams, StacksTransferStxRequest, StacksTransferStxResult, StacksTransferStxSuccessResponse, type StarknetNetworkConfigurationOptions, StarknetNetworkType, SupportState, SupportedWallet, UnlockDefinition, WalletAddNetworkParams, WalletAddNetworkRequest, WalletAddNetworkResult, WalletAddNetworkSuccessResponse, WalletAddNetworkV2Params, WalletAddNetworkV2Request, WalletAddNetworkV2Result, WalletAddNetworkV2SuccessResponse, WalletChangeNetworkParams, WalletChangeNetworkRequest, WalletChangeNetworkResult, WalletChangeNetworkSuccessResponse, WalletConnectParams, WalletConnectRequest, WalletConnectResult, WalletConnectSuccessResponse, WalletConnectV2Params, WalletConnectV2Request, WalletConnectV2Result, WalletConnectV2SuccessResponse, WalletDisconnectParams, WalletDisconnectRequest, WalletDisconnectResult, WalletDisconnectSuccessResponse, WalletEvent, WalletGetAccountParams, WalletGetAccountRequest, WalletGetAccountResult, WalletGetAccountSuccessResponse, WalletGetAccountV2Params, WalletGetAccountV2Request, WalletGetAccountV2Result, WalletGetAccountV2SuccessResponse, WalletGetCurrentPermissionsParams, WalletGetCurrentPermissionsRequest, WalletGetCurrentPermissionsResult, WalletGetCurrentPermissionsSuccessResponse, WalletGetNetworkParams, WalletGetNetworkRequest, WalletGetNetworkResult, WalletGetNetworkSuccessResponse, WalletGetNetworksParams, WalletGetNetworksRequest, WalletGetNetworksResult, WalletGetNetworksSuccessResponse, WalletGetWalletTypeParams, WalletGetWalletTypeRequest, WalletGetWalletTypeResult, WalletGetWalletTypeSuccessResponse, WalletMethod, WalletOpenBridgeParams, WalletOpenBridgeRequest, WalletOpenBridgeResult, WalletOpenBridgeSuccessResponse, WalletOpenBuyParams, WalletOpenBuyRequest, WalletOpenBuyResult, WalletOpenBuySuccessResponse, WalletOpenParams, WalletOpenReceiveParams, WalletOpenReceiveRequest, WalletOpenReceiveResult, WalletOpenReceiveSuccessResponse, WalletOpenRequest, WalletOpenResult, WalletOpenSuccessResponse, WalletRenouncePermissionsParams, WalletRenouncePermissionsRequest, WalletRenouncePermissionsResult, WalletRenouncePermissionsSuccessResponse, WalletRequestPermissionsParams, WalletRequestPermissionsRequest, WalletRequestPermissionsResult, WalletRequestPermissionsSuccessResponse, WalletRequests, WalletSuccessResponses, WalletSwitchNetworkParams, WalletSwitchNetworkRequest, WalletSwitchNetworkResult, WalletSwitchNetworkSuccessResponse, WalletType, Warning, accountChangeEventName, accountChangeSchema, addListener, addressObjectSchema, addressSchema, allResolvedNetworksSchema, bitcoinGetAccountsParamsSchema, bitcoinGetAccountsRequestSchema, bitcoinGetAccountsResultSchema, bitcoinGetAccountsSuccessResponseSchema, bitcoinGetAddressesParamsSchema, bitcoinGetAddressesRequestSchema, bitcoinGetAddressesResultSchema, bitcoinGetAddressesSuccessResponseSchema, bitcoinGetAddressesV2ParamsSchema, bitcoinGetAddressesV2RequestSchema, bitcoinGetAddressesV2ResultSchema, bitcoinGetAddressesV2SuccessResponseSchema, bitcoinGetBalanceParamsSchema, bitcoinGetBalanceRequestSchema, bitcoinGetBalanceResultSchema, bitcoinGetBalanceSuccessResponseSchema, bitcoinGetBalanceV2ParamsSchema, bitcoinGetBalanceV2RequestSchema, bitcoinGetBalanceV2ResultSchema, bitcoinGetBalanceV2SuccessResponseSchema, bitcoinGetInfoParamsSchema, bitcoinGetInfoRequestSchema, bitcoinGetInfoResultSchema, bitcoinGetInfoSuccessResponseSchema, bitcoinMethods, bitcoinModeToLegacyBitcoinNetworkType, bitcoinNetworkConfigurationOptionsSchema, bitcoinRequestSchema, bitcoinSendTransferParamsSchema, bitcoinSendTransferRequestSchema, bitcoinSendTransferResultSchema, bitcoinSendTransferSuccessResponseSchema, bitcoinSendTransferV2ParamsSchema, bitcoinSendTransferV2RequestSchema, bitcoinSendTransferV2ResultSchema, bitcoinSendTransferV2SuccessResponseSchema, bitcoinSignMessageParamsSchema, bitcoinSignMessageRequestSchema, bitcoinSignMessageResultSchema, bitcoinSignMessageSuccessResponseSchema, bitcoinSignMessageV2ParamsSchema, bitcoinSignMessageV2RequestSchema, bitcoinSignMessageV2ResultSchema, bitcoinSignMessageV2SuccessResponseSchema, bitcoinSignMultipleMessagesParamsSchema, bitcoinSignMultipleMessagesRequestSchema, bitcoinSignMultipleMessagesResultSchema, bitcoinSignMultipleMessagesSuccessResponseSchema, bitcoinSignMultipleMessagesV2ParamsSchema, bitcoinSignMultipleMessagesV2RequestSchema, bitcoinSignMultipleMessagesV2ResultSchema, bitcoinSignMultipleMessagesV2SuccessResponseSchema, bitcoinSignPsbtParamsSchema, bitcoinSignPsbtRequestSchema, bitcoinSignPsbtResultSchema, bitcoinSignPsbtSuccessResponseSchema, bitcoinSignPsbtV2ParamsSchema, bitcoinSignPsbtV2RequestSchema, bitcoinSignPsbtV2ResultSchema, bitcoinSignPsbtV2SuccessResponseSchema, bitcoinSuccessResponseSchema, createInscription, createRepeatInscriptions, createRpcRequest, createRpcSuccessResponse, defaultAdapters, defineMethodSupport, disconnectEventName, disconnectSchema, getAddress, getCapabilities, getDefaultProvider, getProviderById, getProviderOrThrow, getProviders, getSupportedWallets, isProviderInstalled, methods, networkChangeEventName, networkChangeEventNameV2, networkChangeSchema, networkChangeV2Schema, networkConfigurationOptionsSchema, ordinalsGetInscriptionsParamsSchema, ordinalsGetInscriptionsRequestSchema, ordinalsGetInscriptionsResultSchema, ordinalsGetInscriptionsSuccessResponseSchema, ordinalsMethods, ordinalsRequestSchema, ordinalsSendInscriptionsParamsSchema, ordinalsSendInscriptionsRequestSchema, ordinalsSendInscriptionsResultSchema, ordinalsSendInscriptionsSuccessResponseSchema, ordinalsSuccessResponseSchema, permissionRequestParamsSchema, removeDefaultProvider, request, rpcIdSchema, rpcRequestSchema, rpcSuccessResponseSchema, runesEstimateEtchParamsSchema, runesEstimateEtchRequestSchema, runesEstimateEtchResultSchema, runesEstimateEtchSuccessResponseSchema, runesEstimateMintParamsSchema, runesEstimateMintRequestSchema, runesEstimateMintResultSchema, runesEstimateMintSuccessResponseSchema, runesEstimateRbfOrderParamsSchema, runesEstimateRbfOrderRequestSchema, runesEstimateRbfOrderResultSchema, runesEstimateRbfOrderSuccessResponseSchema, runesEtchParamsSchema, runesEtchRequestSchema, runesEtchResultSchema, runesEtchSuccessResponseSchema, runesGetBalanceParamsSchema, runesGetBalanceRequestSchema, runesGetBalanceResultSchema, runesGetBalanceSuccessResponseSchema, runesGetOrderParamsSchema, runesGetOrderRequestSchema, runesGetOrderResultSchema, runesGetOrderSuccessResponseSchema, runesMethods, runesMintParamsSchema, runesMintRequestSchema, runesMintResultSchema, runesMintSuccessResponseSchema, runesRbfOrderParamsSchema, runesRbfOrderRequestSchema, runesRbfOrderResultSchema, runesRbfOrderSuccessResponseSchema, runesRequestSchema, runesSuccessResponseSchema, runesTransferParamsSchema, runesTransferRequestSchema, runesTransferResultSchema, runesTransferSuccessResponseSchema, sendBtcTransaction, setDefaultProvider, signMessage, signMultipleTransactions, signTransaction, sparkFlashnetClawbackFundsParamsSchema, sparkFlashnetClawbackFundsRequestSchema, sparkFlashnetClawbackFundsResultSchema, sparkFlashnetClawbackFundsSuccessResponseSchema, sparkFlashnetExecuteRouteSwapParamsSchema, sparkFlashnetExecuteRouteSwapRequestSchema, sparkFlashnetExecuteRouteSwapResultSchema, sparkFlashnetExecuteRouteSwapSuccessResponseSchema, sparkFlashnetExecuteSwapParamsSchema, sparkFlashnetExecuteSwapRequestSchema, sparkFlashnetExecuteSwapResultSchema, sparkFlashnetExecuteSwapSuccessResponseSchema, sparkFlashnetGetJwtParamsSchema, sparkFlashnetGetJwtRequestSchema, sparkFlashnetGetJwtResultSchema, sparkFlashnetGetJwtSuccessResponseSchema, sparkFlashnetSignIntentParamsSchema, sparkFlashnetSignIntentRequestSchema, sparkFlashnetSignIntentResultSchema, sparkFlashnetSignIntentSuccessResponseSchema, sparkFlashnetSignStructuredMessageParamsSchema, sparkFlashnetSignStructuredMessageRequestSchema, sparkFlashnetSignStructuredMessageResultSchema, sparkFlashnetSignStructuredMessageSuccessResponseSchema, sparkGetAddressesParamsSchema, sparkGetAddressesRequestSchema, sparkGetAddressesResultSchema, sparkGetAddressesSuccessResponseSchema, sparkGetAddressesV2ParamsSchema, sparkGetAddressesV2RequestSchema, sparkGetAddressesV2ResultSchema, sparkGetAddressesV2SuccessResponseSchema, sparkGetBalanceParamsSchema, sparkGetBalanceRequestSchema, sparkGetBalanceResultSchema, sparkGetBalanceSuccessResponseSchema, sparkGetClawbackEligibleTransfersParamsSchema, sparkGetClawbackEligibleTransfersRequestSchema, sparkGetClawbackEligibleTransfersResultSchema, sparkGetClawbackEligibleTransfersSuccessResponseSchema, sparkMethods, sparkModeToLegacySparkNetworkType, sparkNetworkConfigurationOptionsSchema, sparkRequestSchema, sparkSignMessageParamsSchema, sparkSignMessageRequestSchema, sparkSignMessageResultSchema, sparkSignMessageSuccessResponseSchema, sparkSuccessResponseSchema, sparkTransferParamsSchema, sparkTransferRequestSchema, sparkTransferResultSchema, sparkTransferSuccessResponseSchema, sparkTransferTokenParamsSchema, sparkTransferTokenRequestSchema, sparkTransferTokenResultSchema, sparkTransferTokenSuccessResponseSchema, specErrorObjectSchema, specErrorResponseSchema, specIdSchema, specRequestSchema, specResponseSchema, specSuccessResponseSchema, specSuccessWithExtensionsResponseSchema, stacksAccountSchema, stacksCallContractParamsSchema, stacksCallContractRequestSchema, stacksCallContractResultSchema, stacksCallContractSuccessResponseSchema, stacksDeployContractParamsSchema, stacksDeployContractRequestSchema, stacksDeployContractResultSchema, stacksDeployContractSuccessResponseSchema, stacksGetAccountsParamsSchema, stacksGetAccountsRequestSchema, stacksGetAccountsResultSchema, stacksGetAccountsSuccessResponseSchema, stacksGetAddressesParamsSchema, stacksGetAddressesRequestSchema, stacksGetAddressesResultSchema, stacksGetAddressesSuccessResponseSchema, stacksLegacyAccountSchema, stacksMethods, stacksModeToLegacyStacksNetworkType, stacksMultisigAccountSchema, stacksMultisigSchema, stacksNetworkConfigurationOptionsSchema, stacksRequestSchema, stacksSignMessageParamsSchema, stacksSignMessageRequestSchema, stacksSignMessageResultSchema, stacksSignMessageSuccessResponseSchema, stacksSignStructuredMessageParamsSchema, stacksSignStructuredMessageRequestSchema, stacksSignStructuredMessageResultSchema, stacksSignStructuredMessageSuccessResponseSchema, stacksSignTransactionParamsSchema, stacksSignTransactionRequestSchema, stacksSignTransactionResultSchema, stacksSignTransactionSuccessResponseSchema, stacksSignTransactionsBroadcastErrorDataSchema, stacksSignTransactionsParamsSchema, stacksSignTransactionsRequestSchema, stacksSignTransactionsResultSchema, stacksSignTransactionsSuccessResponseSchema, stacksSuccessResponseSchema, stacksTransferStxParamsSchema, stacksTransferStxRequestSchema, stacksTransferStxResultSchema, stacksTransferStxSuccessResponseSchema, starknetNetworkConfigurationOptionsSchema, supportStates, unlockDefinitionSchema, walletAddNetworkParamsSchema, walletAddNetworkRequestSchema, walletAddNetworkResultSchema, walletAddNetworkSuccessResponseSchema, walletAddNetworkV2ParamsSchema, walletAddNetworkV2RequestSchema, walletAddNetworkV2ResultSchema, walletAddNetworkV2SuccessResponseSchema, walletChangeNetworkParamsSchema, walletChangeNetworkRequestSchema, walletChangeNetworkResultSchema, walletChangeNetworkSuccessResponseSchema, walletConnectParamsSchema, walletConnectRequestSchema, walletConnectResultSchema, walletConnectSuccessResponseSchema, walletConnectV2ParamsSchema, walletConnectV2RequestSchema, walletConnectV2ResultSchema, walletConnectV2SuccessResponseSchema, walletDisconnectParamsSchema, walletDisconnectRequestSchema, walletDisconnectResultSchema, walletDisconnectSuccessResponseSchema, walletEventSchema, walletGetAccountParamsSchema, walletGetAccountRequestSchema, walletGetAccountResultSchema, walletGetAccountSuccessResponseSchema, walletGetAccountV2ParamsSchema, walletGetAccountV2RequestSchema, walletGetAccountV2ResultSchema, walletGetAccountV2SuccessResponseSchema, walletGetCurrentPermissionsParamsSchema, walletGetCurrentPermissionsRequestSchema, walletGetCurrentPermissionsResultSchema, walletGetCurrentPermissionsSuccessResponseSchema, walletGetNetworkParamsSchema, walletGetNetworkRequestSchema, walletGetNetworkResultSchema, walletGetNetworkSuccessResponseSchema, walletGetNetworksParamsSchema, walletGetNetworksRequestSchema, walletGetNetworksResultSchema, walletGetNetworksSuccessResponseSchema, walletGetWalletTypeParamsSchema, walletGetWalletTypeRequestSchema, walletGetWalletTypeResultSchema, walletGetWalletTypeSuccessResponseSchema, walletMethods, walletOpenBridgeParamsSchema, walletOpenBridgeRequestSchema, walletOpenBridgeResultSchema, walletOpenBridgeSuccessResponseSchema, walletOpenBuyParamsSchema, walletOpenBuyRequestSchema, walletOpenBuyResultSchema, walletOpenBuySuccessResponseSchema, walletOpenParamsSchema, walletOpenReceiveParamsSchema, walletOpenReceiveRequestSchema, walletOpenReceiveResultSchema, walletOpenReceiveSuccessResponseSchema, walletOpenRequestSchema, walletOpenResultSchema, walletOpenSuccessResponseSchema, walletRenouncePermissionsParamsSchema, walletRenouncePermissionsRequestSchema, walletRenouncePermissionsResultSchema, walletRenouncePermissionsSuccessResponseSchema, walletRequestPermissionsParamsSchema, walletRequestPermissionsRequestSchema, walletRequestPermissionsResultSchema, walletRequestPermissionsSuccessResponseSchema, walletRequestSchema, walletSuccessResponseSchema, walletSwitchNetworkParamsSchema, walletSwitchNetworkRequestSchema, walletSwitchNetworkResultSchema, walletSwitchNetworkSuccessResponseSchema, walletTypeSchema, walletTypes };