@sats-connect/core 0.18.2-263ae91 → 0.18.2-443cc47

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,7 +2474,42 @@ 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>;
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>;
2098
2513
  readonly '~sats-connect-method': v.LiteralSchema<"getAccounts", undefined>;
2099
2514
  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
2100
2515
  readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
@@ -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,7 +2734,42 @@ declare const bitcoinSuccessResponseSchema: v.VariantSchema<"~sats-connect-metho
2269
2734
  controlBlock: string;
2270
2735
  }[];
2271
2736
  } | undefined;
2272
- }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
2737
+ stacksMultisig?: {
2738
+ hashMode: "P2SHNonSequential";
2739
+ threshold: number;
2740
+ publicKeys: string[];
2741
+ } | undefined;
2742
+ }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
2743
+ address: string;
2744
+ publicKey: string;
2745
+ purpose: AddressPurpose;
2746
+ addressType: AddressType;
2747
+ walletType: "software" | "ledger" | "keystone" | "multisig";
2748
+ scriptPubKey?: string | undefined;
2749
+ unlockDefinition?: {
2750
+ type: "p2wpkh";
2751
+ } | {
2752
+ type: "p2sh-p2wpkh";
2753
+ redeemScript: string;
2754
+ } | {
2755
+ type: "p2tr-key-path";
2756
+ tapInternalKey: string;
2757
+ } | {
2758
+ type: "p2wsh";
2759
+ witnessScript: string;
2760
+ } | {
2761
+ type: "p2tr-script-path";
2762
+ tapLeafScript: {
2763
+ script: string;
2764
+ controlBlock: string;
2765
+ }[];
2766
+ } | undefined;
2767
+ stacksMultisig?: {
2768
+ hashMode: "P2SHNonSequential";
2769
+ threshold: number;
2770
+ publicKeys: string[];
2771
+ } | undefined;
2772
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
2273
2773
  address: string;
2274
2774
  publicKey: string;
2275
2775
  purpose: AddressPurpose;
@@ -2294,7 +2794,12 @@ declare const bitcoinSuccessResponseSchema: v.VariantSchema<"~sats-connect-metho
2294
2794
  controlBlock: string;
2295
2795
  }[];
2296
2796
  } | undefined;
2297
- }, "unlockDefinition type does not match addressType">]>, 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,7 +6055,42 @@ 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>;
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>;
5319
6094
  readonly network: v.ObjectSchema<{
5320
6095
  readonly chain: v.LiteralSchema<"spark", undefined>;
5321
6096
  readonly mode: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EnumSchema<{
@@ -5773,10 +6548,6 @@ declare const stacksMultisigAccountSchema: v.StrictObjectSchema<{
5773
6548
  readonly multisig: v.ObjectSchema<{
5774
6549
  readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
5775
6550
  readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
5776
- /**
5777
- * Compressed secp256k1 public keys of the vault members, in the order the vault
5778
- * address derives from.
5779
- */
5780
6551
  readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
5781
6552
  }, undefined>;
5782
6553
  }, undefined>;
@@ -5793,10 +6564,6 @@ declare const stacksAccountSchema: v.UnionSchema<[v.ObjectSchema<{
5793
6564
  readonly multisig: v.ObjectSchema<{
5794
6565
  readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
5795
6566
  readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
5796
- /**
5797
- * Compressed secp256k1 public keys of the vault members, in the order the vault
5798
- * address derives from.
5799
- */
5800
6567
  readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
5801
6568
  }, undefined>;
5802
6569
  }, undefined>], undefined>;
@@ -5817,10 +6584,6 @@ declare const stacksGetAccountsResultSchema: v.ObjectSchema<{
5817
6584
  readonly multisig: v.ObjectSchema<{
5818
6585
  readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
5819
6586
  readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
5820
- /**
5821
- * Compressed secp256k1 public keys of the vault members, in the order the vault
5822
- * address derives from.
5823
- */
5824
6587
  readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
5825
6588
  }, undefined>;
5826
6589
  }, undefined>], undefined>, undefined>;
@@ -5855,10 +6618,6 @@ declare const stacksGetAccountsSuccessResponseSchema: v.ObjectSchema<{
5855
6618
  readonly multisig: v.ObjectSchema<{
5856
6619
  readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
5857
6620
  readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
5858
- /**
5859
- * Compressed secp256k1 public keys of the vault members, in the order the vault
5860
- * address derives from.
5861
- */
5862
6621
  readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
5863
6622
  }, undefined>;
5864
6623
  }, undefined>], undefined>, undefined>;
@@ -5943,6 +6702,11 @@ declare const stacksGetAddressesResultSchema: v.ObjectSchema<{
5943
6702
  controlBlock: string;
5944
6703
  }[], 1, undefined>]>;
5945
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>;
5946
6710
  }, undefined>, v.CheckAction<{
5947
6711
  address: string;
5948
6712
  publicKey: string;
@@ -5968,6 +6732,11 @@ declare const stacksGetAddressesResultSchema: v.ObjectSchema<{
5968
6732
  controlBlock: string;
5969
6733
  }[];
5970
6734
  } | undefined;
6735
+ stacksMultisig?: {
6736
+ hashMode: "P2SHNonSequential";
6737
+ threshold: number;
6738
+ publicKeys: string[];
6739
+ } | undefined;
5971
6740
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
5972
6741
  address: string;
5973
6742
  publicKey: string;
@@ -5993,7 +6762,42 @@ declare const stacksGetAddressesResultSchema: v.ObjectSchema<{
5993
6762
  controlBlock: string;
5994
6763
  }[];
5995
6764
  } | undefined;
5996
- }, "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>;
5997
6801
  readonly network: v.ObjectSchema<{
5998
6802
  readonly bitcoin: v.ObjectSchema<{
5999
6803
  readonly name: v.EnumSchema<typeof BitcoinNetworkType, undefined>;
@@ -6042,9 +6846,44 @@ declare const stacksGetAddressesSuccessResponseSchema: v.ObjectSchema<{
6042
6846
  }, "Tapleaf version does not match the control block">]>, undefined>, v.MinLengthAction<{
6043
6847
  script: string;
6044
6848
  controlBlock: string;
6045
- }[], 1, undefined>]>;
6046
- }, undefined>], undefined>, undefined>;
6047
- }, undefined>, v.CheckAction<{
6849
+ }[], 1, undefined>]>;
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>;
6856
+ }, undefined>, v.CheckAction<{
6857
+ address: string;
6858
+ publicKey: string;
6859
+ purpose: AddressPurpose;
6860
+ addressType: AddressType;
6861
+ walletType: "software" | "ledger" | "keystone" | "multisig";
6862
+ scriptPubKey?: string | undefined;
6863
+ unlockDefinition?: {
6864
+ type: "p2wpkh";
6865
+ } | {
6866
+ type: "p2sh-p2wpkh";
6867
+ redeemScript: string;
6868
+ } | {
6869
+ type: "p2tr-key-path";
6870
+ tapInternalKey: string;
6871
+ } | {
6872
+ type: "p2wsh";
6873
+ witnessScript: string;
6874
+ } | {
6875
+ type: "p2tr-script-path";
6876
+ tapLeafScript: {
6877
+ script: string;
6878
+ controlBlock: string;
6879
+ }[];
6880
+ } | undefined;
6881
+ stacksMultisig?: {
6882
+ hashMode: "P2SHNonSequential";
6883
+ threshold: number;
6884
+ publicKeys: string[];
6885
+ } | undefined;
6886
+ }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
6048
6887
  address: string;
6049
6888
  publicKey: string;
6050
6889
  purpose: AddressPurpose;
@@ -6069,7 +6908,12 @@ declare const stacksGetAddressesSuccessResponseSchema: v.ObjectSchema<{
6069
6908
  controlBlock: string;
6070
6909
  }[];
6071
6910
  } | undefined;
6072
- }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
6911
+ stacksMultisig?: {
6912
+ hashMode: "P2SHNonSequential";
6913
+ threshold: number;
6914
+ publicKeys: string[];
6915
+ } | undefined;
6916
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
6073
6917
  address: string;
6074
6918
  publicKey: string;
6075
6919
  purpose: AddressPurpose;
@@ -6094,7 +6938,12 @@ declare const stacksGetAddressesSuccessResponseSchema: v.ObjectSchema<{
6094
6938
  controlBlock: string;
6095
6939
  }[];
6096
6940
  } | undefined;
6097
- }, "unlockDefinition type does not match addressType">]>, undefined>;
6941
+ stacksMultisig?: {
6942
+ hashMode: "P2SHNonSequential";
6943
+ threshold: number;
6944
+ publicKeys: string[];
6945
+ } | undefined;
6946
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
6098
6947
  readonly network: v.ObjectSchema<{
6099
6948
  readonly bitcoin: v.ObjectSchema<{
6100
6949
  readonly name: v.EnumSchema<typeof BitcoinNetworkType, undefined>;
@@ -6756,6 +7605,11 @@ declare const stacksSuccessResponseSchema: v.VariantSchema<"~sats-connect-method
6756
7605
  controlBlock: string;
6757
7606
  }[], 1, undefined>]>;
6758
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>;
6759
7613
  }, undefined>, v.CheckAction<{
6760
7614
  address: string;
6761
7615
  publicKey: string;
@@ -6781,6 +7635,11 @@ declare const stacksSuccessResponseSchema: v.VariantSchema<"~sats-connect-method
6781
7635
  controlBlock: string;
6782
7636
  }[];
6783
7637
  } | undefined;
7638
+ stacksMultisig?: {
7639
+ hashMode: "P2SHNonSequential";
7640
+ threshold: number;
7641
+ publicKeys: string[];
7642
+ } | undefined;
6784
7643
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
6785
7644
  address: string;
6786
7645
  publicKey: string;
@@ -6806,7 +7665,42 @@ declare const stacksSuccessResponseSchema: v.VariantSchema<"~sats-connect-method
6806
7665
  controlBlock: string;
6807
7666
  }[];
6808
7667
  } | undefined;
6809
- }, "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>;
6810
7704
  readonly network: v.ObjectSchema<{
6811
7705
  readonly bitcoin: v.ObjectSchema<{
6812
7706
  readonly name: v.EnumSchema<typeof BitcoinNetworkType, undefined>;
@@ -7966,6 +8860,11 @@ declare const walletConnectResultSchema: v.ObjectSchema<{
7966
8860
  controlBlock: string;
7967
8861
  }[], 1, undefined>]>;
7968
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>;
7969
8868
  }, undefined>, v.CheckAction<{
7970
8869
  address: string;
7971
8870
  publicKey: string;
@@ -7991,6 +8890,11 @@ declare const walletConnectResultSchema: v.ObjectSchema<{
7991
8890
  controlBlock: string;
7992
8891
  }[];
7993
8892
  } | undefined;
8893
+ stacksMultisig?: {
8894
+ hashMode: "P2SHNonSequential";
8895
+ threshold: number;
8896
+ publicKeys: string[];
8897
+ } | undefined;
7994
8898
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
7995
8899
  address: string;
7996
8900
  publicKey: string;
@@ -8016,7 +8920,42 @@ declare const walletConnectResultSchema: v.ObjectSchema<{
8016
8920
  controlBlock: string;
8017
8921
  }[];
8018
8922
  } | undefined;
8019
- }, "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>;
8020
8959
  readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone", "multisig"], undefined>;
8021
8960
  readonly network: v.ObjectSchema<{
8022
8961
  readonly bitcoin: v.ObjectSchema<{
@@ -8066,6 +9005,11 @@ declare const walletConnectSuccessResponseSchema: v.ObjectSchema<{
8066
9005
  controlBlock: string;
8067
9006
  }[], 1, undefined>]>;
8068
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>;
8069
9013
  }, undefined>, v.CheckAction<{
8070
9014
  address: string;
8071
9015
  publicKey: string;
@@ -8091,6 +9035,11 @@ declare const walletConnectSuccessResponseSchema: v.ObjectSchema<{
8091
9035
  controlBlock: string;
8092
9036
  }[];
8093
9037
  } | undefined;
9038
+ stacksMultisig?: {
9039
+ hashMode: "P2SHNonSequential";
9040
+ threshold: number;
9041
+ publicKeys: string[];
9042
+ } | undefined;
8094
9043
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
8095
9044
  address: string;
8096
9045
  publicKey: string;
@@ -8116,7 +9065,42 @@ declare const walletConnectSuccessResponseSchema: v.ObjectSchema<{
8116
9065
  controlBlock: string;
8117
9066
  }[];
8118
9067
  } | undefined;
8119
- }, "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>;
8120
9104
  readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone", "multisig"], undefined>;
8121
9105
  readonly network: v.ObjectSchema<{
8122
9106
  readonly bitcoin: v.ObjectSchema<{
@@ -8221,6 +9205,11 @@ declare const walletConnectV2ResultSchema: v.ObjectSchema<{
8221
9205
  controlBlock: string;
8222
9206
  }[], 1, undefined>]>;
8223
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>;
8224
9213
  }, undefined>, v.CheckAction<{
8225
9214
  address: string;
8226
9215
  publicKey: string;
@@ -8246,6 +9235,11 @@ declare const walletConnectV2ResultSchema: v.ObjectSchema<{
8246
9235
  controlBlock: string;
8247
9236
  }[];
8248
9237
  } | undefined;
9238
+ stacksMultisig?: {
9239
+ hashMode: "P2SHNonSequential";
9240
+ threshold: number;
9241
+ publicKeys: string[];
9242
+ } | undefined;
8249
9243
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
8250
9244
  address: string;
8251
9245
  publicKey: string;
@@ -8271,7 +9265,42 @@ declare const walletConnectV2ResultSchema: v.ObjectSchema<{
8271
9265
  controlBlock: string;
8272
9266
  }[];
8273
9267
  } | undefined;
8274
- }, "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>;
8275
9304
  readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone", "multisig"], undefined>;
8276
9305
  readonly networks: v.ObjectSchema<{
8277
9306
  readonly active: v.ObjectSchema<{
@@ -8447,6 +9476,11 @@ declare const walletConnectV2SuccessResponseSchema: v.ObjectSchema<{
8447
9476
  controlBlock: string;
8448
9477
  }[], 1, undefined>]>;
8449
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>;
8450
9484
  }, undefined>, v.CheckAction<{
8451
9485
  address: string;
8452
9486
  publicKey: string;
@@ -8472,6 +9506,11 @@ declare const walletConnectV2SuccessResponseSchema: v.ObjectSchema<{
8472
9506
  controlBlock: string;
8473
9507
  }[];
8474
9508
  } | undefined;
9509
+ stacksMultisig?: {
9510
+ hashMode: "P2SHNonSequential";
9511
+ threshold: number;
9512
+ publicKeys: string[];
9513
+ } | undefined;
8475
9514
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
8476
9515
  address: string;
8477
9516
  publicKey: string;
@@ -8497,7 +9536,42 @@ declare const walletConnectV2SuccessResponseSchema: v.ObjectSchema<{
8497
9536
  controlBlock: string;
8498
9537
  }[];
8499
9538
  } | undefined;
8500
- }, "unlockDefinition type does not match addressType">]>, undefined>;
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>;
8501
9575
  readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone", "multisig"], undefined>;
8502
9576
  readonly networks: v.ObjectSchema<{
8503
9577
  readonly active: v.ObjectSchema<{
@@ -8723,6 +9797,11 @@ declare const walletGetAccountResultSchema: v.ObjectSchema<{
8723
9797
  controlBlock: string;
8724
9798
  }[], 1, undefined>]>;
8725
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>;
8726
9805
  }, undefined>, v.CheckAction<{
8727
9806
  address: string;
8728
9807
  publicKey: string;
@@ -8748,6 +9827,11 @@ declare const walletGetAccountResultSchema: v.ObjectSchema<{
8748
9827
  controlBlock: string;
8749
9828
  }[];
8750
9829
  } | undefined;
9830
+ stacksMultisig?: {
9831
+ hashMode: "P2SHNonSequential";
9832
+ threshold: number;
9833
+ publicKeys: string[];
9834
+ } | undefined;
8751
9835
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
8752
9836
  address: string;
8753
9837
  publicKey: string;
@@ -8773,7 +9857,42 @@ declare const walletGetAccountResultSchema: v.ObjectSchema<{
8773
9857
  controlBlock: string;
8774
9858
  }[];
8775
9859
  } | undefined;
8776
- }, "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>;
8777
9896
  readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone", "multisig"], undefined>;
8778
9897
  readonly network: v.ObjectSchema<{
8779
9898
  readonly bitcoin: v.ObjectSchema<{
@@ -8823,6 +9942,11 @@ declare const walletGetAccountSuccessResponseSchema: v.ObjectSchema<{
8823
9942
  controlBlock: string;
8824
9943
  }[], 1, undefined>]>;
8825
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>;
8826
9950
  }, undefined>, v.CheckAction<{
8827
9951
  address: string;
8828
9952
  publicKey: string;
@@ -8848,6 +9972,11 @@ declare const walletGetAccountSuccessResponseSchema: v.ObjectSchema<{
8848
9972
  controlBlock: string;
8849
9973
  }[];
8850
9974
  } | undefined;
9975
+ stacksMultisig?: {
9976
+ hashMode: "P2SHNonSequential";
9977
+ threshold: number;
9978
+ publicKeys: string[];
9979
+ } | undefined;
8851
9980
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
8852
9981
  address: string;
8853
9982
  publicKey: string;
@@ -8873,7 +10002,42 @@ declare const walletGetAccountSuccessResponseSchema: v.ObjectSchema<{
8873
10002
  controlBlock: string;
8874
10003
  }[];
8875
10004
  } | undefined;
8876
- }, "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>;
8877
10041
  readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone", "multisig"], undefined>;
8878
10042
  readonly network: v.ObjectSchema<{
8879
10043
  readonly bitcoin: v.ObjectSchema<{
@@ -8942,9 +10106,44 @@ declare const walletGetAccountV2ResultSchema: v.ObjectSchema<{
8942
10106
  }, "Tapleaf version does not match the control block">]>, undefined>, v.MinLengthAction<{
8943
10107
  script: string;
8944
10108
  controlBlock: string;
8945
- }[], 1, undefined>]>;
8946
- }, undefined>], undefined>, undefined>;
8947
- }, undefined>, v.CheckAction<{
10109
+ }[], 1, undefined>]>;
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>;
10116
+ }, undefined>, v.CheckAction<{
10117
+ address: string;
10118
+ publicKey: string;
10119
+ purpose: AddressPurpose;
10120
+ addressType: AddressType;
10121
+ walletType: "software" | "ledger" | "keystone" | "multisig";
10122
+ scriptPubKey?: string | undefined;
10123
+ unlockDefinition?: {
10124
+ type: "p2wpkh";
10125
+ } | {
10126
+ type: "p2sh-p2wpkh";
10127
+ redeemScript: string;
10128
+ } | {
10129
+ type: "p2tr-key-path";
10130
+ tapInternalKey: string;
10131
+ } | {
10132
+ type: "p2wsh";
10133
+ witnessScript: string;
10134
+ } | {
10135
+ type: "p2tr-script-path";
10136
+ tapLeafScript: {
10137
+ script: string;
10138
+ controlBlock: string;
10139
+ }[];
10140
+ } | undefined;
10141
+ stacksMultisig?: {
10142
+ hashMode: "P2SHNonSequential";
10143
+ threshold: number;
10144
+ publicKeys: string[];
10145
+ } | undefined;
10146
+ }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
8948
10147
  address: string;
8949
10148
  publicKey: string;
8950
10149
  purpose: AddressPurpose;
@@ -8969,7 +10168,12 @@ declare const walletGetAccountV2ResultSchema: v.ObjectSchema<{
8969
10168
  controlBlock: string;
8970
10169
  }[];
8971
10170
  } | undefined;
8972
- }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
10171
+ stacksMultisig?: {
10172
+ hashMode: "P2SHNonSequential";
10173
+ threshold: number;
10174
+ publicKeys: string[];
10175
+ } | undefined;
10176
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
8973
10177
  address: string;
8974
10178
  publicKey: string;
8975
10179
  purpose: AddressPurpose;
@@ -8994,7 +10198,12 @@ declare const walletGetAccountV2ResultSchema: v.ObjectSchema<{
8994
10198
  controlBlock: string;
8995
10199
  }[];
8996
10200
  } | undefined;
8997
- }, "unlockDefinition type does not match addressType">]>, undefined>;
10201
+ stacksMultisig?: {
10202
+ hashMode: "P2SHNonSequential";
10203
+ threshold: number;
10204
+ publicKeys: string[];
10205
+ } | undefined;
10206
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
8998
10207
  readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone", "multisig"], undefined>;
8999
10208
  readonly networks: v.ObjectSchema<{
9000
10209
  readonly active: v.ObjectSchema<{
@@ -9170,6 +10379,11 @@ declare const walletGetAccountV2SuccessResponseSchema: v.ObjectSchema<{
9170
10379
  controlBlock: string;
9171
10380
  }[], 1, undefined>]>;
9172
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>;
9173
10387
  }, undefined>, v.CheckAction<{
9174
10388
  address: string;
9175
10389
  publicKey: string;
@@ -9195,6 +10409,11 @@ declare const walletGetAccountV2SuccessResponseSchema: v.ObjectSchema<{
9195
10409
  controlBlock: string;
9196
10410
  }[];
9197
10411
  } | undefined;
10412
+ stacksMultisig?: {
10413
+ hashMode: "P2SHNonSequential";
10414
+ threshold: number;
10415
+ publicKeys: string[];
10416
+ } | undefined;
9198
10417
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
9199
10418
  address: string;
9200
10419
  publicKey: string;
@@ -9220,7 +10439,42 @@ declare const walletGetAccountV2SuccessResponseSchema: v.ObjectSchema<{
9220
10439
  controlBlock: string;
9221
10440
  }[];
9222
10441
  } | undefined;
9223
- }, "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>;
9224
10478
  readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone", "multisig"], undefined>;
9225
10479
  readonly networks: v.ObjectSchema<{
9226
10480
  readonly active: v.ObjectSchema<{
@@ -9956,6 +11210,11 @@ declare const walletOpenReceiveResultSchema: v.SchemaWithPipe<readonly [v.Object
9956
11210
  controlBlock: string;
9957
11211
  }[], 1, undefined>]>;
9958
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>;
9959
11218
  }, undefined>, v.CheckAction<{
9960
11219
  address: string;
9961
11220
  publicKey: string;
@@ -9981,6 +11240,11 @@ declare const walletOpenReceiveResultSchema: v.SchemaWithPipe<readonly [v.Object
9981
11240
  controlBlock: string;
9982
11241
  }[];
9983
11242
  } | undefined;
11243
+ stacksMultisig?: {
11244
+ hashMode: "P2SHNonSequential";
11245
+ threshold: number;
11246
+ publicKeys: string[];
11247
+ } | undefined;
9984
11248
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
9985
11249
  address: string;
9986
11250
  publicKey: string;
@@ -10006,7 +11270,42 @@ declare const walletOpenReceiveResultSchema: v.SchemaWithPipe<readonly [v.Object
10006
11270
  controlBlock: string;
10007
11271
  }[];
10008
11272
  } | undefined;
10009
- }, "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">]>;
10010
11309
  type WalletOpenReceiveResult = v.InferOutput<typeof walletOpenReceiveResultSchema>;
10011
11310
  declare const walletOpenReceiveSuccessResponseSchema: v.ObjectSchema<{
10012
11311
  readonly id: v.StringSchema<undefined>;
@@ -10041,6 +11340,11 @@ declare const walletOpenReceiveSuccessResponseSchema: v.ObjectSchema<{
10041
11340
  controlBlock: string;
10042
11341
  }[], 1, undefined>]>;
10043
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>;
10044
11348
  }, undefined>, v.CheckAction<{
10045
11349
  address: string;
10046
11350
  publicKey: string;
@@ -10066,6 +11370,11 @@ declare const walletOpenReceiveSuccessResponseSchema: v.ObjectSchema<{
10066
11370
  controlBlock: string;
10067
11371
  }[];
10068
11372
  } | undefined;
11373
+ stacksMultisig?: {
11374
+ hashMode: "P2SHNonSequential";
11375
+ threshold: number;
11376
+ publicKeys: string[];
11377
+ } | undefined;
10069
11378
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
10070
11379
  address: string;
10071
11380
  publicKey: string;
@@ -10091,7 +11400,42 @@ declare const walletOpenReceiveSuccessResponseSchema: v.ObjectSchema<{
10091
11400
  controlBlock: string;
10092
11401
  }[];
10093
11402
  } | undefined;
10094
- }, "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">]>;
10095
11439
  readonly '~sats-connect-method': v.LiteralSchema<"wallet_openReceive", undefined>;
10096
11440
  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
10097
11441
  readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
@@ -12222,6 +13566,11 @@ declare const walletSuccessResponseSchema: v.VariantSchema<"~sats-connect-method
12222
13566
  controlBlock: string;
12223
13567
  }[], 1, undefined>]>;
12224
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>;
12225
13574
  }, undefined>, v.CheckAction<{
12226
13575
  address: string;
12227
13576
  publicKey: string;
@@ -12247,6 +13596,11 @@ declare const walletSuccessResponseSchema: v.VariantSchema<"~sats-connect-method
12247
13596
  controlBlock: string;
12248
13597
  }[];
12249
13598
  } | undefined;
13599
+ stacksMultisig?: {
13600
+ hashMode: "P2SHNonSequential";
13601
+ threshold: number;
13602
+ publicKeys: string[];
13603
+ } | undefined;
12250
13604
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
12251
13605
  address: string;
12252
13606
  publicKey: string;
@@ -12272,7 +13626,42 @@ declare const walletSuccessResponseSchema: v.VariantSchema<"~sats-connect-method
12272
13626
  controlBlock: string;
12273
13627
  }[];
12274
13628
  } | undefined;
12275
- }, "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>;
12276
13665
  readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone", "multisig"], undefined>;
12277
13666
  readonly network: v.ObjectSchema<{
12278
13667
  readonly bitcoin: v.ObjectSchema<{
@@ -12330,6 +13719,11 @@ declare const walletSuccessResponseSchema: v.VariantSchema<"~sats-connect-method
12330
13719
  controlBlock: string;
12331
13720
  }[], 1, undefined>]>;
12332
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>;
12333
13727
  }, undefined>, v.CheckAction<{
12334
13728
  address: string;
12335
13729
  publicKey: string;
@@ -12355,6 +13749,11 @@ declare const walletSuccessResponseSchema: v.VariantSchema<"~sats-connect-method
12355
13749
  controlBlock: string;
12356
13750
  }[];
12357
13751
  } | undefined;
13752
+ stacksMultisig?: {
13753
+ hashMode: "P2SHNonSequential";
13754
+ threshold: number;
13755
+ publicKeys: string[];
13756
+ } | undefined;
12358
13757
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
12359
13758
  address: string;
12360
13759
  publicKey: string;
@@ -12380,7 +13779,42 @@ declare const walletSuccessResponseSchema: v.VariantSchema<"~sats-connect-method
12380
13779
  controlBlock: string;
12381
13780
  }[];
12382
13781
  } | undefined;
12383
- }, "unlockDefinition type does not match addressType">]>, undefined>;
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>;
12384
13818
  readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone", "multisig"], undefined>;
12385
13819
  readonly networks: v.ObjectSchema<{
12386
13820
  readonly active: v.ObjectSchema<{
@@ -12576,6 +14010,11 @@ declare const walletSuccessResponseSchema: v.VariantSchema<"~sats-connect-method
12576
14010
  controlBlock: string;
12577
14011
  }[], 1, undefined>]>;
12578
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>;
12579
14018
  }, undefined>, v.CheckAction<{
12580
14019
  address: string;
12581
14020
  publicKey: string;
@@ -12601,6 +14040,11 @@ declare const walletSuccessResponseSchema: v.VariantSchema<"~sats-connect-method
12601
14040
  controlBlock: string;
12602
14041
  }[];
12603
14042
  } | undefined;
14043
+ stacksMultisig?: {
14044
+ hashMode: "P2SHNonSequential";
14045
+ threshold: number;
14046
+ publicKeys: string[];
14047
+ } | undefined;
12604
14048
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
12605
14049
  address: string;
12606
14050
  publicKey: string;
@@ -12626,7 +14070,42 @@ declare const walletSuccessResponseSchema: v.VariantSchema<"~sats-connect-method
12626
14070
  controlBlock: string;
12627
14071
  }[];
12628
14072
  } | undefined;
12629
- }, "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>;
12630
14109
  readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone", "multisig"], undefined>;
12631
14110
  readonly network: v.ObjectSchema<{
12632
14111
  readonly bitcoin: v.ObjectSchema<{
@@ -12684,6 +14163,11 @@ declare const walletSuccessResponseSchema: v.VariantSchema<"~sats-connect-method
12684
14163
  controlBlock: string;
12685
14164
  }[], 1, undefined>]>;
12686
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>;
12687
14171
  }, undefined>, v.CheckAction<{
12688
14172
  address: string;
12689
14173
  publicKey: string;
@@ -12709,6 +14193,11 @@ declare const walletSuccessResponseSchema: v.VariantSchema<"~sats-connect-method
12709
14193
  controlBlock: string;
12710
14194
  }[];
12711
14195
  } | undefined;
14196
+ stacksMultisig?: {
14197
+ hashMode: "P2SHNonSequential";
14198
+ threshold: number;
14199
+ publicKeys: string[];
14200
+ } | undefined;
12712
14201
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
12713
14202
  address: string;
12714
14203
  publicKey: string;
@@ -12734,7 +14223,42 @@ declare const walletSuccessResponseSchema: v.VariantSchema<"~sats-connect-method
12734
14223
  controlBlock: string;
12735
14224
  }[];
12736
14225
  } | undefined;
12737
- }, "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>;
12738
14262
  readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone", "multisig"], undefined>;
12739
14263
  readonly networks: v.ObjectSchema<{
12740
14264
  readonly active: v.ObjectSchema<{
@@ -13160,6 +14684,11 @@ declare const walletSuccessResponseSchema: v.VariantSchema<"~sats-connect-method
13160
14684
  controlBlock: string;
13161
14685
  }[], 1, undefined>]>;
13162
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>;
13163
14692
  }, undefined>, v.CheckAction<{
13164
14693
  address: string;
13165
14694
  publicKey: string;
@@ -13185,7 +14714,42 @@ declare const walletSuccessResponseSchema: v.VariantSchema<"~sats-connect-method
13185
14714
  controlBlock: string;
13186
14715
  }[];
13187
14716
  } | undefined;
13188
- }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
14717
+ stacksMultisig?: {
14718
+ hashMode: "P2SHNonSequential";
14719
+ threshold: number;
14720
+ publicKeys: string[];
14721
+ } | undefined;
14722
+ }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
14723
+ address: string;
14724
+ publicKey: string;
14725
+ purpose: AddressPurpose;
14726
+ addressType: AddressType;
14727
+ walletType: "software" | "ledger" | "keystone" | "multisig";
14728
+ scriptPubKey?: string | undefined;
14729
+ unlockDefinition?: {
14730
+ type: "p2wpkh";
14731
+ } | {
14732
+ type: "p2sh-p2wpkh";
14733
+ redeemScript: string;
14734
+ } | {
14735
+ type: "p2tr-key-path";
14736
+ tapInternalKey: string;
14737
+ } | {
14738
+ type: "p2wsh";
14739
+ witnessScript: string;
14740
+ } | {
14741
+ type: "p2tr-script-path";
14742
+ tapLeafScript: {
14743
+ script: string;
14744
+ controlBlock: string;
14745
+ }[];
14746
+ } | undefined;
14747
+ stacksMultisig?: {
14748
+ hashMode: "P2SHNonSequential";
14749
+ threshold: number;
14750
+ publicKeys: string[];
14751
+ } | undefined;
14752
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
13189
14753
  address: string;
13190
14754
  publicKey: string;
13191
14755
  purpose: AddressPurpose;
@@ -13210,7 +14774,12 @@ declare const walletSuccessResponseSchema: v.VariantSchema<"~sats-connect-method
13210
14774
  controlBlock: string;
13211
14775
  }[];
13212
14776
  } | undefined;
13213
- }, "unlockDefinition type does not match addressType">]>;
14777
+ stacksMultisig?: {
14778
+ hashMode: "P2SHNonSequential";
14779
+ threshold: number;
14780
+ publicKeys: string[];
14781
+ } | undefined;
14782
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>;
13214
14783
  readonly '~sats-connect-method': v.LiteralSchema<"wallet_openReceive", undefined>;
13215
14784
  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
13216
14785
  readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
@@ -13262,6 +14831,19 @@ declare const walletSuccessResponseSchema: v.VariantSchema<"~sats-connect-method
13262
14831
  declare const walletTypes: readonly ["software", "ledger", "keystone", "multisig"];
13263
14832
  declare const walletTypeSchema: v.PicklistSchema<readonly ["software", "ledger", "keystone", "multisig"], undefined>;
13264
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>;
13265
14847
  //#endregion
13266
14848
  //#region src/request/shared.d.ts
13267
14849
  declare const rpcIdSchema: v.StringSchema<undefined>;
@@ -14389,6 +15971,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
14389
15971
  controlBlock: string;
14390
15972
  }[], 1, undefined>]>;
14391
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>;
14392
15979
  }, undefined>, v.CheckAction<{
14393
15980
  address: string;
14394
15981
  publicKey: string;
@@ -14414,6 +16001,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
14414
16001
  controlBlock: string;
14415
16002
  }[];
14416
16003
  } | undefined;
16004
+ stacksMultisig?: {
16005
+ hashMode: "P2SHNonSequential";
16006
+ threshold: number;
16007
+ publicKeys: string[];
16008
+ } | undefined;
14417
16009
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
14418
16010
  address: string;
14419
16011
  publicKey: string;
@@ -14439,7 +16031,42 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
14439
16031
  controlBlock: string;
14440
16032
  }[];
14441
16033
  } | undefined;
14442
- }, "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>;
14443
16070
  readonly '~sats-connect-method': v.LiteralSchema<"getAccounts", undefined>;
14444
16071
  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
14445
16072
  readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
@@ -14483,6 +16110,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
14483
16110
  controlBlock: string;
14484
16111
  }[], 1, undefined>]>;
14485
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>;
14486
16118
  }, undefined>, v.CheckAction<{
14487
16119
  address: string;
14488
16120
  publicKey: string;
@@ -14508,6 +16140,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
14508
16140
  controlBlock: string;
14509
16141
  }[];
14510
16142
  } | undefined;
16143
+ stacksMultisig?: {
16144
+ hashMode: "P2SHNonSequential";
16145
+ threshold: number;
16146
+ publicKeys: string[];
16147
+ } | undefined;
14511
16148
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
14512
16149
  address: string;
14513
16150
  publicKey: string;
@@ -14533,7 +16170,42 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
14533
16170
  controlBlock: string;
14534
16171
  }[];
14535
16172
  } | undefined;
14536
- }, "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>;
14537
16209
  readonly network: v.ObjectSchema<{
14538
16210
  readonly bitcoin: v.ObjectSchema<{
14539
16211
  readonly name: v.StringSchema<undefined>;
@@ -14589,6 +16261,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
14589
16261
  controlBlock: string;
14590
16262
  }[], 1, undefined>]>;
14591
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>;
14592
16269
  }, undefined>, v.CheckAction<{
14593
16270
  address: string;
14594
16271
  publicKey: string;
@@ -14614,6 +16291,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
14614
16291
  controlBlock: string;
14615
16292
  }[];
14616
16293
  } | undefined;
16294
+ stacksMultisig?: {
16295
+ hashMode: "P2SHNonSequential";
16296
+ threshold: number;
16297
+ publicKeys: string[];
16298
+ } | undefined;
14617
16299
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
14618
16300
  address: string;
14619
16301
  publicKey: string;
@@ -14639,7 +16321,42 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
14639
16321
  controlBlock: string;
14640
16322
  }[];
14641
16323
  } | undefined;
14642
- }, "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>;
14643
16360
  readonly networks: v.ObjectSchema<{
14644
16361
  readonly active: v.ObjectSchema<{
14645
16362
  readonly bitcoin: v.ObjectSchema<{
@@ -15069,6 +16786,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
15069
16786
  controlBlock: string;
15070
16787
  }[], 1, undefined>]>;
15071
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>;
15072
16794
  }, undefined>, v.CheckAction<{
15073
16795
  address: string;
15074
16796
  publicKey: string;
@@ -15094,6 +16816,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
15094
16816
  controlBlock: string;
15095
16817
  }[];
15096
16818
  } | undefined;
16819
+ stacksMultisig?: {
16820
+ hashMode: "P2SHNonSequential";
16821
+ threshold: number;
16822
+ publicKeys: string[];
16823
+ } | undefined;
15097
16824
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
15098
16825
  address: string;
15099
16826
  publicKey: string;
@@ -15119,7 +16846,42 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
15119
16846
  controlBlock: string;
15120
16847
  }[];
15121
16848
  } | undefined;
15122
- }, "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>;
15123
16885
  readonly network: v.ObjectSchema<{
15124
16886
  readonly bitcoin: v.ObjectSchema<{
15125
16887
  readonly name: v.EnumSchema<typeof BitcoinNetworkType, undefined>;
@@ -15249,6 +17011,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
15249
17011
  controlBlock: string;
15250
17012
  }[], 1, undefined>]>;
15251
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>;
15252
17019
  }, undefined>, v.CheckAction<{
15253
17020
  address: string;
15254
17021
  publicKey: string;
@@ -15274,6 +17041,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
15274
17041
  controlBlock: string;
15275
17042
  }[];
15276
17043
  } | undefined;
17044
+ stacksMultisig?: {
17045
+ hashMode: "P2SHNonSequential";
17046
+ threshold: number;
17047
+ publicKeys: string[];
17048
+ } | undefined;
15277
17049
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
15278
17050
  address: string;
15279
17051
  publicKey: string;
@@ -15299,7 +17071,42 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
15299
17071
  controlBlock: string;
15300
17072
  }[];
15301
17073
  } | undefined;
15302
- }, "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>;
15303
17110
  readonly network: v.ObjectSchema<{
15304
17111
  readonly bitcoin: v.ObjectSchema<{
15305
17112
  readonly name: v.EnumSchema<typeof BitcoinNetworkType, undefined>;
@@ -15355,6 +17162,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
15355
17162
  controlBlock: string;
15356
17163
  }[], 1, undefined>]>;
15357
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>;
15358
17170
  }, undefined>, v.CheckAction<{
15359
17171
  address: string;
15360
17172
  publicKey: string;
@@ -15380,6 +17192,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
15380
17192
  controlBlock: string;
15381
17193
  }[];
15382
17194
  } | undefined;
17195
+ stacksMultisig?: {
17196
+ hashMode: "P2SHNonSequential";
17197
+ threshold: number;
17198
+ publicKeys: string[];
17199
+ } | undefined;
15383
17200
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
15384
17201
  address: string;
15385
17202
  publicKey: string;
@@ -15405,7 +17222,42 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
15405
17222
  controlBlock: string;
15406
17223
  }[];
15407
17224
  } | undefined;
15408
- }, "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>;
15409
17261
  readonly network: v.ObjectSchema<{
15410
17262
  readonly chain: v.LiteralSchema<"spark", undefined>;
15411
17263
  readonly mode: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EnumSchema<{
@@ -15956,6 +17808,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
15956
17808
  controlBlock: string;
15957
17809
  }[], 1, undefined>]>;
15958
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>;
15959
17816
  }, undefined>, v.CheckAction<{
15960
17817
  address: string;
15961
17818
  publicKey: string;
@@ -15981,6 +17838,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
15981
17838
  controlBlock: string;
15982
17839
  }[];
15983
17840
  } | undefined;
17841
+ stacksMultisig?: {
17842
+ hashMode: "P2SHNonSequential";
17843
+ threshold: number;
17844
+ publicKeys: string[];
17845
+ } | undefined;
15984
17846
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
15985
17847
  address: string;
15986
17848
  publicKey: string;
@@ -16006,7 +17868,42 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
16006
17868
  controlBlock: string;
16007
17869
  }[];
16008
17870
  } | undefined;
16009
- }, "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>;
16010
17907
  readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone", "multisig"], undefined>;
16011
17908
  readonly network: v.ObjectSchema<{
16012
17909
  readonly bitcoin: v.ObjectSchema<{
@@ -16064,6 +17961,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
16064
17961
  controlBlock: string;
16065
17962
  }[], 1, undefined>]>;
16066
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>;
16067
17969
  }, undefined>, v.CheckAction<{
16068
17970
  address: string;
16069
17971
  publicKey: string;
@@ -16089,7 +17991,42 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
16089
17991
  controlBlock: string;
16090
17992
  }[];
16091
17993
  } | undefined;
16092
- }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
17994
+ stacksMultisig?: {
17995
+ hashMode: "P2SHNonSequential";
17996
+ threshold: number;
17997
+ publicKeys: string[];
17998
+ } | undefined;
17999
+ }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
18000
+ address: string;
18001
+ publicKey: string;
18002
+ purpose: AddressPurpose;
18003
+ addressType: AddressType;
18004
+ walletType: "software" | "ledger" | "keystone" | "multisig";
18005
+ scriptPubKey?: string | undefined;
18006
+ unlockDefinition?: {
18007
+ type: "p2wpkh";
18008
+ } | {
18009
+ type: "p2sh-p2wpkh";
18010
+ redeemScript: string;
18011
+ } | {
18012
+ type: "p2tr-key-path";
18013
+ tapInternalKey: string;
18014
+ } | {
18015
+ type: "p2wsh";
18016
+ witnessScript: string;
18017
+ } | {
18018
+ type: "p2tr-script-path";
18019
+ tapLeafScript: {
18020
+ script: string;
18021
+ controlBlock: string;
18022
+ }[];
18023
+ } | undefined;
18024
+ stacksMultisig?: {
18025
+ hashMode: "P2SHNonSequential";
18026
+ threshold: number;
18027
+ publicKeys: string[];
18028
+ } | undefined;
18029
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
16093
18030
  address: string;
16094
18031
  publicKey: string;
16095
18032
  purpose: AddressPurpose;
@@ -16114,7 +18051,12 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
16114
18051
  controlBlock: string;
16115
18052
  }[];
16116
18053
  } | undefined;
16117
- }, "unlockDefinition type does not match addressType">]>, undefined>;
18054
+ stacksMultisig?: {
18055
+ hashMode: "P2SHNonSequential";
18056
+ threshold: number;
18057
+ publicKeys: string[];
18058
+ } | undefined;
18059
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>;
16118
18060
  readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone", "multisig"], undefined>;
16119
18061
  readonly networks: v.ObjectSchema<{
16120
18062
  readonly active: v.ObjectSchema<{
@@ -16310,6 +18252,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
16310
18252
  controlBlock: string;
16311
18253
  }[], 1, undefined>]>;
16312
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>;
16313
18260
  }, undefined>, v.CheckAction<{
16314
18261
  address: string;
16315
18262
  publicKey: string;
@@ -16335,6 +18282,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
16335
18282
  controlBlock: string;
16336
18283
  }[];
16337
18284
  } | undefined;
18285
+ stacksMultisig?: {
18286
+ hashMode: "P2SHNonSequential";
18287
+ threshold: number;
18288
+ publicKeys: string[];
18289
+ } | undefined;
16338
18290
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
16339
18291
  address: string;
16340
18292
  publicKey: string;
@@ -16360,7 +18312,42 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
16360
18312
  controlBlock: string;
16361
18313
  }[];
16362
18314
  } | undefined;
16363
- }, "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>;
16364
18351
  readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone", "multisig"], undefined>;
16365
18352
  readonly network: v.ObjectSchema<{
16366
18353
  readonly bitcoin: v.ObjectSchema<{
@@ -16418,6 +18405,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
16418
18405
  controlBlock: string;
16419
18406
  }[], 1, undefined>]>;
16420
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>;
16421
18413
  }, undefined>, v.CheckAction<{
16422
18414
  address: string;
16423
18415
  publicKey: string;
@@ -16443,6 +18435,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
16443
18435
  controlBlock: string;
16444
18436
  }[];
16445
18437
  } | undefined;
18438
+ stacksMultisig?: {
18439
+ hashMode: "P2SHNonSequential";
18440
+ threshold: number;
18441
+ publicKeys: string[];
18442
+ } | undefined;
16446
18443
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
16447
18444
  address: string;
16448
18445
  publicKey: string;
@@ -16468,7 +18465,42 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
16468
18465
  controlBlock: string;
16469
18466
  }[];
16470
18467
  } | undefined;
16471
- }, "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>;
16472
18504
  readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone", "multisig"], undefined>;
16473
18505
  readonly networks: v.ObjectSchema<{
16474
18506
  readonly active: v.ObjectSchema<{
@@ -16894,6 +18926,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
16894
18926
  controlBlock: string;
16895
18927
  }[], 1, undefined>]>;
16896
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>;
16897
18934
  }, undefined>, v.CheckAction<{
16898
18935
  address: string;
16899
18936
  publicKey: string;
@@ -16919,6 +18956,11 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
16919
18956
  controlBlock: string;
16920
18957
  }[];
16921
18958
  } | undefined;
18959
+ stacksMultisig?: {
18960
+ hashMode: "P2SHNonSequential";
18961
+ threshold: number;
18962
+ publicKeys: string[];
18963
+ } | undefined;
16922
18964
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
16923
18965
  address: string;
16924
18966
  publicKey: string;
@@ -16944,7 +18986,42 @@ declare const rpcSuccessResponseSchema: v.VariantSchema<"~sats-connect-method",
16944
18986
  controlBlock: string;
16945
18987
  }[];
16946
18988
  } | undefined;
16947
- }, "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">]>;
16948
19025
  readonly '~sats-connect-method': v.LiteralSchema<"wallet_openReceive", undefined>;
16949
19026
  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
16950
19027
  readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
@@ -17226,10 +19303,6 @@ type SignMultipleTransactionOptions = RequestOptions<SignMultipleTransactionsPay
17226
19303
  declare const sendBtcTransaction: (options: SendBtcTransactionOptions) => Promise<void>;
17227
19304
  //#endregion
17228
19305
  //#region src/transactions/signMultipleTransactions.d.ts
17229
- /**
17230
- * For vault (multisig) accounts the wallet returns the finalized PSBTs without
17231
- * broadcasting them, so every `txId` in the response is empty.
17232
- */
17233
19306
  declare const signMultipleTransactions: (options: SignMultipleTransactionOptions) => Promise<void>;
17234
19307
  //#endregion
17235
19308
  //#region src/transactions/signTransaction.d.ts
@@ -17270,6 +19343,11 @@ declare const accountChangeSchema: v.ObjectSchema<{
17270
19343
  controlBlock: string;
17271
19344
  }[], 1, undefined>]>;
17272
19345
  }, undefined>], undefined>, undefined>;
19346
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
19347
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
19348
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
19349
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
19350
+ }, undefined>, undefined>;
17273
19351
  }, undefined>, v.CheckAction<{
17274
19352
  address: string;
17275
19353
  publicKey: string;
@@ -17295,6 +19373,11 @@ declare const accountChangeSchema: v.ObjectSchema<{
17295
19373
  controlBlock: string;
17296
19374
  }[];
17297
19375
  } | undefined;
19376
+ stacksMultisig?: {
19377
+ hashMode: "P2SHNonSequential";
19378
+ threshold: number;
19379
+ publicKeys: string[];
19380
+ } | undefined;
17298
19381
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
17299
19382
  address: string;
17300
19383
  publicKey: string;
@@ -17320,7 +19403,42 @@ declare const accountChangeSchema: v.ObjectSchema<{
17320
19403
  controlBlock: string;
17321
19404
  }[];
17322
19405
  } | undefined;
17323
- }, "unlockDefinition type does not match addressType">]>, undefined>, undefined>;
19406
+ stacksMultisig?: {
19407
+ hashMode: "P2SHNonSequential";
19408
+ threshold: number;
19409
+ publicKeys: string[];
19410
+ } | undefined;
19411
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
19412
+ address: string;
19413
+ publicKey: string;
19414
+ purpose: AddressPurpose;
19415
+ addressType: AddressType;
19416
+ walletType: "software" | "ledger" | "keystone" | "multisig";
19417
+ scriptPubKey?: string | undefined;
19418
+ unlockDefinition?: {
19419
+ type: "p2wpkh";
19420
+ } | {
19421
+ type: "p2sh-p2wpkh";
19422
+ redeemScript: string;
19423
+ } | {
19424
+ type: "p2tr-key-path";
19425
+ tapInternalKey: string;
19426
+ } | {
19427
+ type: "p2wsh";
19428
+ witnessScript: string;
19429
+ } | {
19430
+ type: "p2tr-script-path";
19431
+ tapLeafScript: {
19432
+ script: string;
19433
+ controlBlock: string;
19434
+ }[];
19435
+ } | undefined;
19436
+ stacksMultisig?: {
19437
+ hashMode: "P2SHNonSequential";
19438
+ threshold: number;
19439
+ publicKeys: string[];
19440
+ } | undefined;
19441
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>, undefined>;
17324
19442
  }, undefined>;
17325
19443
  type AccountChangeEvent = v.InferOutput<typeof accountChangeSchema>;
17326
19444
  declare const networkChangeEventName = "networkChange";
@@ -17363,6 +19481,11 @@ declare const networkChangeSchema: v.ObjectSchema<{
17363
19481
  controlBlock: string;
17364
19482
  }[], 1, undefined>]>;
17365
19483
  }, undefined>], undefined>, undefined>;
19484
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
19485
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
19486
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
19487
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
19488
+ }, undefined>, undefined>;
17366
19489
  }, undefined>, v.CheckAction<{
17367
19490
  address: string;
17368
19491
  publicKey: string;
@@ -17388,6 +19511,11 @@ declare const networkChangeSchema: v.ObjectSchema<{
17388
19511
  controlBlock: string;
17389
19512
  }[];
17390
19513
  } | undefined;
19514
+ stacksMultisig?: {
19515
+ hashMode: "P2SHNonSequential";
19516
+ threshold: number;
19517
+ publicKeys: string[];
19518
+ } | undefined;
17391
19519
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
17392
19520
  address: string;
17393
19521
  publicKey: string;
@@ -17413,7 +19541,42 @@ declare const networkChangeSchema: v.ObjectSchema<{
17413
19541
  controlBlock: string;
17414
19542
  }[];
17415
19543
  } | undefined;
17416
- }, "unlockDefinition type does not match addressType">]>, undefined>, undefined>;
19544
+ stacksMultisig?: {
19545
+ hashMode: "P2SHNonSequential";
19546
+ threshold: number;
19547
+ publicKeys: string[];
19548
+ } | undefined;
19549
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
19550
+ address: string;
19551
+ publicKey: string;
19552
+ purpose: AddressPurpose;
19553
+ addressType: AddressType;
19554
+ walletType: "software" | "ledger" | "keystone" | "multisig";
19555
+ scriptPubKey?: string | undefined;
19556
+ unlockDefinition?: {
19557
+ type: "p2wpkh";
19558
+ } | {
19559
+ type: "p2sh-p2wpkh";
19560
+ redeemScript: string;
19561
+ } | {
19562
+ type: "p2tr-key-path";
19563
+ tapInternalKey: string;
19564
+ } | {
19565
+ type: "p2wsh";
19566
+ witnessScript: string;
19567
+ } | {
19568
+ type: "p2tr-script-path";
19569
+ tapLeafScript: {
19570
+ script: string;
19571
+ controlBlock: string;
19572
+ }[];
19573
+ } | undefined;
19574
+ stacksMultisig?: {
19575
+ hashMode: "P2SHNonSequential";
19576
+ threshold: number;
19577
+ publicKeys: string[];
19578
+ } | undefined;
19579
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>, undefined>;
17417
19580
  }, undefined>;
17418
19581
  type NetworkChangeEvent = v.InferOutput<typeof networkChangeSchema>;
17419
19582
  declare const networkChangeEventNameV2 = "networkChangeV2";
@@ -17520,6 +19683,11 @@ declare const networkChangeV2Schema: v.ObjectSchema<{
17520
19683
  controlBlock: string;
17521
19684
  }[], 1, undefined>]>;
17522
19685
  }, undefined>], undefined>, undefined>;
19686
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
19687
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
19688
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
19689
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
19690
+ }, undefined>, undefined>;
17523
19691
  }, undefined>, v.CheckAction<{
17524
19692
  address: string;
17525
19693
  publicKey: string;
@@ -17545,6 +19713,11 @@ declare const networkChangeV2Schema: v.ObjectSchema<{
17545
19713
  controlBlock: string;
17546
19714
  }[];
17547
19715
  } | undefined;
19716
+ stacksMultisig?: {
19717
+ hashMode: "P2SHNonSequential";
19718
+ threshold: number;
19719
+ publicKeys: string[];
19720
+ } | undefined;
17548
19721
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
17549
19722
  address: string;
17550
19723
  publicKey: string;
@@ -17570,7 +19743,42 @@ declare const networkChangeV2Schema: v.ObjectSchema<{
17570
19743
  controlBlock: string;
17571
19744
  }[];
17572
19745
  } | undefined;
17573
- }, "unlockDefinition type does not match addressType">]>, undefined>, undefined>;
19746
+ stacksMultisig?: {
19747
+ hashMode: "P2SHNonSequential";
19748
+ threshold: number;
19749
+ publicKeys: string[];
19750
+ } | undefined;
19751
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
19752
+ address: string;
19753
+ publicKey: string;
19754
+ purpose: AddressPurpose;
19755
+ addressType: AddressType;
19756
+ walletType: "software" | "ledger" | "keystone" | "multisig";
19757
+ scriptPubKey?: string | undefined;
19758
+ unlockDefinition?: {
19759
+ type: "p2wpkh";
19760
+ } | {
19761
+ type: "p2sh-p2wpkh";
19762
+ redeemScript: string;
19763
+ } | {
19764
+ type: "p2tr-key-path";
19765
+ tapInternalKey: string;
19766
+ } | {
19767
+ type: "p2wsh";
19768
+ witnessScript: string;
19769
+ } | {
19770
+ type: "p2tr-script-path";
19771
+ tapLeafScript: {
19772
+ script: string;
19773
+ controlBlock: string;
19774
+ }[];
19775
+ } | undefined;
19776
+ stacksMultisig?: {
19777
+ hashMode: "P2SHNonSequential";
19778
+ threshold: number;
19779
+ publicKeys: string[];
19780
+ } | undefined;
19781
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>, undefined>;
17574
19782
  }, undefined>;
17575
19783
  type NetworkChangeEventV2 = v.InferOutput<typeof networkChangeSchema>;
17576
19784
  declare const disconnectEventName = "disconnect";
@@ -17611,6 +19819,11 @@ declare const walletEventSchema: v.VariantSchema<"type", [v.ObjectSchema<{
17611
19819
  controlBlock: string;
17612
19820
  }[], 1, undefined>]>;
17613
19821
  }, undefined>], undefined>, undefined>;
19822
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
19823
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
19824
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
19825
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
19826
+ }, undefined>, undefined>;
17614
19827
  }, undefined>, v.CheckAction<{
17615
19828
  address: string;
17616
19829
  publicKey: string;
@@ -17636,6 +19849,11 @@ declare const walletEventSchema: v.VariantSchema<"type", [v.ObjectSchema<{
17636
19849
  controlBlock: string;
17637
19850
  }[];
17638
19851
  } | undefined;
19852
+ stacksMultisig?: {
19853
+ hashMode: "P2SHNonSequential";
19854
+ threshold: number;
19855
+ publicKeys: string[];
19856
+ } | undefined;
17639
19857
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
17640
19858
  address: string;
17641
19859
  publicKey: string;
@@ -17661,7 +19879,42 @@ declare const walletEventSchema: v.VariantSchema<"type", [v.ObjectSchema<{
17661
19879
  controlBlock: string;
17662
19880
  }[];
17663
19881
  } | undefined;
17664
- }, "unlockDefinition type does not match addressType">]>, undefined>, undefined>;
19882
+ stacksMultisig?: {
19883
+ hashMode: "P2SHNonSequential";
19884
+ threshold: number;
19885
+ publicKeys: string[];
19886
+ } | undefined;
19887
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
19888
+ address: string;
19889
+ publicKey: string;
19890
+ purpose: AddressPurpose;
19891
+ addressType: AddressType;
19892
+ walletType: "software" | "ledger" | "keystone" | "multisig";
19893
+ scriptPubKey?: string | undefined;
19894
+ unlockDefinition?: {
19895
+ type: "p2wpkh";
19896
+ } | {
19897
+ type: "p2sh-p2wpkh";
19898
+ redeemScript: string;
19899
+ } | {
19900
+ type: "p2tr-key-path";
19901
+ tapInternalKey: string;
19902
+ } | {
19903
+ type: "p2wsh";
19904
+ witnessScript: string;
19905
+ } | {
19906
+ type: "p2tr-script-path";
19907
+ tapLeafScript: {
19908
+ script: string;
19909
+ controlBlock: string;
19910
+ }[];
19911
+ } | undefined;
19912
+ stacksMultisig?: {
19913
+ hashMode: "P2SHNonSequential";
19914
+ threshold: number;
19915
+ publicKeys: string[];
19916
+ } | undefined;
19917
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>, undefined>;
17665
19918
  }, undefined>, v.ObjectSchema<{
17666
19919
  readonly type: v.LiteralSchema<"networkChange", undefined>;
17667
19920
  readonly bitcoin: v.ObjectSchema<{
@@ -17701,6 +19954,11 @@ declare const walletEventSchema: v.VariantSchema<"type", [v.ObjectSchema<{
17701
19954
  controlBlock: string;
17702
19955
  }[], 1, undefined>]>;
17703
19956
  }, undefined>], undefined>, undefined>;
19957
+ readonly stacksMultisig: v.OptionalSchema<v.ObjectSchema<{
19958
+ readonly hashMode: v.LiteralSchema<"P2SHNonSequential", undefined>;
19959
+ readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
19960
+ readonly publicKeys: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
19961
+ }, undefined>, undefined>;
17704
19962
  }, undefined>, v.CheckAction<{
17705
19963
  address: string;
17706
19964
  publicKey: string;
@@ -17726,6 +19984,11 @@ declare const walletEventSchema: v.VariantSchema<"type", [v.ObjectSchema<{
17726
19984
  controlBlock: string;
17727
19985
  }[];
17728
19986
  } | undefined;
19987
+ stacksMultisig?: {
19988
+ hashMode: "P2SHNonSequential";
19989
+ threshold: number;
19990
+ publicKeys: string[];
19991
+ } | undefined;
17729
19992
  }, "scriptPubKey and unlockDefinition must both be present or both be absent">, v.CheckAction<{
17730
19993
  address: string;
17731
19994
  publicKey: string;
@@ -17751,7 +20014,42 @@ declare const walletEventSchema: v.VariantSchema<"type", [v.ObjectSchema<{
17751
20014
  controlBlock: string;
17752
20015
  }[];
17753
20016
  } | undefined;
17754
- }, "unlockDefinition type does not match addressType">]>, undefined>, undefined>;
20017
+ stacksMultisig?: {
20018
+ hashMode: "P2SHNonSequential";
20019
+ threshold: number;
20020
+ publicKeys: string[];
20021
+ } | undefined;
20022
+ }, "unlockDefinition type does not match addressType">, v.CheckAction<{
20023
+ address: string;
20024
+ publicKey: string;
20025
+ purpose: AddressPurpose;
20026
+ addressType: AddressType;
20027
+ walletType: "software" | "ledger" | "keystone" | "multisig";
20028
+ scriptPubKey?: string | undefined;
20029
+ unlockDefinition?: {
20030
+ type: "p2wpkh";
20031
+ } | {
20032
+ type: "p2sh-p2wpkh";
20033
+ redeemScript: string;
20034
+ } | {
20035
+ type: "p2tr-key-path";
20036
+ tapInternalKey: string;
20037
+ } | {
20038
+ type: "p2wsh";
20039
+ witnessScript: string;
20040
+ } | {
20041
+ type: "p2tr-script-path";
20042
+ tapLeafScript: {
20043
+ script: string;
20044
+ controlBlock: string;
20045
+ }[];
20046
+ } | undefined;
20047
+ stacksMultisig?: {
20048
+ hashMode: "P2SHNonSequential";
20049
+ threshold: number;
20050
+ publicKeys: string[];
20051
+ } | undefined;
20052
+ }, "stacksMultisig is only valid on multisig Stacks addresses">]>, undefined>, undefined>;
17755
20053
  }, undefined>, v.ObjectSchema<{
17756
20054
  readonly type: v.LiteralSchema<"disconnect", undefined>;
17757
20055
  }, undefined>], undefined>;
@@ -17847,4 +20145,4 @@ declare class BaseAdapter extends SatsConnectAdapter {
17847
20145
  declare const DefaultAdaptersInfo: Record<string, Provider>;
17848
20146
  declare const defaultAdapters: Record<string, new () => SatsConnectAdapter>;
17849
20147
  //#endregion
17850
- 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, 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, 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, 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 };
20148
+ 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 };