@arkade-os/swap 0.1.7 → 0.1.8

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.
Files changed (41) hide show
  1. package/dist/advanced.cjs +625 -249
  2. package/dist/advanced.d.cts +9 -8
  3. package/dist/advanced.d.ts +9 -8
  4. package/dist/advanced.js +4 -3
  5. package/dist/chunk-5QPJWOCN.js +16 -0
  6. package/dist/{chunk-QFM55KP2.js → chunk-ISWLKKSS.js} +1 -1
  7. package/dist/{chunk-7BBQ74BG.js → chunk-PDNVKH5L.js} +464 -117
  8. package/dist/{chunk-SDPNWPGY.js → chunk-ZBJGLLYV.js} +27 -16
  9. package/dist/index.cjs +641 -265
  10. package/dist/index.d.cts +7 -6
  11. package/dist/index.d.ts +7 -6
  12. package/dist/index.js +4 -3
  13. package/dist/{lockupContract-CKPFpIt9.d.ts → lockupContract-BUOsghl1.d.ts} +1 -1
  14. package/dist/{lockupContract-CpJXTjX_.d.cts → lockupContract-DguuT7NK.d.cts} +1 -1
  15. package/dist/nostr.cjs +290 -17
  16. package/dist/nostr.d.cts +2 -1
  17. package/dist/nostr.d.ts +2 -1
  18. package/dist/nostr.js +2 -1
  19. package/dist/{offer-Drw1k_jt.d.ts → offer-BhonWuKR.d.ts} +22 -17
  20. package/dist/{offer-Boxive2u.d.cts → offer-D_qHpWo2.d.cts} +22 -17
  21. package/dist/{offerFillPlan-BxNkWLtw.d.cts → offerFillPlan-Bp6-z6dS.d.cts} +3 -3
  22. package/dist/{offerFillPlan-D2N4s7Xe.d.ts → offerFillPlan-_AOLo6kh.d.ts} +3 -3
  23. package/dist/protocol.cjs +566 -185
  24. package/dist/protocol.d.cts +9 -8
  25. package/dist/protocol.d.ts +9 -8
  26. package/dist/protocol.js +14 -2
  27. package/dist/repositories/realm/index.d.cts +3 -2
  28. package/dist/repositories/realm/index.d.ts +3 -2
  29. package/dist/repositories/sqlite/index.d.cts +3 -2
  30. package/dist/repositories/sqlite/index.d.ts +3 -2
  31. package/dist/{repository-DFDNvcZ7.d.cts → repository--pfikw2R.d.cts} +1 -1
  32. package/dist/{repository-Dn1V17T2.d.ts → repository-CkKK0dGO.d.ts} +1 -1
  33. package/dist/{rfq-CP-P0PSL.d.ts → rfq-BRpo5uWU.d.cts} +14 -2
  34. package/dist/{rfq-CP-P0PSL.d.cts → rfq-IzhOCG02.d.ts} +14 -2
  35. package/dist/rfq-contract.cjs +45 -0
  36. package/dist/rfq-contract.d.cts +9 -0
  37. package/dist/rfq-contract.d.ts +9 -0
  38. package/dist/rfq-contract.js +16 -0
  39. package/dist/{watch-D-mc_wfD.d.ts → watch-DDNycuUa.d.ts} +1 -1
  40. package/dist/{watch-DFNMY2K-.d.cts → watch-pvTVFp6-.d.cts} +1 -1
  41. package/package.json +13 -3
package/dist/index.cjs CHANGED
@@ -630,11 +630,248 @@ var init_lockupContract = __esm({
630
630
  }
631
631
  });
632
632
 
633
- // src/swap-want-asset.program.json
634
- var swap_want_asset_program_default;
635
- var init_swap_want_asset_program = __esm({
636
- "src/swap-want-asset.program.json"() {
637
- swap_want_asset_program_default = {
633
+ // src/contracts/asset-swap.json
634
+ var asset_swap_default;
635
+ var init_asset_swap = __esm({
636
+ "src/contracts/asset-swap.json"() {
637
+ asset_swap_default = {
638
+ formatVersion: 1,
639
+ contractName: "AssetSwap",
640
+ constructorInputs: [
641
+ {
642
+ name: "receiver",
643
+ type: "pubkey"
644
+ },
645
+ {
646
+ name: "amount",
647
+ type: "int"
648
+ },
649
+ {
650
+ name: "assetTxid",
651
+ type: "bytes32"
652
+ },
653
+ {
654
+ name: "assetGroupIndex",
655
+ type: "int"
656
+ },
657
+ {
658
+ name: "user",
659
+ type: "pubkey"
660
+ }
661
+ ],
662
+ functions: [
663
+ {
664
+ name: "fulfill",
665
+ arkade: {
666
+ inputs: [],
667
+ asm: [
668
+ "OP_PUSHCURRENTINPUTINDEX",
669
+ "OP_DUP",
670
+ "<assetTxid>",
671
+ "<assetGroupIndex>",
672
+ "OP_INSPECTOUTASSETLOOKUP",
673
+ "OP_VERIFY",
674
+ "<amount>",
675
+ "OP_GREATERTHANOREQUAL",
676
+ "OP_VERIFY",
677
+ "OP_INSPECTOUTPUTSCRIPTPUBKEY",
678
+ "1",
679
+ "OP_NUMEQUALVERIFY",
680
+ "<receiver>",
681
+ "OP_EQUAL"
682
+ ]
683
+ },
684
+ leaves: [
685
+ {
686
+ name: "fulfill",
687
+ witness: [
688
+ {
689
+ name: "serverSig",
690
+ type: "signature",
691
+ encoding: "schnorr-64",
692
+ injected: true
693
+ },
694
+ {
695
+ name: "emulatorSig",
696
+ type: "signature",
697
+ encoding: "schnorr-64",
698
+ injected: true
699
+ }
700
+ ],
701
+ asm: [
702
+ "<SERVER_KEY>",
703
+ "OP_CHECKSIGVERIFY",
704
+ "<EMULATOR_KEY:fulfill>",
705
+ "OP_CHECKSIG"
706
+ ]
707
+ }
708
+ ]
709
+ },
710
+ {
711
+ name: "cancel",
712
+ leaves: [
713
+ {
714
+ name: "cancel",
715
+ witness: [
716
+ {
717
+ name: "userSig",
718
+ type: "signature",
719
+ encoding: "schnorr-64"
720
+ },
721
+ {
722
+ name: "serverSig",
723
+ type: "signature",
724
+ encoding: "schnorr-64",
725
+ injected: true
726
+ }
727
+ ],
728
+ asm: [
729
+ "<user>",
730
+ "OP_CHECKSIGVERIFY",
731
+ "<SERVER_KEY>",
732
+ "OP_CHECKSIG"
733
+ ]
734
+ }
735
+ ]
736
+ }
737
+ ],
738
+ source: {
739
+ entry: "asset-swap.ark",
740
+ files: {
741
+ "asset-swap.ark": "pragma arkade ^0.1.0;\n\n// The output at this input's index pays `receiver` at least `amount` of the asset.\n// Coordination of who funds it lives outside the contract.\ncontract AssetSwap(\n pubkey receiver,\n int amount,\n bytes32 assetTxid,\n int assetGroupIndex,\n pubkey user\n) {\n function fulfill() {\n int i = this.activeInputIndex;\n require(tx.outputs[i].assets.lookup(assetTxid, assetGroupIndex) >= amount);\n let paid = tx.outputs[i].script;\n require(paid.version == 1);\n require(paid.program == receiver);\n }\n\n function cancel(signature userSig, signature serverSig) tapscript {\n require(checkMultisig([user, server], [userSig, serverSig], 2));\n }\n}\n"
742
+ }
743
+ },
744
+ compiler: {
745
+ name: "arkadec",
746
+ version: "0.1.0-rc.1",
747
+ options: {
748
+ optimize: true
749
+ }
750
+ },
751
+ updatedAt: "2026-11-02T17:43:42.615113722+00:00",
752
+ fingerprint: "sha256:e2b80add6237f6c7e2c69a96ae46d55abe6de5f71c3718106f4d5b22ac9e6d0a"
753
+ };
754
+ }
755
+ });
756
+
757
+ // src/contracts/sats-swap.json
758
+ var sats_swap_default;
759
+ var init_sats_swap = __esm({
760
+ "src/contracts/sats-swap.json"() {
761
+ sats_swap_default = {
762
+ formatVersion: 1,
763
+ contractName: "SatsSwap",
764
+ constructorInputs: [
765
+ {
766
+ name: "receiver",
767
+ type: "pubkey"
768
+ },
769
+ {
770
+ name: "amount",
771
+ type: "int"
772
+ },
773
+ {
774
+ name: "user",
775
+ type: "pubkey"
776
+ }
777
+ ],
778
+ functions: [
779
+ {
780
+ name: "fulfill",
781
+ arkade: {
782
+ inputs: [],
783
+ asm: [
784
+ "OP_PUSHCURRENTINPUTINDEX",
785
+ "OP_DUP",
786
+ "OP_INSPECTOUTPUTVALUE",
787
+ "<amount>",
788
+ "OP_GREATERTHANOREQUAL",
789
+ "OP_VERIFY",
790
+ "OP_INSPECTOUTPUTSCRIPTPUBKEY",
791
+ "1",
792
+ "OP_NUMEQUALVERIFY",
793
+ "<receiver>",
794
+ "OP_EQUAL"
795
+ ]
796
+ },
797
+ leaves: [
798
+ {
799
+ name: "fulfill",
800
+ witness: [
801
+ {
802
+ name: "serverSig",
803
+ type: "signature",
804
+ encoding: "schnorr-64",
805
+ injected: true
806
+ },
807
+ {
808
+ name: "emulatorSig",
809
+ type: "signature",
810
+ encoding: "schnorr-64",
811
+ injected: true
812
+ }
813
+ ],
814
+ asm: [
815
+ "<SERVER_KEY>",
816
+ "OP_CHECKSIGVERIFY",
817
+ "<EMULATOR_KEY:fulfill>",
818
+ "OP_CHECKSIG"
819
+ ]
820
+ }
821
+ ]
822
+ },
823
+ {
824
+ name: "cancel",
825
+ leaves: [
826
+ {
827
+ name: "cancel",
828
+ witness: [
829
+ {
830
+ name: "userSig",
831
+ type: "signature",
832
+ encoding: "schnorr-64"
833
+ },
834
+ {
835
+ name: "serverSig",
836
+ type: "signature",
837
+ encoding: "schnorr-64",
838
+ injected: true
839
+ }
840
+ ],
841
+ asm: [
842
+ "<user>",
843
+ "OP_CHECKSIGVERIFY",
844
+ "<SERVER_KEY>",
845
+ "OP_CHECKSIG"
846
+ ]
847
+ }
848
+ ]
849
+ }
850
+ ],
851
+ source: {
852
+ entry: "sats-swap.ark",
853
+ files: {
854
+ "sats-swap.ark": "pragma arkade ^0.1.0;\n\n// The output at this input's index pays `receiver` at least `amount` sats.\n// Coordination of who funds it lives outside the contract.\ncontract SatsSwap(\n pubkey receiver,\n int amount,\n pubkey user\n) {\n function fulfill() {\n int i = this.activeInputIndex;\n require(tx.outputs[i].value >= amount);\n let paid = tx.outputs[i].script;\n require(paid.version == 1);\n require(paid.program == receiver);\n }\n\n function cancel(signature userSig, signature serverSig) tapscript {\n require(checkMultisig([user, server], [userSig, serverSig], 2));\n }\n}\n"
855
+ }
856
+ },
857
+ compiler: {
858
+ name: "arkadec",
859
+ version: "0.1.0-rc.1",
860
+ options: {
861
+ optimize: true
862
+ }
863
+ },
864
+ updatedAt: "2026-11-02T17:43:42.616824535+00:00",
865
+ fingerprint: "sha256:d7a60ab2178ede40a2e4867816689ea022641531cc662b562bebd7caa1ef96c4"
866
+ };
867
+ }
868
+ });
869
+
870
+ // src/legacy/swap-want-asset.program.v1.json
871
+ var swap_want_asset_program_v1_default;
872
+ var init_swap_want_asset_program_v1 = __esm({
873
+ "src/legacy/swap-want-asset.program.v1.json"() {
874
+ swap_want_asset_program_v1_default = {
638
875
  version: 1,
639
876
  name: "banco-btc-to-asset",
640
877
  params: [
@@ -675,11 +912,11 @@ var init_swap_want_asset_program = __esm({
675
912
  }
676
913
  });
677
914
 
678
- // src/swap-want-btc.program.json
679
- var swap_want_btc_program_default;
680
- var init_swap_want_btc_program = __esm({
681
- "src/swap-want-btc.program.json"() {
682
- swap_want_btc_program_default = {
915
+ // src/legacy/swap-want-btc.program.v1.json
916
+ var swap_want_btc_program_v1_default;
917
+ var init_swap_want_btc_program_v1 = __esm({
918
+ "src/legacy/swap-want-btc.program.v1.json"() {
919
+ swap_want_btc_program_v1_default = {
683
920
  version: 1,
684
921
  name: "banco-asset-to-btc",
685
922
  params: [
@@ -715,6 +952,80 @@ var init_swap_want_btc_program = __esm({
715
952
  }
716
953
  });
717
954
 
955
+ // src/rfq-contract.ts
956
+ var RFQ_CONTRACT_VERSIONS_KEY, RFQ_CONTRACT_VERSION_KEY, RFQ_CONTRACT_VERSION_UNSUPPORTED, ASSET_SWAP_V2, ASSET_SWAP_V3, ASSET_SWAP_BASELINE;
957
+ var init_rfq_contract = __esm({
958
+ "src/rfq-contract.ts"() {
959
+ "use strict";
960
+ RFQ_CONTRACT_VERSIONS_KEY = "contract_versions";
961
+ RFQ_CONTRACT_VERSION_KEY = "contract_version";
962
+ RFQ_CONTRACT_VERSION_UNSUPPORTED = "contract_version_unsupported";
963
+ ASSET_SWAP_V2 = "asset-swap-v2";
964
+ ASSET_SWAP_V3 = "asset-swap-v3";
965
+ ASSET_SWAP_BASELINE = ASSET_SWAP_V2;
966
+ }
967
+ });
968
+
969
+ // src/program.ts
970
+ var import_sdk4, swapPrograms, legacySwapPrograms, sharedArgs, ASSET_SWAP_CONTRACTS, ASSET_SWAP_CONTRACT_VERSIONS, assetSwapContractVersion;
971
+ var init_program = __esm({
972
+ "src/program.ts"() {
973
+ "use strict";
974
+ import_sdk4 = require("@arkade-os/sdk");
975
+ init_asset_swap();
976
+ init_sats_swap();
977
+ init_swap_want_asset_program_v1();
978
+ init_swap_want_btc_program_v1();
979
+ init_rfq_contract();
980
+ init_rfq_contract();
981
+ swapPrograms = {
982
+ wantAsset: import_sdk4.arkade.programFromArtifact(asset_swap_default),
983
+ wantBtc: import_sdk4.arkade.programFromArtifact(sats_swap_default)
984
+ };
985
+ legacySwapPrograms = {
986
+ wantAsset: import_sdk4.arkade.parseArtifact(swap_want_asset_program_v1_default),
987
+ wantBtc: import_sdk4.arkade.parseArtifact(swap_want_btc_program_v1_default)
988
+ };
989
+ sharedArgs = ({ user, server, exitDelay }) => ({
990
+ user,
991
+ server,
992
+ ...exitDelay && { exitDelay }
993
+ });
994
+ ASSET_SWAP_CONTRACTS = {
995
+ [ASSET_SWAP_V2]: {
996
+ programs: legacySwapPrograms,
997
+ args: (inputs) => ({
998
+ makerWP: inputs.receiver,
999
+ wantAmount: inputs.amount,
1000
+ ...inputs.asset && {
1001
+ wantAssetTxid: inputs.asset.txid,
1002
+ wantAssetGroupIndex: inputs.asset.groupIndex
1003
+ },
1004
+ ...sharedArgs(inputs)
1005
+ })
1006
+ },
1007
+ [ASSET_SWAP_V3]: {
1008
+ programs: swapPrograms,
1009
+ args: (inputs) => ({
1010
+ receiver: inputs.receiver,
1011
+ amount: inputs.amount,
1012
+ ...inputs.asset && {
1013
+ assetTxid: inputs.asset.txid,
1014
+ assetGroupIndex: inputs.asset.groupIndex
1015
+ },
1016
+ ...sharedArgs(inputs)
1017
+ })
1018
+ }
1019
+ };
1020
+ ASSET_SWAP_CONTRACT_VERSIONS = [ASSET_SWAP_V3, ASSET_SWAP_V2];
1021
+ assetSwapContractVersion = (id) => {
1022
+ if (id === void 0) return ASSET_SWAP_BASELINE;
1023
+ if (Object.hasOwn(ASSET_SWAP_CONTRACTS, id)) return id;
1024
+ throw new Error(`unknown contract version ${id}`);
1025
+ };
1026
+ }
1027
+ });
1028
+
718
1029
  // src/rfqCorridor.ts
719
1030
  var RfqCorridorRegistry, rfqCorridorHandlers;
720
1031
  var init_rfqCorridor = __esm({
@@ -758,13 +1069,13 @@ var init_rfqCorridor = __esm({
758
1069
  });
759
1070
 
760
1071
  // src/store.ts
761
- var import_base4, import_sha23, import_sdk4, BTC_ASSET_ID, byNewest, getAssetSwapsOrThrow, getAssetSwaps, saveSwapOrThrow, updateAssetSwap, updateAssetSwapBestEffort, swapSecretsToRecord, decodeHex32, PreimageNotRecoverableError, preimageForSwapRecord;
1072
+ var import_base4, import_sha23, import_sdk5, BTC_ASSET_ID, byNewest, getAssetSwapsOrThrow, getAssetSwaps, saveSwapOrThrow, updateAssetSwap, updateAssetSwapBestEffort, swapSecretsToRecord, decodeHex32, PreimageNotRecoverableError, preimageForSwapRecord;
762
1073
  var init_store = __esm({
763
1074
  "src/store.ts"() {
764
1075
  "use strict";
765
1076
  import_base4 = require("@scure/base");
766
1077
  import_sha23 = require("@noble/hashes/sha2.js");
767
- import_sdk4 = require("@arkade-os/sdk");
1078
+ import_sdk5 = require("@arkade-os/sdk");
768
1079
  init_repository();
769
1080
  BTC_ASSET_ID = "btc";
770
1081
  byNewest = (a, b) => b.createdAt - a.createdAt;
@@ -850,7 +1161,7 @@ var init_store = __esm({
850
1161
  }
851
1162
  let preimage;
852
1163
  try {
853
- preimage = await (0, import_sdk4.contractPreimage)(wallet, record.signingDescriptor, { stored, salt });
1164
+ preimage = await (0, import_sdk5.contractPreimage)(wallet, record.signingDescriptor, { stored, salt });
854
1165
  } catch (cause) {
855
1166
  throw new PreimageNotRecoverableError(
856
1167
  "not-derivable",
@@ -975,37 +1286,60 @@ function withExitClosure(program, exit) {
975
1286
  }
976
1287
  };
977
1288
  }
978
- function swapProgramBinding(offer, operatorPubkey) {
1289
+ function swapProgramBinding(offer, operatorPubkey, contractVersion = ASSET_SWAP_BASELINE) {
979
1290
  if (offer.makerPkScript.length !== FIELDS.makerPkScript.width) {
980
1291
  throw new Error("makerPkScript is not a 34-byte taproot scriptPubKey");
981
1292
  }
1293
+ const expected = offer.swapPkScript;
1294
+ if (!expected?.length) return bindSwapProgram(offer, operatorPubkey, contractVersion);
1295
+ const funded = import_base5.hex.encode(expected);
1296
+ const order = [
1297
+ ASSET_SWAP_BASELINE,
1298
+ ...ASSET_SWAP_CONTRACT_VERSIONS.filter((v) => v !== ASSET_SWAP_BASELINE)
1299
+ ];
1300
+ for (const version of order) {
1301
+ const binding = bindSwapProgram(offer, operatorPubkey, version);
1302
+ if (pkOf(binding) === funded) return binding;
1303
+ }
1304
+ return bindSwapProgram(offer, operatorPubkey, contractVersion);
1305
+ }
1306
+ function bindSwapProgram(offer, operatorPubkey, contractVersion) {
1307
+ const { programs, args } = ASSET_SWAP_CONTRACTS[contractVersion];
1308
+ const user = offer.makerPublicKey;
1309
+ const assetId = offer.wantAsset;
982
1310
  return {
983
- program: withExitClosure(
984
- offer.wantAsset ? swapPrograms.wantAsset : swapPrograms.wantBtc,
985
- offer.exitDelay
986
- ),
987
- args: {
988
- makerWP: offer.makerPkScript.subarray(2),
989
- wantAmount: offer.wantAmount,
990
- server: operatorPubkey,
991
- user: offer.makerPublicKey,
1311
+ program: withExitClosure(assetId ? programs.wantAsset : programs.wantBtc, offer.exitDelay),
1312
+ args: args({
1313
+ receiver: offer.makerPkScript.subarray(2),
1314
+ amount: offer.wantAmount,
992
1315
  // internal byte order
993
- ...offer.wantAsset && {
994
- wantAssetTxid: offer.wantAsset.txid.slice().reverse(),
995
- wantAssetGroupIndex: offer.wantAsset.groupIndex
1316
+ ...assetId && {
1317
+ asset: { txid: assetId.txid.slice().reverse(), groupIndex: assetId.groupIndex }
996
1318
  },
1319
+ user,
1320
+ server: operatorPubkey,
997
1321
  ...offer.exitDelay && { exitDelay: offer.exitDelay.value }
998
- },
1322
+ }),
999
1323
  keys: {
1000
1324
  serverKey: operatorPubkey,
1001
- userKey: offer.makerPublicKey,
1325
+ userKey: user,
1002
1326
  emulatorKey: offer.emulatorPubkey
1003
1327
  }
1004
1328
  };
1005
1329
  }
1006
- function offerContract(offer, operatorPubkey) {
1007
- const { program, args, keys } = swapProgramBinding(offer, operatorPubkey);
1008
- return new import_sdk5.arkade.ArkadeProgramScript(program, args, keys);
1330
+ function compileSwapBinding(binding) {
1331
+ let script = compiledBindings.get(binding);
1332
+ if (!script) {
1333
+ script = new import_sdk6.arkade.ArkadeProgramScript(binding.program, binding.args, binding.keys);
1334
+ compiledBindings.set(binding, script);
1335
+ }
1336
+ return script;
1337
+ }
1338
+ function pkOf(binding) {
1339
+ return import_base5.hex.encode(compileSwapBinding(binding).pkScript);
1340
+ }
1341
+ function offerContract(offer, operatorPubkey, contractVersion) {
1342
+ return compileSwapBinding(swapProgramBinding(offer, operatorPubkey, contractVersion));
1009
1343
  }
1010
1344
  function u64(name, value) {
1011
1345
  if (value < BigInt(0) || value >> BigInt(64) > BigInt(0)) {
@@ -1121,8 +1455,8 @@ function decodeOffer(data) {
1121
1455
  return {
1122
1456
  swapPkScript: need("swapPkScript"),
1123
1457
  wantAmount: readU64(amount),
1124
- ...fields.wantAsset && { wantAsset: import_sdk5.asset.AssetId.fromBytes(fields.wantAsset) },
1125
- ...fields.offerAsset && { offerAsset: import_sdk5.asset.AssetId.fromBytes(fields.offerAsset) },
1458
+ ...fields.wantAsset && { wantAsset: import_sdk6.asset.AssetId.fromBytes(fields.wantAsset) },
1459
+ ...fields.offerAsset && { offerAsset: import_sdk6.asset.AssetId.fromBytes(fields.offerAsset) },
1126
1460
  makerPkScript: need("makerPkScript"),
1127
1461
  makerPublicKey: need("makerPublicKey"),
1128
1462
  emulatorPubkey: need("emulatorPubkey"),
@@ -1148,8 +1482,11 @@ async function registerOfferContract(wallet, info, binding, operatorPubkey, expe
1148
1482
  });
1149
1483
  }
1150
1484
  function offerContractParams(client, binding, operatorPubkey, expectedPkScript) {
1151
- const { program, args, keys } = swapProgramBinding(binding, operatorPubkey);
1152
- const contract = new import_sdk5.arkade.ArkadeContract(client, program, args, keys);
1485
+ const { program, args, keys } = swapProgramBinding(
1486
+ { ...binding, swapPkScript: expectedPkScript },
1487
+ operatorPubkey
1488
+ );
1489
+ const contract = new import_sdk6.arkade.ArkadeContract(client, program, args, keys);
1153
1490
  if (import_base5.hex.encode(contract.pkScript) !== import_base5.hex.encode(expectedPkScript)) {
1154
1491
  throw new Error("derived covenant does not match the offer's swapPkScript");
1155
1492
  }
@@ -1166,7 +1503,7 @@ async function restoreOfferCoverage(wallet, swaps) {
1166
1503
  wallet.getArkadeInfo({ requireLive: true }),
1167
1504
  wallet.getContractManager()
1168
1505
  ]);
1169
- const operatorPubkey = import_base5.hex.decode((0, import_sdk5.toXOnlySignerHex)(info.signerPubkey));
1506
+ const operatorPubkey = import_base5.hex.decode((0, import_sdk6.toXOnlySignerHex)(info.signerPubkey));
1170
1507
  const client = await derivingClient(wallet, info, contractManager);
1171
1508
  const rows = await contractManager.getContracts({
1172
1509
  script: live.map((swap) => swap.swapPkScript)
@@ -1189,7 +1526,7 @@ async function restoreOfferCoverage(wallet, swaps) {
1189
1526
  params: offerContractParams(
1190
1527
  client,
1191
1528
  binding,
1192
- stored ? import_base5.hex.decode((0, import_sdk5.toXOnlySignerHex)(stored)) : operatorPubkey,
1529
+ stored ? import_base5.hex.decode((0, import_sdk6.toXOnlySignerHex)(stored)) : operatorPubkey,
1193
1530
  import_base5.hex.decode(swap.swapPkScript)
1194
1531
  )
1195
1532
  });
@@ -1233,7 +1570,7 @@ function resolveReceivePkScript(receiveAddress, walletPkScript, hrp, serverPubKe
1233
1570
  if (receiveAddress === void 0) return walletPkScript;
1234
1571
  let address;
1235
1572
  try {
1236
- address = import_sdk5.ArkAddress.decode(receiveAddress);
1573
+ address = import_sdk6.ArkAddress.decode(receiveAddress);
1237
1574
  } catch (cause) {
1238
1575
  throw new Error("receiveAddress is not a valid Arkade address", { cause });
1239
1576
  }
@@ -1268,13 +1605,13 @@ async function deriveOffer(wallet, params) {
1268
1605
  wallet.getAddress(),
1269
1606
  wallet.identity.xOnlyPublicKey()
1270
1607
  ]);
1271
- return { pkScript: import_sdk5.ArkAddress.decode(address).pkScript, publicKey };
1608
+ return { pkScript: import_sdk6.ArkAddress.decode(address).pkScript, publicKey };
1272
1609
  })()
1273
1610
  ]);
1274
- const operatorPubKey = import_base5.hex.decode((0, import_sdk5.toXOnlySignerHex)(info.signerPubkey));
1275
- const network = (0, import_sdk5.networkFromOperatorInfo)(info);
1611
+ const operatorPubKey = import_base5.hex.decode((0, import_sdk6.toXOnlySignerHex)(info.signerPubkey));
1612
+ const network = (0, import_sdk6.networkFromOperatorInfo)(info);
1276
1613
  const emuKey = import_base5.hex.decode(
1277
- (0, import_sdk5.toXOnlySignerHex)((0, import_sdk5.resolveEmulatorPubkey)(network, params.emulatorPubkey))
1614
+ (0, import_sdk6.toXOnlySignerHex)((0, import_sdk6.resolveEmulatorPubkey)(network, params.emulatorPubkey))
1278
1615
  );
1279
1616
  const binding = Object.freeze({
1280
1617
  wantAmount: params.wantAmount,
@@ -1291,7 +1628,7 @@ async function deriveOffer(wallet, params) {
1291
1628
  // checked before registration below. @see assertExitDelay
1292
1629
  exitDelay: params.noExit ? void 0 : params.exitDelay ? assertExitDelay(params.exitDelay) : serverExitDelay(info.unilateralExitDelay)
1293
1630
  });
1294
- const script = offerContract(binding, operatorPubKey);
1631
+ const script = offerContract(binding, operatorPubKey, params.contractVersion);
1295
1632
  const offer = { ...binding, swapPkScript: script.pkScript };
1296
1633
  const payload = encodeOffer(offer);
1297
1634
  return Object.freeze({
@@ -1325,7 +1662,7 @@ async function prepareOfferCancel(wallet, offerHex, opts) {
1325
1662
  wallet.getArkadeReader(),
1326
1663
  wallet.getArkadeBroadcaster()
1327
1664
  ]);
1328
- const client = await import_sdk5.arkade.Arkade.connect({
1665
+ const client = await import_sdk6.arkade.Arkade.connect({
1329
1666
  arkade: { getInfo: async () => info, ...broadcaster },
1330
1667
  indexer: reader,
1331
1668
  identity: wallet.identity,
@@ -1335,21 +1672,22 @@ async function prepareOfferCancel(wallet, offerHex, opts) {
1335
1672
  // no `network`: the row lookup is by script and the payout comes from wallet.getAddress()
1336
1673
  oneShotSubmit: wallet.oneShotSubmit
1337
1674
  });
1338
- const operatorPubkey = swapAddress ? import_sdk5.ArkAddress.decode(swapAddress).serverPubKey : client.serverKey;
1339
- const { program, args, keys } = swapProgramBinding(offer, operatorPubkey);
1675
+ const operatorPubkey = swapAddress ? import_sdk6.ArkAddress.decode(swapAddress).serverPubKey : client.serverKey;
1676
+ let binding;
1340
1677
  let rebuilt;
1341
1678
  try {
1342
- rebuilt = new import_sdk5.arkade.ArkadeProgramScript(program, args, keys);
1679
+ binding = swapProgramBinding(offer, operatorPubkey);
1680
+ rebuilt = compileSwapBinding(binding);
1343
1681
  } catch (cause) {
1344
1682
  throw new OfferCovenantMismatchError(import_base5.hex.encode(offer.swapPkScript), { cause });
1345
1683
  }
1346
1684
  if (import_base5.hex.encode(rebuilt.pkScript) !== import_base5.hex.encode(offer.swapPkScript)) {
1347
1685
  throw new OfferCovenantMismatchError(import_base5.hex.encode(offer.swapPkScript));
1348
1686
  }
1349
- const contract = new import_sdk5.arkade.ArkadeContract(client, program, args, keys);
1687
+ const contract = new import_sdk6.arkade.ArkadeContract(client, binding.program, binding.args, binding.keys);
1350
1688
  const [vtxos, makerAddress] = await Promise.all([contract.getUtxos(), wallet.getAddress()]);
1351
1689
  const vtxo = resolveDeposit(vtxos, { fundingTxid, fundingOutpoint });
1352
- const makerPkScript = import_sdk5.ArkAddress.decode(makerAddress).pkScript;
1690
+ const makerPkScript = import_sdk6.ArkAddress.decode(makerAddress).pkScript;
1353
1691
  const cancel = contract.functions.cancel().from({ txid: vtxo.txid, vout: vtxo.vout, value: vtxo.value }).to(makerPkScript, BigInt(vtxo.value));
1354
1692
  for (const a of vtxo.assets ?? []) {
1355
1693
  cancel.withAsset({
@@ -1367,25 +1705,25 @@ async function prepareOfferCancel(wallet, offerHex, opts) {
1367
1705
  async function connectFillContract(wallet, arkServerUrl, offer, opts = {}) {
1368
1706
  const { swapAddress, emulator, emulatorPubkey } = opts;
1369
1707
  const contractManager = await wallet.getContractManager();
1370
- const client = await import_sdk5.arkade.Arkade.connect({
1371
- arkade: new import_sdk5.RestOperatorProvider(arkServerUrl),
1372
- indexer: new import_sdk5.RestIndexerProvider(arkServerUrl),
1708
+ const client = await import_sdk6.arkade.Arkade.connect({
1709
+ arkade: new import_sdk6.RestOperatorProvider(arkServerUrl),
1710
+ indexer: new import_sdk6.RestIndexerProvider(arkServerUrl),
1373
1711
  identity: wallet.identity,
1374
1712
  contractManager,
1375
1713
  ...emulator !== void 0 ? {
1376
- emulator: typeof emulator === "string" ? new import_sdk5.RestEmulatorProvider(emulator) : emulator
1714
+ emulator: typeof emulator === "string" ? new import_sdk6.RestEmulatorProvider(emulator) : emulator
1377
1715
  } : {},
1378
1716
  ...emulatorPubkey ? { emulatorPubkey } : {}
1379
1717
  });
1380
- const serverKey = swapAddress ? import_sdk5.ArkAddress.decode(swapAddress).serverPubKey : client.serverKey;
1381
- const { program, args, keys } = swapProgramBinding(offer, serverKey);
1382
- const rebuilt = new import_sdk5.arkade.ArkadeProgramScript(program, args, keys);
1718
+ const serverKey = swapAddress ? import_sdk6.ArkAddress.decode(swapAddress).serverPubKey : client.serverKey;
1719
+ const binding = swapProgramBinding(offer, serverKey);
1720
+ const rebuilt = compileSwapBinding(binding);
1383
1721
  if (import_base5.hex.encode(rebuilt.pkScript) !== import_base5.hex.encode(offer.swapPkScript)) {
1384
1722
  throw new Error(
1385
1723
  "rebuilt covenant does not match the offer's swapPkScript \u2014 the server signing key has likely rotated since funding; pass swapAddress (the funded address) to pin the original key"
1386
1724
  );
1387
1725
  }
1388
- return new import_sdk5.arkade.ArkadeContract(client, program, args, keys);
1726
+ return new import_sdk6.arkade.ArkadeContract(client, binding.program, binding.args, binding.keys);
1389
1727
  }
1390
1728
  function resolveDeposit(vtxos, sel) {
1391
1729
  const { fundingTxid, fundingOutpoint } = sel;
@@ -1674,7 +2012,7 @@ function assertScript(script, what) {
1674
2012
  function assertAssetId(assetId, what) {
1675
2013
  if (typeof assetId !== "string") throw new Error(`${what} must be an asset id string`);
1676
2014
  try {
1677
- return import_sdk5.asset.AssetId.fromString(assetId).toString();
2015
+ return import_sdk6.asset.AssetId.fromString(assetId).toString();
1678
2016
  } catch {
1679
2017
  throw new Error(`${what} is not a valid asset id`);
1680
2018
  }
@@ -1696,22 +2034,18 @@ function assertFillCoin(coin, what) {
1696
2034
  toAmount(coin.value, `${what}.value`, "sats", BigInt(1));
1697
2035
  assertAssetEntries(coin.assets, what);
1698
2036
  }
1699
- var import_base5, import_utils2, import_sdk5, swapPrograms, OFFER_PACKET_TYPE, FIELDS, EXIT_TYPES, NAMES, readU64, setRatio, OFFER_CONTRACT_LABEL, OFFER_CONTRACT_KIND, derivingClient, NoSpendableDepositError, OfferCovenantMismatchError, ASSET_CARRIER_SATS, amountOfAsset, U64_MAX, MAX_SAFE_SATS;
2037
+ var import_base5, import_utils2, import_sdk6, compiledBindings, OFFER_PACKET_TYPE, FIELDS, EXIT_TYPES, NAMES, readU64, setRatio, OFFER_CONTRACT_LABEL, OFFER_CONTRACT_KIND, derivingClient, NoSpendableDepositError, OfferCovenantMismatchError, ASSET_CARRIER_SATS, amountOfAsset, U64_MAX, MAX_SAFE_SATS;
1700
2038
  var init_offer = __esm({
1701
2039
  "src/offer.ts"() {
1702
2040
  "use strict";
1703
2041
  import_base5 = require("@scure/base");
1704
2042
  import_utils2 = require("@scure/btc-signer/utils.js");
1705
- import_sdk5 = require("@arkade-os/sdk");
1706
- init_swap_want_asset_program();
1707
- init_swap_want_btc_program();
2043
+ import_sdk6 = require("@arkade-os/sdk");
2044
+ init_program();
1708
2045
  init_coverage();
1709
2046
  init_rfqProfileParts();
1710
2047
  init_store();
1711
- swapPrograms = {
1712
- wantAsset: import_sdk5.arkade.parseArtifact(swap_want_asset_program_default),
1713
- wantBtc: import_sdk5.arkade.parseArtifact(swap_want_btc_program_default)
1714
- };
2048
+ compiledBindings = /* @__PURE__ */ new WeakMap();
1715
2049
  OFFER_PACKET_TYPE = 3;
1716
2050
  FIELDS = {
1717
2051
  swapPkScript: { tag: 1, width: 34 },
@@ -1735,10 +2069,10 @@ var init_offer = __esm({
1735
2069
  };
1736
2070
  OFFER_CONTRACT_LABEL = "Arkade swap offer";
1737
2071
  OFFER_CONTRACT_KIND = "asset-swap-offer";
1738
- derivingClient = (wallet, info, contractManager) => import_sdk5.arkade.Arkade.connect({
2072
+ derivingClient = (wallet, info, contractManager) => import_sdk6.arkade.Arkade.connect({
1739
2073
  arkade: { getInfo: async () => info },
1740
2074
  identity: wallet.identity,
1741
- network: (0, import_sdk5.networkFromOperatorInfo)(info),
2075
+ network: (0, import_sdk6.networkFromOperatorInfo)(info),
1742
2076
  contractManager
1743
2077
  });
1744
2078
  NoSpendableDepositError = class extends Error {
@@ -1758,7 +2092,7 @@ var init_offer = __esm({
1758
2092
  swapPkScript;
1759
2093
  name = "OfferCovenantMismatchError";
1760
2094
  };
1761
- ASSET_CARRIER_SATS = BigInt(import_sdk5.ASSET_CARRIER_SATS);
2095
+ ASSET_CARRIER_SATS = BigInt(import_sdk6.ASSET_CARRIER_SATS);
1762
2096
  amountOfAsset = (assets, assetId) => {
1763
2097
  let total = BigInt(0);
1764
2098
  for (const a of assets ?? []) {
@@ -1802,7 +2136,7 @@ function deriveLightningSend(input) {
1802
2136
  throw new Error("lightning-send quote is missing profile.receiver_pk_script");
1803
2137
  }
1804
2138
  const contractParams = {
1805
- solverPubkey: (0, import_sdk6.toXOnly)(import_base6.hex.decode(quote.solver_pubkey), "solver key"),
2139
+ solverPubkey: (0, import_sdk7.toXOnly)(import_base6.hex.decode(quote.solver_pubkey), "solver key"),
1806
2140
  refundLocktime: quote.refund_locktime,
1807
2141
  operatorPubkey: input.operatorPubkey,
1808
2142
  paymentHash: input.paymentHash,
@@ -1848,7 +2182,7 @@ function deriveOnchainSend(input) {
1848
2182
  "onchain-send"
1849
2183
  );
1850
2184
  const contractParams = {
1851
- solverPubkey: (0, import_sdk6.toXOnly)(import_base6.hex.decode(quote.solver_pubkey), "solver key"),
2185
+ solverPubkey: (0, import_sdk7.toXOnly)(import_base6.hex.decode(quote.solver_pubkey), "solver key"),
1852
2186
  refundLocktime,
1853
2187
  operatorPubkey: input.operatorPubkey,
1854
2188
  paymentHash: input.paymentHash,
@@ -1857,7 +2191,7 @@ function deriveOnchainSend(input) {
1857
2191
  emulatorPubkey: input.emulatorPubkey,
1858
2192
  senderPubkey: input.senderPubkey,
1859
2193
  receiverPkScript: solverHex(receiverPkScriptHex, "profile.receiver_pk_script"),
1860
- refundPkScript: import_sdk6.ArkAddress.decode(input.refundAddress).pkScript
2194
+ refundPkScript: import_sdk7.ArkAddress.decode(input.refundAddress).pkScript
1861
2195
  };
1862
2196
  const { script, address } = matchQuotedLockup(
1863
2197
  quote,
@@ -1868,7 +2202,7 @@ function deriveOnchainSend(input) {
1868
2202
  const htlcParams = {
1869
2203
  paymentHash: input.paymentHash,
1870
2204
  claimKey: input.payoutPubkey,
1871
- refundKey: (0, import_sdk6.toXOnly)(import_base6.hex.decode(htlcPubkey), "solver L1 htlc key"),
2205
+ refundKey: (0, import_sdk7.toXOnly)(import_base6.hex.decode(htlcPubkey), "solver L1 htlc key"),
1872
2206
  refundLocktime: htlcLocktime
1873
2207
  };
1874
2208
  const htlc = onchainHtlcScript(htlcParams, input.l1Network);
@@ -1940,7 +2274,7 @@ function deriveOnchainReceive(input) {
1940
2274
  ).matched;
1941
2275
  const htlcParams = {
1942
2276
  paymentHash: input.paymentHash,
1943
- claimKey: (0, import_sdk6.toXOnly)(import_base6.hex.decode(claimPubkey), "solver L1 claim key"),
2277
+ claimKey: (0, import_sdk7.toXOnly)(import_base6.hex.decode(claimPubkey), "solver L1 claim key"),
1944
2278
  refundKey: input.refundPubkey,
1945
2279
  refundLocktime: htlcLocktime
1946
2280
  };
@@ -1957,21 +2291,23 @@ function deriveOnchainReceive(input) {
1957
2291
  minConfirmations
1958
2292
  };
1959
2293
  }
1960
- var import_base6, import_solver_discovery, import_legacy2, import_sdk6, import_sdk7, solverHex, quoteSats, quoteAmountSats, quoteExpectedSats, ARKADE_BTC, LIGHTNING_BTC, ONCHAIN_BTC, arkadeAssetLeg, rfqPair, LIGHTNING_SEND_PAIR, LIGHTNING_RECEIVE_PAIR, ONCHAIN_SEND_PAIR, ONCHAIN_RECEIVE_PAIR, RFQ_REFUSAL_ERROR_CODES, isRfqRefusalErrorCode, REFUSAL_FIELDS, REFUSAL_UNITS, safeInteger, safeRefusalDetail, refusalMessage, SwapRefusal, AddressMismatch, newRfqId, lightningSendRequest, arkadeSwapRequest, canonicalAssetAmount, normalizeHexBytes, normalizeMakerPkScript, normalizeMakerPublicKey, MIN_HEADROOM_SECONDS, assertFinite, MAX_PAIR_LENGTH, assertPairLength, verifyLockupAddress, LOCKUP_SHAPE_VARIANTS, matchQuotedLockup, assertFundable, expectQuote, pairOf, SEQUENCE_GRANULARITY_SECONDS, SOLO_REFUND_HEADROOM_SECONDS, unilateralClaimDelay, unilateralRefundDelay, unilateralRefundWithoutReceiverDelay, seconds, suiteVhtlc, quotedSoloRefundDelay, offerTermsFromQuote, verifyOfferAddress, quoteCarrierSats, l1NetworkFromArk, onchainSendRequest, lightningReceiveRequest, onchainReceiveRequest, MIN_CLAIM_WINDOW_SECONDS, assertReceivable, matchReceiveLockup;
2294
+ var import_base6, import_solver_discovery, import_legacy2, import_sdk7, import_sdk8, solverHex, quoteSats, quoteAmountSats, quoteExpectedSats, ARKADE_BTC, LIGHTNING_BTC, ONCHAIN_BTC, arkadeAssetLeg, rfqPair, LIGHTNING_SEND_PAIR, LIGHTNING_RECEIVE_PAIR, ONCHAIN_SEND_PAIR, ONCHAIN_RECEIVE_PAIR, RFQ_REFUSAL_ERROR_CODES, isRfqRefusalErrorCode, REFUSAL_FIELDS, REFUSAL_UNITS, safeInteger, safeRefusalDetail, refusalMessage, SwapRefusal, AddressMismatch, newRfqId, lightningSendRequest, arkadeSwapRequest, canonicalAssetAmount, normalizeHexBytes, normalizeMakerPkScript, normalizeMakerPublicKey, MIN_HEADROOM_SECONDS, assertFinite, MAX_PAIR_LENGTH, assertPairLength, verifyLockupAddress, LOCKUP_SHAPE_VARIANTS, matchQuotedLockup, assertFundable, expectQuote, requestVersionedQuote, pairOf, SEQUENCE_GRANULARITY_SECONDS, SOLO_REFUND_HEADROOM_SECONDS, unilateralClaimDelay, unilateralRefundDelay, unilateralRefundWithoutReceiverDelay, seconds, suiteVhtlc, quotedSoloRefundDelay, offerTermsFromQuote, verifyOfferAddress, quoteCarrierSats, l1NetworkFromArk, onchainSendRequest, lightningReceiveRequest, onchainReceiveRequest, MIN_CLAIM_WINDOW_SECONDS, assertReceivable, matchReceiveLockup;
1961
2295
  var init_rfq = __esm({
1962
2296
  "src/rfq.ts"() {
1963
2297
  "use strict";
1964
2298
  import_base6 = require("@scure/base");
1965
2299
  import_solver_discovery = require("@arkade-os/solver-discovery");
1966
2300
  import_legacy2 = require("@noble/hashes/legacy.js");
1967
- import_sdk6 = require("@arkade-os/sdk");
2301
+ import_sdk7 = require("@arkade-os/sdk");
1968
2302
  init_onchainHtlc();
1969
2303
  init_onchainHtlc();
1970
- import_sdk7 = require("@arkade-os/sdk");
2304
+ import_sdk8 = require("@arkade-os/sdk");
1971
2305
  init_claimAmountGate();
1972
2306
  init_claimPacket();
1973
2307
  init_lockupContract();
1974
2308
  init_offer();
2309
+ init_program();
2310
+ init_rfq_contract();
1975
2311
  solverHex = (value, field) => {
1976
2312
  try {
1977
2313
  return import_base6.hex.decode(value);
@@ -2008,6 +2344,7 @@ var init_rfq = __esm({
2008
2344
  ONCHAIN_RECEIVE_PAIR = rfqPair(ONCHAIN_BTC, ARKADE_BTC);
2009
2345
  RFQ_REFUSAL_ERROR_CODES = [
2010
2346
  "amount_side_unsupported",
2347
+ RFQ_CONTRACT_VERSION_UNSUPPORTED,
2011
2348
  "exact_out_unsupported",
2012
2349
  "invalid_amount",
2013
2350
  "invalid_payout_address",
@@ -2123,6 +2460,7 @@ var init_rfq = __esm({
2123
2460
  pair,
2124
2461
  amount_side: input.amountSide ?? "from",
2125
2462
  amount: canonicalAssetAmount(input.amount),
2463
+ ...input.contractVersions && input.contractVersions.length > 0 ? { [RFQ_CONTRACT_VERSIONS_KEY]: [...input.contractVersions] } : {},
2126
2464
  // The solver's `.strict()` schema refuses any undeclared key as `unsupported_payload`.
2127
2465
  profile: {
2128
2466
  maker_pk_script: normalizeMakerPkScript(input.makerPkScript),
@@ -2310,6 +2648,34 @@ var init_rfq = __esm({
2310
2648
  }
2311
2649
  return payload;
2312
2650
  };
2651
+ requestVersionedQuote = async (transport, request, advertised) => {
2652
+ if (advertised.length === 0) {
2653
+ throw new Error("contractVersions is empty: advertise at least one contract version");
2654
+ }
2655
+ let sent = request;
2656
+ let quote;
2657
+ try {
2658
+ quote = await transport.requestQuote(request);
2659
+ } catch (error) {
2660
+ if (!(error instanceof SwapRefusal) || error.reason !== "unsupported_payload" || error.errorCode !== void 0 || !advertised.includes(ASSET_SWAP_BASELINE)) {
2661
+ throw error;
2662
+ }
2663
+ const { [RFQ_CONTRACT_VERSIONS_KEY]: _, ...baseline } = request;
2664
+ sent = { ...baseline, rfq_id: newRfqId() };
2665
+ quote = await transport.requestQuote(sent);
2666
+ }
2667
+ const selected = quote[RFQ_CONTRACT_VERSION_KEY];
2668
+ if (sent !== request && selected !== void 0) {
2669
+ throw new Error(`solver chose contract version ${selected}, but none was advertised`);
2670
+ }
2671
+ const version = selected ?? ASSET_SWAP_BASELINE;
2672
+ if (!advertised.includes(version)) {
2673
+ throw new Error(
2674
+ `solver chose contract version ${version}, not one of ${advertised.join(", ")}`
2675
+ );
2676
+ }
2677
+ return { quote, rfqId: sent.rfq_id, contractVersion: assetSwapContractVersion(version) };
2678
+ };
2313
2679
  pairOf = (payload) => typeof payload.pair === "string" ? payload.pair : void 0;
2314
2680
  SEQUENCE_GRANULARITY_SECONDS = 512;
2315
2681
  SOLO_REFUND_HEADROOM_SECONDS = 8 * SEQUENCE_GRANULARITY_SECONDS;
@@ -2332,7 +2698,7 @@ var init_rfq = __esm({
2332
2698
  type: "seconds",
2333
2699
  value: BigInt(value)
2334
2700
  });
2335
- suiteVhtlc = (params, roles) => new import_sdk6.VHTLC.ScriptV2({
2701
+ suiteVhtlc = (params, roles) => new import_sdk7.VHTLC.ScriptV2({
2336
2702
  sender: roles.sender,
2337
2703
  receiver: roles.receiver,
2338
2704
  server: params.operatorPubkey,
@@ -2461,7 +2827,7 @@ var init_rfq = __esm({
2461
2827
  };
2462
2828
  matchReceiveLockup = (input, refundLocktime, solverRefundPkScriptHex) => {
2463
2829
  const contractParams = {
2464
- solverPubkey: (0, import_sdk6.toXOnly)(import_base6.hex.decode(input.quote.solver_pubkey), "solver key"),
2830
+ solverPubkey: (0, import_sdk7.toXOnly)(import_base6.hex.decode(input.quote.solver_pubkey), "solver key"),
2465
2831
  refundLocktime,
2466
2832
  operatorPubkey: input.operatorPubkey,
2467
2833
  paymentHash: input.paymentHash,
@@ -2469,7 +2835,7 @@ var init_rfq = __esm({
2469
2835
  emulatorPubkey: input.emulatorPubkey,
2470
2836
  solverRefundPkScript: solverHex(solverRefundPkScriptHex, "profile.solver_refund_pk_script"),
2471
2837
  payoutPubkey: input.payoutPubkey,
2472
- payoutPkScript: import_sdk6.ArkAddress.decode(input.payoutAddress).pkScript
2838
+ payoutPkScript: import_sdk7.ArkAddress.decode(input.payoutAddress).pkScript
2473
2839
  };
2474
2840
  const matched = matchQuotedLockup(
2475
2841
  input.quote,
@@ -2631,14 +2997,14 @@ __export(nostr_exports, {
2631
2997
  nostrRfqTransport: () => nostrRfqTransport,
2632
2998
  sharedNostrPool: () => sharedNostrPool
2633
2999
  });
2634
- var import_solver_discovery2, import_sdk15, import_nostr_tools2, RFQ_DIRECTED_KIND, DEFAULT_TIMEOUT_MS, CONNECTION_FAILURE, CARD_FETCH_TIMEOUT_MS, RelayUnavailable, TransportClosed, closeReasons, nostrRfqTransport, isNewer, nostrCardFetcher;
3000
+ var import_solver_discovery2, import_sdk16, import_nostr_tools2, RFQ_DIRECTED_KIND, DEFAULT_TIMEOUT_MS, CONNECTION_FAILURE, CARD_FETCH_TIMEOUT_MS, RelayUnavailable, TransportClosed, closeReasons, nostrRfqTransport, isNewer, nostrCardFetcher;
2635
3001
  var init_nostr = __esm({
2636
3002
  "src/nostr.ts"() {
2637
3003
  "use strict";
2638
3004
  import_solver_discovery2 = require("@arkade-os/solver-discovery");
2639
3005
  init_rfq();
2640
3006
  init_nostrPool();
2641
- import_sdk15 = require("@arkade-os/sdk");
3007
+ import_sdk16 = require("@arkade-os/sdk");
2642
3008
  import_nostr_tools2 = require("nostr-tools");
2643
3009
  init_nostrPool();
2644
3010
  RFQ_DIRECTED_KIND = 24859;
@@ -2665,7 +3031,7 @@ var init_nostr = __esm({
2665
3031
  return url ? `${url}: ${reason ?? "closed"}` : reason ?? "closed";
2666
3032
  });
2667
3033
  nostrRfqTransport = (options) => {
2668
- (0, import_sdk15.assertTimerMs)("timeoutMs", options.timeoutMs);
3034
+ (0, import_sdk16.assertTimerMs)("timeoutMs", options.timeoutMs);
2669
3035
  const relays = options.relays;
2670
3036
  const solverPubkey = options.solverPubkey;
2671
3037
  const secretKey = options.secretKey ?? (0, import_nostr_tools2.generateSecretKey)();
@@ -2777,7 +3143,7 @@ var init_nostr = __esm({
2777
3143
  };
2778
3144
  isNewer = (event, held) => !held || event.created_at > held.created_at || event.created_at === held.created_at && event.id < held.id;
2779
3145
  nostrCardFetcher = (options = {}) => {
2780
- (0, import_sdk15.assertTimerMs)("timeoutMs", options.timeoutMs);
3146
+ (0, import_sdk16.assertTimerMs)("timeoutMs", options.timeoutMs);
2781
3147
  if (options.timeoutMs === 0) throw new Error("timeoutMs must be positive");
2782
3148
  const seen = /* @__PURE__ */ new Map();
2783
3149
  const inflight = /* @__PURE__ */ new Map();
@@ -2947,13 +3313,13 @@ module.exports = __toCommonJS(index_exports);
2947
3313
 
2948
3314
  // src/client/client.ts
2949
3315
  var import_base23 = require("@scure/base");
2950
- var import_sdk37 = require("@arkade-os/sdk");
3316
+ var import_sdk38 = require("@arkade-os/sdk");
2951
3317
  init_repository();
2952
3318
 
2953
3319
  // src/refund.ts
2954
3320
  var import_base7 = require("@scure/base");
2955
3321
  var import_sha24 = require("@noble/hashes/sha2.js");
2956
- var import_sdk8 = require("@arkade-os/sdk");
3322
+ var import_sdk9 = require("@arkade-os/sdk");
2957
3323
  init_onchainHtlc();
2958
3324
  init_rfq();
2959
3325
  var walletOperator = (wallet) => {
@@ -2991,7 +3357,7 @@ async function findLockupVtxos(contracts, swapPkScript) {
2991
3357
  const out = [];
2992
3358
  for (const vtxo of row?.vtxos ?? []) {
2993
3359
  if (vtxo.isUnrolled) continue;
2994
- if ((0, import_sdk8.isVtxoSpent)(vtxo)) continue;
3360
+ if ((0, import_sdk9.isVtxoSpent)(vtxo)) continue;
2995
3361
  const key = `${vtxo.txid}:${vtxo.vout}`;
2996
3362
  if (seen.has(key)) continue;
2997
3363
  seen.add(key);
@@ -3007,17 +3373,17 @@ async function findLockupVtxos(contracts, swapPkScript) {
3007
3373
  }
3008
3374
  var hashesTo = (candidate, paymentHash) => import_base7.hex.encode((0, import_sha24.sha256)(candidate)) === paymentHash;
3009
3375
  var candidateWitnessItems = (tx, inputIndex) => [
3010
- ...(0, import_sdk8.getArkPsbtFields)(tx, inputIndex, import_sdk8.ConditionWitness).flat(),
3376
+ ...(0, import_sdk9.getArkPsbtFields)(tx, inputIndex, import_sdk9.ConditionWitness).flat(),
3011
3377
  ...tx.getInput(inputIndex).finalScriptWitness ?? []
3012
3378
  ];
3013
3379
  var refundLeafScript = (tx, inputIndex) => {
3014
3380
  const input = tx.getInput(inputIndex);
3015
3381
  const witness = input.finalScriptWitness;
3016
3382
  const leaves = input.tapLeafScript ?? [];
3017
- const script = witness && witness.length >= 2 ? witness[witness.length - 2] : leaves.length === 1 ? (0, import_sdk8.scriptFromTapLeafScript)(leaves[0]) : void 0;
3383
+ const script = witness && witness.length >= 2 ? witness[witness.length - 2] : leaves.length === 1 ? (0, import_sdk9.scriptFromTapLeafScript)(leaves[0]) : void 0;
3018
3384
  if (!script) return void 0;
3019
3385
  try {
3020
- const { type } = (0, import_sdk8.decodeTapscript)(script);
3386
+ const { type } = (0, import_sdk9.decodeTapscript)(script);
3021
3387
  return type === "multisig" || type === "csv-multisig" || type === "cltv-multisig" ? script : void 0;
3022
3388
  } catch {
3023
3389
  return void 0;
@@ -3027,7 +3393,7 @@ async function readLockupFate(indexer, input) {
3027
3393
  const { vtxos } = await indexer.getVtxos({ scripts: [import_base7.hex.encode(input.swapPkScript)] });
3028
3394
  const all = vtxos ?? [];
3029
3395
  if (all.length === 0) return { fate: "unknown" };
3030
- const exited = all.filter((vtxo) => vtxo.isUnrolled && !(0, import_sdk8.isVtxoSpent)(vtxo));
3396
+ const exited = all.filter((vtxo) => vtxo.isUnrolled && !(0, import_sdk9.isVtxoSpent)(vtxo));
3031
3397
  if (exited.length > 0) {
3032
3398
  return {
3033
3399
  fate: "exited",
@@ -3039,7 +3405,7 @@ async function readLockupFate(indexer, input) {
3039
3405
  let sweptLeft = false;
3040
3406
  let live = false;
3041
3407
  for (const vtxo of all) {
3042
- if (!(0, import_sdk8.isVtxoSpent)(vtxo)) {
3408
+ if (!(0, import_sdk9.isVtxoSpent)(vtxo)) {
3043
3409
  if (input.receiver && vtxo.isSwept) sweptLeft = true;
3044
3410
  else live = true;
3045
3411
  continue;
@@ -3066,7 +3432,7 @@ async function readLockupFate(indexer, input) {
3066
3432
  for (const raw of txs) {
3067
3433
  let tx;
3068
3434
  try {
3069
- tx = import_sdk8.Transaction.fromPSBT(import_base7.base64.decode(raw));
3435
+ tx = import_sdk9.Transaction.fromPSBT(import_base7.base64.decode(raw));
3070
3436
  } catch {
3071
3437
  continue;
3072
3438
  }
@@ -3116,10 +3482,10 @@ var assertNoneSwept = (vtxos, contract) => {
3116
3482
  };
3117
3483
  var operatorUnrollScript = async (operator, network) => {
3118
3484
  const info = await operator.getInfo();
3119
- return (0, import_sdk8.assertValidServerUnrollScript)(
3485
+ return (0, import_sdk9.assertValidServerUnrollScript)(
3120
3486
  info.checkpointTapscript,
3121
- network ?? (0, import_sdk8.networkFromOperatorInfo)(info),
3122
- (0, import_sdk8.toXOnly)(import_base7.hex.decode(info.forfeitPubkey), "forfeit key")
3487
+ network ?? (0, import_sdk9.networkFromOperatorInfo)(info),
3488
+ (0, import_sdk9.toXOnly)(import_base7.hex.decode(info.forfeitPubkey), "forfeit key")
3123
3489
  );
3124
3490
  };
3125
3491
  var MAX_LOCKUP_SPEND_INPUTS = 16;
@@ -3139,7 +3505,7 @@ var lockupAssetOutputs = (vtxos) => {
3139
3505
  address: "",
3140
3506
  assets: [...totals].map(([assetId, amount]) => ({ assetId, amount }))
3141
3507
  };
3142
- return [import_sdk8.Extension.create([(0, import_sdk8.createAssetPacket)(inputs, [receiver])]).txOut()];
3508
+ return [import_sdk9.Extension.create([(0, import_sdk9.createAssetPacket)(inputs, [receiver])]).txOut()];
3143
3509
  };
3144
3510
  var lockupInputs = (vtxos, contract, leaf) => {
3145
3511
  const tapTree = contract.encode();
@@ -3164,7 +3530,7 @@ async function pushRefundWithoutReceiver(operator, input) {
3164
3530
  const leaf = input.contract.refundWithoutReceiver();
3165
3531
  const vtxos = boundedLockupSpend(input.vtxos);
3166
3532
  const amount = vtxos.reduce((sum, vtxo) => sum + vtxo.value, 0);
3167
- const txid = await (0, import_sdk8.signAndSubmitOffchainTx)({
3533
+ const txid = await (0, import_sdk9.signAndSubmitOffchainTx)({
3168
3534
  identity: input.sender,
3169
3535
  provider: operator,
3170
3536
  inputs: lockupInputs(vtxos, input.contract, leaf),
@@ -3182,7 +3548,7 @@ async function pushRefundWithoutReceiver(operator, input) {
3182
3548
  var REFUND_MTP_LAG_SECONDS = 2 * 60 * 60;
3183
3549
 
3184
3550
  // src/client/corridors/registry.ts
3185
- var import_sdk14 = require("@arkade-os/sdk");
3551
+ var import_sdk15 = require("@arkade-os/sdk");
3186
3552
 
3187
3553
  // src/client/corridor.ts
3188
3554
  var CORRIDORS = ["arkade", "lightning", "onchain"];
@@ -3379,7 +3745,7 @@ function isSwapError(e, name) {
3379
3745
  }
3380
3746
 
3381
3747
  // src/client/corridors/arkade.ts
3382
- var import_sdk9 = require("@arkade-os/sdk");
3748
+ var import_sdk10 = require("@arkade-os/sdk");
3383
3749
  var ARKADE_DRIVE = {};
3384
3750
  var messageOf = (error) => error instanceof Error ? error.message : String(error);
3385
3751
  var arkadeCorridor = Object.assign(
@@ -3388,11 +3754,11 @@ var arkadeCorridor = Object.assign(
3388
3754
  deps,
3389
3755
  drive: ARKADE_DRIVE,
3390
3756
  matches(raw) {
3391
- const target = (0, import_sdk9.arkTarget)(raw);
3757
+ const target = (0, import_sdk10.arkTarget)(raw);
3392
3758
  if (target === void 0) return void 0;
3393
3759
  try {
3394
- const address = import_sdk9.ArkAddress.decode(target);
3395
- (0, import_sdk9.assertRecipientArkadeAddress)(target, address, {
3760
+ const address = import_sdk10.ArkAddress.decode(target);
3761
+ (0, import_sdk10.assertRecipientArkadeAddress)(target, address, {
3396
3762
  hrp: deps.network.hrp,
3397
3763
  signerSet: deps.signerSet
3398
3764
  });
@@ -3402,11 +3768,11 @@ var arkadeCorridor = Object.assign(
3402
3768
  return { claimed: { kind: "address", address: target } };
3403
3769
  }
3404
3770
  }),
3405
- { target: import_sdk9.arkTarget }
3771
+ { target: import_sdk10.arkTarget }
3406
3772
  );
3407
3773
 
3408
3774
  // src/client/corridors/deps.ts
3409
- var import_sdk12 = require("@arkade-os/sdk");
3775
+ var import_sdk13 = require("@arkade-os/sdk");
3410
3776
 
3411
3777
  // src/chainSource.ts
3412
3778
  var btc2 = __toESM(require("@scure/btc-signer"), 1);
@@ -3465,7 +3831,7 @@ init_rfq();
3465
3831
  var import_light_bolt11_decoder = __toESM(require("light-bolt11-decoder"), 1);
3466
3832
 
3467
3833
  // src/client/corridors/lightning.ts
3468
- var import_sdk10 = require("@arkade-os/sdk");
3834
+ var import_sdk11 = require("@arkade-os/sdk");
3469
3835
  var INVOICE_HRPS = [
3470
3836
  ["lnbcrt", ["regtest"]],
3471
3837
  ["lntbs", ["signet", "mutinynet"]],
@@ -3495,7 +3861,7 @@ var lightningCorridor = Object.assign(
3495
3861
  deps,
3496
3862
  drive: LIGHTNING_DRIVE,
3497
3863
  matches(raw) {
3498
- const invoice = (0, import_sdk10.invoiceTarget)(raw);
3864
+ const invoice = (0, import_sdk11.invoiceTarget)(raw);
3499
3865
  if (invoice === void 0) return void 0;
3500
3866
  const networks2 = networksOfInvoiceHrp(invoice);
3501
3867
  if (networks2 === void 0) {
@@ -3541,7 +3907,7 @@ var lightningCorridor = Object.assign(
3541
3907
  };
3542
3908
  }
3543
3909
  }),
3544
- { target: import_sdk10.invoiceTarget }
3910
+ { target: import_sdk11.invoiceTarget }
3545
3911
  );
3546
3912
 
3547
3913
  // src/client/corridors/bolt11.ts
@@ -3572,7 +3938,7 @@ var decodeBolt11 = (invoice) => {
3572
3938
  // src/client/corridors/chainSource.ts
3573
3939
  var import_base9 = require("@scure/base");
3574
3940
  var btc3 = __toESM(require("@scure/btc-signer"), 1);
3575
- var import_sdk11 = require("@arkade-os/sdk");
3941
+ var import_sdk12 = require("@arkade-os/sdk");
3576
3942
  var addressOfScript = (script, network) => btc3.Address(network).encode(btc3.OutScript.decode(script));
3577
3943
  var chainSourceOver = (backend, network) => {
3578
3944
  const spenderFromVins = async (txid, vout, pkScript) => {
@@ -3639,7 +4005,7 @@ var esploraTip = async (esploraUrl, fetchImpl) => {
3639
4005
  };
3640
4006
  var esploraChainSource = (input) => chainSourceOver(
3641
4007
  {
3642
- provider: new import_sdk11.EsploraProvider(input.esploraUrl),
4008
+ provider: new import_sdk12.EsploraProvider(input.esploraUrl),
3643
4009
  tip: () => esploraTip(input.esploraUrl, input.fetchImpl)
3644
4010
  },
3645
4011
  input.network
@@ -3665,10 +4031,10 @@ var refusedIfMalformed = (value, dep) => {
3665
4031
  };
3666
4032
  var emulatorPubkeyFor = (base) => {
3667
4033
  if (base.emulatorPubkey !== void 0) {
3668
- return (0, import_sdk12.resolveEmulatorPubkey)(base.network, base.emulatorPubkey);
4034
+ return (0, import_sdk13.resolveEmulatorPubkey)(base.network, base.emulatorPubkey);
3669
4035
  }
3670
4036
  try {
3671
- return (0, import_sdk12.defaultEmulatorPubkey)(base.network);
4037
+ return (0, import_sdk13.defaultEmulatorPubkey)(base.network);
3672
4038
  } catch {
3673
4039
  throw new MissingCorridorDep(
3674
4040
  "arkade",
@@ -3719,7 +4085,7 @@ function resolveCorridorDeps(corridor, overrides, base) {
3719
4085
  return {
3720
4086
  networkName: base.networkName,
3721
4087
  chain: chain && "provider" in chain ? chainSourceFrom(chain.provider, l1Network) : esploraChainSource({
3722
- esploraUrl: chain?.esploraUrl ?? import_sdk12.ESPLORA_URL[base.networkName],
4088
+ esploraUrl: chain?.esploraUrl ?? import_sdk13.ESPLORA_URL[base.networkName],
3723
4089
  network: L1_NETWORKS[l1Network],
3724
4090
  fetchImpl: base.fetchImpl
3725
4091
  }),
@@ -3749,8 +4115,8 @@ var resolveCorridorBase = async (input) => {
3749
4115
  wallet: input.wallet,
3750
4116
  operator: input.operator,
3751
4117
  networkName,
3752
- network: (0, import_sdk12.getNetwork)(networkName),
3753
- signerSet: (0, import_sdk12.signerSetFromInfo)(info),
4118
+ network: (0, import_sdk13.getNetwork)(networkName),
4119
+ signerSet: (0, import_sdk13.signerSetFromInfo)(info),
3754
4120
  emulatorPubkey: input.emulatorPubkey,
3755
4121
  fetchImpl: input.fetchImpl,
3756
4122
  repository: input.repository
@@ -3758,7 +4124,7 @@ var resolveCorridorBase = async (input) => {
3758
4124
  };
3759
4125
 
3760
4126
  // src/client/corridors/onchain.ts
3761
- var import_sdk13 = require("@arkade-os/sdk");
4127
+ var import_sdk14 = require("@arkade-os/sdk");
3762
4128
  var btc4 = __toESM(require("@scure/btc-signer"), 1);
3763
4129
  init_onchainHtlc();
3764
4130
  init_rfq();
@@ -3788,14 +4154,14 @@ var onchainCorridor = Object.assign(
3788
4154
  deps,
3789
4155
  drive: ONCHAIN_DRIVE,
3790
4156
  matches(raw) {
3791
- const target = (0, import_sdk13.btcTarget)(raw);
4157
+ const target = (0, import_sdk14.btcTarget)(raw);
3792
4158
  if (target === void 0) return void 0;
3793
4159
  try {
3794
4160
  btc4.Address(L1_NETWORKS[l1]).decode(target);
3795
4161
  } catch {
3796
4162
  return { refused: `this is not a ${l1} address` };
3797
4163
  }
3798
- const amount = import_sdk13.BIP21.amountSats(raw);
4164
+ const amount = import_sdk14.BIP21.amountSats(raw);
3799
4165
  return {
3800
4166
  claimed: {
3801
4167
  kind: "address",
@@ -3806,7 +4172,7 @@ var onchainCorridor = Object.assign(
3806
4172
  }
3807
4173
  };
3808
4174
  },
3809
- { target: import_sdk13.btcTarget }
4175
+ { target: import_sdk14.btcTarget }
3810
4176
  );
3811
4177
 
3812
4178
  // src/client/corridors/registry.ts
@@ -3832,7 +4198,7 @@ var corridorSet = (base, overrides) => {
3832
4198
  (corridor) => CORRIDOR_FACTORIES[corridor].target(raw) !== void 0
3833
4199
  );
3834
4200
  if (owners.length === 0) {
3835
- if ((0, import_sdk14.isLnurl)(raw)) return void 0;
4201
+ if ((0, import_sdk15.isLnurl)(raw)) return void 0;
3836
4202
  throw new AmbiguousDestination(raw, "no corridor recognises this destination");
3837
4203
  }
3838
4204
  const claims = [];
@@ -3860,7 +4226,7 @@ var import_solver_discovery5 = require("@arkade-os/solver-discovery");
3860
4226
 
3861
4227
  // src/markets.ts
3862
4228
  var import_solver_discovery3 = require("@arkade-os/solver-discovery");
3863
- var import_sdk16 = require("@arkade-os/sdk");
4229
+ var import_sdk17 = require("@arkade-os/sdk");
3864
4230
 
3865
4231
  // src/marketShape.ts
3866
4232
  var MARKET_CORRIDORS = ["arkade", "bolt11", "bitcoin", "eip155"];
@@ -3902,7 +4268,7 @@ var marketPairLabel = (market) => `${sideLabel(market, "base")}/${sideLabel(mark
3902
4268
  init_store();
3903
4269
  var QUOTE_OPTIONS = { safetyBps: 0 };
3904
4270
  var makeCachedFeedFetch = (ttlMs = 3e4, fetchImpl = fetch) => {
3905
- (0, import_sdk16.assertNonNegativeMs)("ttlMs", ttlMs);
4271
+ (0, import_sdk17.assertNonNegativeMs)("ttlMs", ttlMs);
3906
4272
  const cache = /* @__PURE__ */ new Map();
3907
4273
  const inflight = /* @__PURE__ */ new Map();
3908
4274
  return async (input, init) => {
@@ -4013,7 +4379,7 @@ var import_solver_discovery4 = require("@arkade-os/solver-discovery");
4013
4379
  init_store();
4014
4380
 
4015
4381
  // src/client/assetId.ts
4016
- var import_sdk17 = require("@arkade-os/sdk");
4382
+ var import_sdk18 = require("@arkade-os/sdk");
4017
4383
  var RAILS = ["arkade", "bitcoin", "bolt11", "eip155"];
4018
4384
  var BITCOIN_RAILS = ["arkade", "bitcoin", "bolt11"];
4019
4385
  var BTC_ASSET_PART = "slip44:0";
@@ -4042,7 +4408,7 @@ var CHAIN_REFERENCE = /^[-_a-z0-9]{1,32}$/;
4042
4408
  var CHAIN_ID = /^(0|[1-9][0-9]*)$/;
4043
4409
  var ASSET_REFERENCE = /^[-.%a-z0-9]{1,128}$/;
4044
4410
  var isRail = (value) => RAILS.includes(value);
4045
- var isNetworkRef = (value) => Object.hasOwn(import_sdk17.networks, value);
4411
+ var isNetworkRef = (value) => Object.hasOwn(import_sdk18.networks, value);
4046
4412
  var parseAssetId = (value) => {
4047
4413
  if (/[A-Z]/.test(value)) {
4048
4414
  throw new AssetIdError(
@@ -4107,7 +4473,7 @@ var parseAssetId = (value) => {
4107
4473
  }
4108
4474
  if (namespace === ARKADE_ASSET_NAMESPACE) {
4109
4475
  try {
4110
- import_sdk17.asset.AssetId.fromString(assetReference);
4476
+ import_sdk18.asset.AssetId.fromString(assetReference);
4111
4477
  } catch (cause) {
4112
4478
  throw new AssetIdError(
4113
4479
  "invalid_asset_reference",
@@ -4163,7 +4529,7 @@ var isBtcAssetLenient = (id) => {
4163
4529
  var arkadeAsset = (network, id) => `arkade:${network}/${ARKADE_ASSET_NAMESPACE}:${id.toString()}`;
4164
4530
  var issuanceOf = (id) => {
4165
4531
  const { assetNamespace, assetReference } = parseAssetId(id);
4166
- return assetNamespace === ARKADE_ASSET_NAMESPACE ? import_sdk17.asset.AssetId.fromString(assetReference) : void 0;
4532
+ return assetNamespace === ARKADE_ASSET_NAMESPACE ? import_sdk18.asset.AssetId.fromString(assetReference) : void 0;
4167
4533
  };
4168
4534
 
4169
4535
  // src/client/aliases.ts
@@ -4378,7 +4744,7 @@ var discoveryIndex = (input) => {
4378
4744
  // src/client/accept.ts
4379
4745
  var import_base12 = require("@scure/base");
4380
4746
  var import_solver_discovery9 = require("@arkade-os/solver-discovery");
4381
- var import_sdk20 = require("@arkade-os/sdk");
4747
+ var import_sdk21 = require("@arkade-os/sdk");
4382
4748
  init_offer();
4383
4749
  init_coverage();
4384
4750
  init_lockupContract();
@@ -4579,7 +4945,7 @@ init_rfqProfileParts();
4579
4945
  init_store();
4580
4946
 
4581
4947
  // src/client/assetPayment.ts
4582
- var import_sdk18 = require("@arkade-os/sdk");
4948
+ var import_sdk19 = require("@arkade-os/sdk");
4583
4949
  var import_solver_discovery6 = require("@arkade-os/solver-discovery");
4584
4950
  var DECIMAL = /^(0|[1-9][0-9]*)$/;
4585
4951
  var MAX_SATS = 2100000000000000n;
@@ -4630,7 +4996,7 @@ function validateReceiverPaidQuoteShape(q) {
4630
4996
  throw new Error("carrier receiver-paid quote needs an assetId");
4631
4997
  }
4632
4998
  try {
4633
- import_sdk18.asset.AssetId.fromString(q.assetId);
4999
+ import_sdk19.asset.AssetId.fromString(q.assetId);
4634
5000
  } catch {
4635
5001
  throw new Error("carrier receiver-paid quote assetId is not a valid SDK asset id");
4636
5002
  }
@@ -4869,7 +5235,7 @@ var assetPaymentOf = (stored, quoteExpiry) => {
4869
5235
  };
4870
5236
 
4871
5237
  // src/client/fundingNotSubmitted.ts
4872
- var import_sdk19 = require("@arkade-os/sdk");
5238
+ var import_sdk20 = require("@arkade-os/sdk");
4873
5239
  var import_base11 = require("@scure/base");
4874
5240
  init_coverage();
4875
5241
  init_repository();
@@ -5087,7 +5453,7 @@ var retireUnsubmittedFunding = async (wallet, repository, record, contracts) =>
5087
5453
  status: row.family === "offer" ? row.status : fundingWasNotSubmitted(row) ? "cancelled" : row.state === "settled" || row.state === "refunded" ? "fulfilled" : "pending"
5088
5454
  }));
5089
5455
  const legacy = (await collectRfqSwaps(repository)).map((row) => ({
5090
- swapPkScript: import_base11.hex.encode(import_sdk19.ArkAddress.decode(row.lockupAddress).pkScript),
5456
+ swapPkScript: import_base11.hex.encode(import_sdk20.ArkAddress.decode(row.lockupAddress).pkScript),
5091
5457
  createdAt: row.createdAt * 1e3,
5092
5458
  status: row.state === "settled" || row.state === "refunded" ? "fulfilled" : "pending"
5093
5459
  }));
@@ -5433,15 +5799,15 @@ var acceptQuoteBody = async (input) => {
5433
5799
  var registeredOfferRecord = async (input, preparation) => {
5434
5800
  const { quote, wallet, corridors, now } = input;
5435
5801
  const { plan } = preparation;
5436
- const arkade3 = corridors.get("arkade").deps;
5802
+ const arkade4 = corridors.get("arkade").deps;
5437
5803
  const receiveIsBtc = plan.receive.asset.id === BTC_ASSET_ID;
5438
5804
  const offer = await createOffer(
5439
5805
  wallet,
5440
5806
  {
5441
5807
  // Keyed on the receive side: the covenant binds what the fill delivers.
5442
5808
  wantAmount: plan.receive.atomic,
5443
- ...receiveIsBtc ? { offerAsset: import_sdk20.asset.AssetId.fromString(plan.deposit.asset.id) } : { wantAsset: import_sdk20.asset.AssetId.fromString(plan.receive.asset.id) },
5444
- emulatorPubkey: arkade3.emulatorPubkey
5809
+ ...receiveIsBtc ? { offerAsset: import_sdk21.asset.AssetId.fromString(plan.deposit.asset.id) } : { wantAsset: import_sdk21.asset.AssetId.fromString(plan.receive.asset.id) },
5810
+ emulatorPubkey: arkade4.emulatorPubkey
5445
5811
  },
5446
5812
  { coverageId: quote.id }
5447
5813
  );
@@ -5504,7 +5870,7 @@ var fundAndStamp = async (input, record, repository) => {
5504
5870
  const txid = await fund({ ...input, ...bounds, validUntil }, record);
5505
5871
  return stampFunding(repository, record, txid, input.now);
5506
5872
  } catch (error) {
5507
- if (input.firstFundingAttempt && validUntil !== void 0 && error instanceof import_sdk20.SendDeadlineExceededError) {
5873
+ if (input.firstFundingAttempt && validUntil !== void 0 && error instanceof import_sdk21.SendDeadlineExceededError) {
5508
5874
  const stopped = {
5509
5875
  ...record,
5510
5876
  ...record.family === "offer" ? { status: "cancelled" } : { state: "failed" },
@@ -5573,7 +5939,7 @@ var reconcileFunding = async (input, record) => {
5573
5939
  const script = record.family === "offer" ? record.swapPkScript : record.lockupPkScript;
5574
5940
  const expected = BigInt(record.give.amount);
5575
5941
  const reader = await input.wallet.getArkadeReader();
5576
- const vtxos = await (0, import_sdk20.getAllNormalizedVtxos)(reader, [script]);
5942
+ const vtxos = await (0, import_sdk21.getAllNormalizedVtxos)(reader, [script]);
5577
5943
  const deposit = vtxos.find((vtxo) => depositMatches(vtxo, record, expected));
5578
5944
  return deposit?.txid;
5579
5945
  };
@@ -5589,13 +5955,13 @@ var depositMatches = (vtxo, record, expected) => {
5589
5955
 
5590
5956
  // src/client/cancel.ts
5591
5957
  var import_base16 = require("@scure/base");
5592
- var import_sdk24 = require("@arkade-os/sdk");
5958
+ var import_sdk25 = require("@arkade-os/sdk");
5593
5959
  init_coverage();
5594
5960
  init_offer();
5595
5961
 
5596
5962
  // src/restore.ts
5597
5963
  var import_base13 = require("@scure/base");
5598
- var import_sdk21 = require("@arkade-os/sdk");
5964
+ var import_sdk22 = require("@arkade-os/sdk");
5599
5965
  init_offer();
5600
5966
  init_store();
5601
5967
  var TXS_PER_REQUEST = 50;
@@ -5620,7 +5986,7 @@ async function fetchParsedTxs(indexer, txids) {
5620
5986
  if (result.status !== "fulfilled") continue;
5621
5987
  for (const psbt of result.value) {
5622
5988
  try {
5623
- const parsed = import_sdk21.Transaction.fromPSBT(import_base13.base64.decode(psbt));
5989
+ const parsed = import_sdk22.Transaction.fromPSBT(import_base13.base64.decode(psbt));
5624
5990
  parsedByTxid.set(parsed.id, parsed);
5625
5991
  } catch {
5626
5992
  }
@@ -5649,7 +6015,7 @@ function classifySpend(offer, operatorPubkey, spendTx, deposit) {
5649
6015
  if (!input.txid || input.index !== deposit.vout) continue;
5650
6016
  if (import_base13.hex.encode(input.txid) !== deposit.txid) continue;
5651
6017
  for (const leaf of input.tapLeafScript ?? []) {
5652
- const spent = import_base13.hex.encode((0, import_sdk21.scriptFromTapLeafScript)(leaf));
6018
+ const spent = import_base13.hex.encode((0, import_sdk22.scriptFromTapLeafScript)(leaf));
5653
6019
  if (leaves.returned.some((back) => spent === import_base13.hex.encode(back))) return "cancelled";
5654
6020
  if (leaves.fulfill && spent === import_base13.hex.encode(leaves.fulfill)) return "fulfilled";
5655
6021
  }
@@ -5703,7 +6069,7 @@ async function restoreAssetSwaps(indexer, txs, existingIds, opts) {
5703
6069
  if (!fundingTx) continue;
5704
6070
  fetchedTxids.push(txid);
5705
6071
  try {
5706
- const packet = import_sdk21.Extension.fromTx(parsed).getPacketByType(OFFER_PACKET_TYPE);
6072
+ const packet = import_sdk22.Extension.fromTx(parsed).getPacketByType(OFFER_PACKET_TYPE);
5707
6073
  if (!packet) continue;
5708
6074
  const payload = packet.serialize();
5709
6075
  found.push({
@@ -5820,7 +6186,7 @@ init_repository();
5820
6186
  init_repository();
5821
6187
 
5822
6188
  // src/rfqRecord.ts
5823
- var import_sdk22 = require("@arkade-os/sdk");
6189
+ var import_sdk23 = require("@arkade-os/sdk");
5824
6190
  var import_base14 = require("@scure/base");
5825
6191
 
5826
6192
  // src/rfqSwapState.ts
@@ -5878,7 +6244,7 @@ function assertSameSwap(origin, swap) {
5878
6244
  `rfq swap record is a ${origin.kind} origin paired with a ${swap.kind} swap`
5879
6245
  );
5880
6246
  }
5881
- const funded = import_base14.hex.encode(import_sdk22.ArkAddress.decode(origin.lockupAddress).pkScript);
6247
+ const funded = import_base14.hex.encode(import_sdk23.ArkAddress.decode(origin.lockupAddress).pkScript);
5882
6248
  const watched = import_base14.hex.encode(swap.lockupPkScript);
5883
6249
  if (funded !== watched) {
5884
6250
  throw new Error(
@@ -5925,8 +6291,8 @@ function rfqSwapOriginOf(record) {
5925
6291
  };
5926
6292
  }
5927
6293
  function lockupScript(params, lockupAddress) {
5928
- const script = import_sdk22.VHTLCV2ContractHandler.createScript(params);
5929
- const funded = import_sdk22.ArkAddress.decode(lockupAddress).pkScript;
6294
+ const script = import_sdk23.VHTLCV2ContractHandler.createScript(params);
6295
+ const funded = import_sdk23.ArkAddress.decode(lockupAddress).pkScript;
5930
6296
  if (import_base14.hex.encode(funded) !== import_base14.hex.encode(script.pkScript)) {
5931
6297
  throw new Error(
5932
6298
  `rfq swap covenant params derive ${import_base14.hex.encode(script.pkScript)}, but the record's lockup address holds ${import_base14.hex.encode(funded)} \u2014 these params are not this swap's`
@@ -5963,7 +6329,7 @@ function shouldRetainRfqSwap(record, now) {
5963
6329
 
5964
6330
  // src/client/driveRecords.ts
5965
6331
  init_store();
5966
- var import_sdk23 = require("@arkade-os/sdk");
6332
+ var import_sdk24 = require("@arkade-os/sdk");
5967
6333
  var import_sha25 = require("@noble/hashes/sha2.js");
5968
6334
  var import_base15 = require("@scure/base");
5969
6335
  var splitRecords = (records) => {
@@ -6018,7 +6384,7 @@ var pageRfqRecords = (records, filter, page) => {
6018
6384
  ).sort(
6019
6385
  (a, b) => a.updatedAt - b.updatedAt || (a.rfqId < b.rfqId ? -1 : a.rfqId > b.rfqId ? 1 : 0)
6020
6386
  ).slice(0, page.limit + 1);
6021
- return (0, import_sdk23.pageResult)(rows, page.limit, (record) => ({
6387
+ return (0, import_sdk24.pageResult)(rows, page.limit, (record) => ({
6022
6388
  updatedAt: record.updatedAt,
6023
6389
  rfqId: record.rfqId
6024
6390
  }));
@@ -6044,7 +6410,7 @@ var corridorRecordStore = (repository, onRecord = () => {
6044
6410
  index,
6045
6411
  quoteIdOf: (rfqId) => byRfqId.get(rfqId),
6046
6412
  async getRfqSwapsPage(filter, page) {
6047
- (0, import_sdk23.assertPageRequest)(page);
6413
+ (0, import_sdk24.assertPageRequest)(page);
6048
6414
  assertRfqSwapPageFilter(filter);
6049
6415
  const { corridor } = splitRecords(await collectSwapRecords(repository));
6050
6416
  for (const record of corridor) index(record);
@@ -6156,7 +6522,7 @@ var restoredOfferRecord = (swap, network, now) => {
6156
6522
  now
6157
6523
  );
6158
6524
  };
6159
- var restoredAssetId = (network, id) => id === BTC_ASSET_ID ? btcOn("arkade", network) : arkadeAsset(network, import_sdk23.asset.AssetId.fromString(id));
6525
+ var restoredAssetId = (network, id) => id === BTC_ASSET_ID ? btcOn("arkade", network) : arkadeAsset(network, import_sdk24.asset.AssetId.fromString(id));
6160
6526
  var RESTORED_CORRIDORS = {
6161
6527
  lightning_send: ["arkade", "lightning"],
6162
6528
  lightning_receive: ["lightning", "arkade"],
@@ -6188,7 +6554,7 @@ var restoredCorridorRecord = (stored, network, refundLocktime) => {
6188
6554
  kind: v1.kind,
6189
6555
  rfqId: v1.rfqId,
6190
6556
  lockupAddress: v1.lockupAddress,
6191
- lockupPkScript: import_base15.hex.encode(import_sdk23.ArkAddress.decode(v1.lockupAddress).pkScript),
6557
+ lockupPkScript: import_base15.hex.encode(import_sdk24.ArkAddress.decode(v1.lockupAddress).pkScript),
6192
6558
  lock: { hash },
6193
6559
  refundLocktime,
6194
6560
  profile: v1.profile,
@@ -6284,12 +6650,12 @@ var reconcileDepositSpend = async (record, indexer) => {
6284
6650
  const { txs } = await indexer.getVirtualTxs(candidates);
6285
6651
  const parsed = txs.map((psbt) => {
6286
6652
  try {
6287
- return import_sdk24.Transaction.fromPSBT(import_base16.base64.decode(psbt));
6653
+ return import_sdk25.Transaction.fromPSBT(import_base16.base64.decode(psbt));
6288
6654
  } catch {
6289
6655
  return void 0;
6290
6656
  }
6291
6657
  }).filter((tx) => tx !== void 0);
6292
- const operatorPubkey = import_sdk24.ArkAddress.decode(record.swapAddress).serverPubKey;
6658
+ const operatorPubkey = import_sdk25.ArkAddress.decode(record.swapAddress).serverPubKey;
6293
6659
  const kind = classifyDepositSpend(offer, operatorPubkey, parsed, {
6294
6660
  txid: deposit.txid,
6295
6661
  vout: deposit.vout
@@ -6328,12 +6694,12 @@ var retireOfferScripts = async (wallet, repository, record) => {
6328
6694
  };
6329
6695
 
6330
6696
  // src/client/drive.ts
6331
- var import_sdk31 = require("@arkade-os/sdk");
6697
+ var import_sdk32 = require("@arkade-os/sdk");
6332
6698
  var import_base20 = require("@scure/base");
6333
6699
 
6334
6700
  // src/claim.ts
6335
6701
  var import_base17 = require("@scure/base");
6336
- var import_sdk25 = require("@arkade-os/sdk");
6702
+ var import_sdk26 = require("@arkade-os/sdk");
6337
6703
  init_onchainHtlc();
6338
6704
  var LockupAmountMismatchError = class extends Error {
6339
6705
  name = "LockupAmountMismatchError";
@@ -6369,8 +6735,8 @@ async function pushClaim(operator, input) {
6369
6735
  assertPreimageMatches(input.preimage, input.contract.options.preimageHash);
6370
6736
  const serverUnrollScript = await operatorUnrollScript(operator, input.network);
6371
6737
  const leaf = input.contract.claim();
6372
- const txid = await (0, import_sdk25.signAndSubmitOffchainTx)({
6373
- identity: (0, import_sdk25.claimWithPreimageIdentity)(input.receiver, input.preimage),
6738
+ const txid = await (0, import_sdk26.signAndSubmitOffchainTx)({
6739
+ identity: (0, import_sdk26.claimWithPreimageIdentity)(input.receiver, input.preimage),
6374
6740
  provider: operator,
6375
6741
  inputs: lockupInputs(vtxos, input.contract, leaf),
6376
6742
  // One aggregate output: this leaf inspects nothing about the output set.
@@ -6391,7 +6757,7 @@ async function findPendingClaims(operator, indexer, input) {
6391
6757
  });
6392
6758
  const byArkTx = /* @__PURE__ */ new Map();
6393
6759
  for (const vtxo of vtxos ?? []) {
6394
- if (!(0, import_sdk25.isVtxoSpent)(vtxo) || !vtxo.spentBy || !vtxo.arkTxId) continue;
6760
+ if (!(0, import_sdk26.isVtxoSpent)(vtxo) || !vtxo.spentBy || !vtxo.arkTxId) continue;
6395
6761
  byArkTx.set(vtxo.arkTxId, [...byArkTx.get(vtxo.arkTxId) ?? [], vtxo]);
6396
6762
  }
6397
6763
  if (byArkTx.size === 0) return [];
@@ -6401,9 +6767,9 @@ async function findPendingClaims(operator, indexer, input) {
6401
6767
  current,
6402
6768
  ...(deprecatedSigners ?? []).flatMap(
6403
6769
  ({ pubkey }) => pubkey ? [
6404
- import_sdk25.CSVMultisigTapscript.encode({
6770
+ import_sdk26.CSVMultisigTapscript.encode({
6405
6771
  ...current.params,
6406
- pubkeys: [(0, import_sdk25.toXOnly)(import_base17.hex.decode(pubkey), "deprecated signer")]
6772
+ pubkeys: [(0, import_sdk26.toXOnly)(import_base17.hex.decode(pubkey), "deprecated signer")]
6407
6773
  })
6408
6774
  ] : []
6409
6775
  )
@@ -6418,7 +6784,7 @@ async function findPendingClaims(operator, indexer, input) {
6418
6784
  }));
6419
6785
  const total = live.reduce((sum, vtxo) => sum + vtxo.value, 0);
6420
6786
  const checkpoints = unrollScripts.map(
6421
- (unroll) => (0, import_sdk25.buildOffchainTx)(
6787
+ (unroll) => (0, import_sdk26.buildOffchainTx)(
6422
6788
  lockupInputs(live, input.contract, input.contract.claim()),
6423
6789
  [{ script: input.contract.pkScript, amount: BigInt(total) }],
6424
6790
  unroll
@@ -6434,14 +6800,14 @@ async function finalizePendingClaim(operator, indexer, input) {
6434
6800
  const claims = await findPendingClaims(operator, indexer, input);
6435
6801
  if (claims.length === 0) return [];
6436
6802
  assertPreimageMatches(input.preimage, input.contract.options.preimageHash);
6437
- const signer = (0, import_sdk25.claimWithPreimageIdentity)(input.receiver, input.preimage);
6803
+ const signer = (0, import_sdk26.claimWithPreimageIdentity)(input.receiver, input.preimage);
6438
6804
  const ours = import_base17.hex.encode(await input.receiver.xOnlyPublicKey());
6439
6805
  const finalized = [];
6440
6806
  for (const { arkTxid, checkpoints } of claims) {
6441
6807
  const { txs } = await indexer.getVirtualTxs(checkpoints.map((checkpoint) => checkpoint.id));
6442
6808
  const stored = new Map(
6443
6809
  txs.map((raw) => {
6444
- const tx = import_sdk25.Transaction.fromPSBT(import_base17.base64.decode(raw));
6810
+ const tx = import_sdk26.Transaction.fromPSBT(import_base17.base64.decode(raw));
6445
6811
  return [tx.id, tx];
6446
6812
  })
6447
6813
  );
@@ -6479,7 +6845,7 @@ init_onchainHtlc();
6479
6845
  init_coverage();
6480
6846
 
6481
6847
  // src/migrateOfferRows.ts
6482
- var import_sdk26 = require("@arkade-os/sdk");
6848
+ var import_sdk27 = require("@arkade-os/sdk");
6483
6849
 
6484
6850
  // src/legacy/swap-want-asset.program.v0.json
6485
6851
  var swap_want_asset_program_v0_default = {
@@ -6571,14 +6937,14 @@ function withExitV0(program, exit) {
6571
6937
  }
6572
6938
  var V0_TO_V1 = /* @__PURE__ */ new Map();
6573
6939
  for (const [v0, v1] of [
6574
- [swap_want_btc_program_v0_default, swapPrograms.wantBtc],
6575
- [swap_want_asset_program_v0_default, swapPrograms.wantAsset]
6940
+ [swap_want_btc_program_v0_default, legacySwapPrograms.wantBtc],
6941
+ [swap_want_asset_program_v0_default, legacySwapPrograms.wantAsset]
6576
6942
  ]) {
6577
6943
  for (const exit of [void 0, "blocks", "seconds"]) {
6578
6944
  const timelock = exit && { type: exit, value: BigInt(0) };
6579
6945
  V0_TO_V1.set(
6580
6946
  JSON.stringify(withExitV0(v0, exit)),
6581
- import_sdk26.arkade.stringifyArtifact(withExitClosure(v1, timelock))
6947
+ import_sdk27.arkade.stringifyArtifact(withExitClosure(v1, timelock))
6582
6948
  );
6583
6949
  }
6584
6950
  }
@@ -6617,7 +6983,7 @@ init_offer();
6617
6983
  init_lockupContract();
6618
6984
 
6619
6985
  // src/refundBlocked.ts
6620
- var import_sdk27 = require("@arkade-os/sdk");
6986
+ var import_sdk28 = require("@arkade-os/sdk");
6621
6987
  var RefundNotLocallyPossibleError = class extends Error {
6622
6988
  constructor(reason, message, options) {
6623
6989
  super(message, options);
@@ -6634,16 +7000,16 @@ async function senderIdentityForSwapRecord(wallet, record) {
6634
7000
  );
6635
7001
  }
6636
7002
  try {
6637
- return await (0, import_sdk27.contractSigner)(wallet, record.signingDescriptor);
7003
+ return await (0, import_sdk28.contractSigner)(wallet, record.signingDescriptor);
6638
7004
  } catch (cause) {
6639
- if (cause instanceof import_sdk27.WalletCannotSignError) {
7005
+ if (cause instanceof import_sdk28.WalletCannotSignError) {
6640
7006
  throw new RefundNotLocallyPossibleError(
6641
7007
  "unsignable-wallet",
6642
7008
  `this wallet holds ${record.signingDescriptor} but cannot sign with it; attach its signer`,
6643
7009
  { cause }
6644
7010
  );
6645
7011
  }
6646
- if (cause instanceof import_sdk27.ForeignDescriptorError) {
7012
+ if (cause instanceof import_sdk28.ForeignDescriptorError) {
6647
7013
  throw new RefundNotLocallyPossibleError(
6648
7014
  "foreign-descriptor",
6649
7015
  `this wallet cannot derive ${record.signingDescriptor}; the swap was created on another wallet`,
@@ -6700,7 +7066,7 @@ init_repository();
6700
7066
 
6701
7067
  // src/swapManager.ts
6702
7068
  var import_base18 = require("@scure/base");
6703
- var import_sdk28 = require("@arkade-os/sdk");
7069
+ var import_sdk29 = require("@arkade-os/sdk");
6704
7070
  init_onchainHtlc();
6705
7071
  init_lockupContract();
6706
7072
  init_repository();
@@ -6831,7 +7197,7 @@ var RfqSwapManager = class _RfqSwapManager {
6831
7197
  timer = null;
6832
7198
  running = false;
6833
7199
  constructor(deps, config = {}) {
6834
- (0, import_sdk28.assertTimerMs)("pollIntervalMs", config.pollIntervalMs);
7200
+ (0, import_sdk29.assertTimerMs)("pollIntervalMs", config.pollIntervalMs);
6835
7201
  this.deps = deps;
6836
7202
  this.config = {
6837
7203
  enableAutoActions: config.enableAutoActions ?? true,
@@ -7215,7 +7581,7 @@ var RfqSwapManager = class _RfqSwapManager {
7215
7581
  });
7216
7582
  return;
7217
7583
  }
7218
- if (!(0, import_sdk28.isContractVtxoEvent)(event)) return;
7584
+ if (!(0, import_sdk29.isContractVtxoEvent)(event)) return;
7219
7585
  const swap = this.byLockupScript.get(event.contractScript);
7220
7586
  if (!swap) return;
7221
7587
  void this.pollSwap(swap).catch(() => {
@@ -7485,8 +7851,8 @@ var RfqSwapManager = class _RfqSwapManager {
7485
7851
  this.setState(swap, "claimed");
7486
7852
  this.emitAction(swap, "claimLockup");
7487
7853
  } catch (error) {
7488
- const ark = (0, import_sdk28.isArkError)(error) ? error : (0, import_sdk28.maybeArkError)(error);
7489
- if ((0, import_sdk28.isArkError)(ark, import_sdk28.ArkErrorName.VTXO_ALREADY_SPENT)) {
7854
+ const ark = (0, import_sdk29.isArkError)(error) ? error : (0, import_sdk29.maybeArkError)(error);
7855
+ if ((0, import_sdk29.isArkError)(ark, import_sdk29.ArkErrorName.VTXO_ALREADY_SPENT)) {
7490
7856
  if (swap.claimFailure !== void 0) {
7491
7857
  delete swap.claimFailure;
7492
7858
  this.touch(swap);
@@ -7777,8 +8143,8 @@ var RfqSwapManager = class _RfqSwapManager {
7777
8143
  this.refundRefused.add(swap.rfqId);
7778
8144
  return this.block(swap, error.message);
7779
8145
  }
7780
- const ark = (0, import_sdk28.isArkError)(error) ? error : (0, import_sdk28.maybeArkError)(error);
7781
- if ((0, import_sdk28.isArkError)(ark, import_sdk28.ArkErrorName.VTXO_ALREADY_SPENT)) return;
8146
+ const ark = (0, import_sdk29.isArkError)(error) ? error : (0, import_sdk29.maybeArkError)(error);
8147
+ if ((0, import_sdk29.isArkError)(ark, import_sdk29.ArkErrorName.VTXO_ALREADY_SPENT)) return;
7782
8148
  this.emitFailed(swap, error);
7783
8149
  if (now >= swap.refundLocktime + REFUND_MTP_LAG_SECONDS) {
7784
8150
  swap.failure = errorMessage(error);
@@ -7971,7 +8337,7 @@ var outpointKey = (vtxo) => `${vtxo.txid}:${vtxo.vout}`;
7971
8337
 
7972
8338
  // src/watch.ts
7973
8339
  var import_base19 = require("@scure/base");
7974
- var import_sdk29 = require("@arkade-os/sdk");
8340
+ var import_sdk30 = require("@arkade-os/sdk");
7975
8341
  init_coverage();
7976
8342
  init_offer();
7977
8343
  init_store();
@@ -8006,7 +8372,7 @@ async function watchOfferSwaps({
8006
8372
  wallet.getAddress(),
8007
8373
  wallet.getArkadeReader()
8008
8374
  ]);
8009
- const operatorPubkey = import_sdk29.ArkAddress.decode(address).serverPubKey;
8375
+ const operatorPubkey = import_sdk30.ArkAddress.decode(address).serverPubKey;
8010
8376
  let queue = Promise.resolve();
8011
8377
  const enqueue = (task) => {
8012
8378
  queue = queue.then(task).catch(() => {
@@ -8021,7 +8387,7 @@ async function watchOfferSwaps({
8021
8387
  return classifyDepositSpend(
8022
8388
  decodeOffer(import_base19.hex.decode(swap.offerHex)),
8023
8389
  operatorPubkey,
8024
- txs.map((psbt) => import_sdk29.Transaction.fromPSBT(import_base19.base64.decode(psbt))),
8390
+ txs.map((psbt) => import_sdk30.Transaction.fromPSBT(import_base19.base64.decode(psbt))),
8025
8391
  { txid: vtxo.txid, vout: vtxo.vout }
8026
8392
  );
8027
8393
  } catch {
@@ -8049,7 +8415,7 @@ async function watchOfferSwaps({
8049
8415
  }
8050
8416
  };
8051
8417
  const unsubscribe = manager.onContractEvent((event) => {
8052
- if (!(0, import_sdk29.isContractVtxoEvent)(event) || event.type !== "vtxo_spent") return;
8418
+ if (!(0, import_sdk30.isContractVtxoEvent)(event) || event.type !== "vtxo_spent") return;
8053
8419
  enqueue(() => handleSpend(event));
8054
8420
  });
8055
8421
  return {
@@ -8059,7 +8425,7 @@ async function watchOfferSwaps({
8059
8425
  }
8060
8426
 
8061
8427
  // src/client/legacyRecords.ts
8062
- var import_sdk30 = require("@arkade-os/sdk");
8428
+ var import_sdk31 = require("@arkade-os/sdk");
8063
8429
  init_repository();
8064
8430
  var readLegacyRfqSwaps = async (repository, filter = {}) => {
8065
8431
  try {
@@ -8076,7 +8442,7 @@ var withLegacyRfqSwaps = (bridge, repository, admits) => {
8076
8442
  index: bridge.index,
8077
8443
  quoteIdOf: bridge.quoteIdOf,
8078
8444
  async getRfqSwapsPage(filter, page) {
8079
- (0, import_sdk30.assertPageRequest)(page);
8445
+ (0, import_sdk31.assertPageRequest)(page);
8080
8446
  assertRfqSwapPageFilter(filter);
8081
8447
  const v2 = await collectRfqSwaps(bridge, filter);
8082
8448
  const held = new Set(
@@ -8332,7 +8698,7 @@ var createSwapDrive = (config) => {
8332
8698
  const secret = rfqClaimSecretOf(record);
8333
8699
  if (!secret) throw new Error(`rfq swap ${swap.rfqId} carries no claim secret`);
8334
8700
  const preimage = await preimageForSwapRecord(wallet, secret);
8335
- const signer = await (0, import_sdk31.contractSigner)(wallet, await (0, import_sdk31.identityDescriptor)(wallet.identity));
8701
+ const signer = await (0, import_sdk32.contractSigner)(wallet, await (0, import_sdk32.identityDescriptor)(wallet.identity));
8336
8702
  const claimKey = record.profile.claimKey;
8337
8703
  if (typeof claimKey === "string") {
8338
8704
  const held = import_base20.hex.encode(await signer.xOnlyPublicKey());
@@ -8378,7 +8744,7 @@ var createSwapDrive = (config) => {
8378
8744
  `rfq swap ${swap.rfqId} carries no refund descriptor; wire the onchain corridor's refund callback to take its L1 funding back`
8379
8745
  );
8380
8746
  }
8381
- const signer = await (0, import_sdk31.contractSigner)(wallet, descriptor);
8747
+ const signer = await (0, import_sdk32.contractSigner)(wallet, descriptor);
8382
8748
  const held = import_base20.hex.encode(await signer.xOnlyPublicKey());
8383
8749
  if (held !== record.profile.refundKey) {
8384
8750
  throw new Error(
@@ -8418,7 +8784,7 @@ var createSwapDrive = (config) => {
8418
8784
  }
8419
8785
  };
8420
8786
  const drivable = async (record) => !readsChain(record.kind) || await resolveOnchain();
8421
- const pinnedNetwork = async () => (0, import_sdk31.getNetwork)(await config.network());
8787
+ const pinnedNetwork = async () => (0, import_sdk32.getNetwork)(await config.network());
8422
8788
  const claimSecretOf = async (swap) => {
8423
8789
  const record = await corridorStore().getRfqSwap(swap.rfqId);
8424
8790
  if (!record) throw new Error(`rfq swap ${swap.rfqId} has no stored record to claim from`);
@@ -8442,7 +8808,7 @@ var createSwapDrive = (config) => {
8442
8808
  await track(
8443
8809
  finalizePendingClaim(operator, indexer, {
8444
8810
  contract: script,
8445
- receiver: await (0, import_sdk31.contractSigner)(wallet, secret.signingDescriptor),
8811
+ receiver: await (0, import_sdk32.contractSigner)(wallet, secret.signingDescriptor),
8446
8812
  preimage: await preimageForSwapRecord(wallet, secret),
8447
8813
  network: await pinnedNetwork()
8448
8814
  })
@@ -8457,10 +8823,10 @@ var createSwapDrive = (config) => {
8457
8823
  return track(
8458
8824
  pushClaim(operator, {
8459
8825
  contract: script,
8460
- receiver: await (0, import_sdk31.contractSigner)(wallet, secret.signingDescriptor),
8826
+ receiver: await (0, import_sdk32.contractSigner)(wallet, secret.signingDescriptor),
8461
8827
  preimage: await preimageForSwapRecord(wallet, secret),
8462
8828
  vtxos,
8463
- destinationPkScript: import_sdk31.ArkAddress.decode(payoutAddress).pkScript,
8829
+ destinationPkScript: import_sdk32.ArkAddress.decode(payoutAddress).pkScript,
8464
8830
  // Passed through: `pushClaim`'s own value check decides whether `P` is published.
8465
8831
  expectedAmount: swap.expectedAmount,
8466
8832
  partiallyClaimed,
@@ -8531,7 +8897,7 @@ var createSwapDrive = (config) => {
8531
8897
  config.network()
8532
8898
  ]);
8533
8899
  const txs = history.map(toRestoreTx);
8534
- const { hrp, serverPubKey: operatorPubkey } = import_sdk31.ArkAddress.decode(address);
8900
+ const { hrp, serverPubKey: operatorPubkey } = import_sdk32.ArkAddress.decode(address);
8535
8901
  const reopened = await legacyOfferDepositsToAdopt(store);
8536
8902
  for (const txid of reopen) reopened.add(txid);
8537
8903
  const cursor = reopened.size === 0 ? scanned : new Set([...scanned].filter((txid) => !reopened.has(txid)));
@@ -9504,13 +9870,13 @@ var verifyPlanLegs = (plan, legs, give) => {
9504
9870
 
9505
9871
  // src/client/quoteRfq.ts
9506
9872
  var import_base22 = require("@scure/base");
9507
- var import_sdk35 = require("@arkade-os/sdk");
9873
+ var import_sdk36 = require("@arkade-os/sdk");
9508
9874
  var import_solver_discovery12 = require("@arkade-os/solver-discovery");
9509
9875
 
9510
9876
  // src/jointGraph.ts
9511
9877
  var import_base21 = require("@scure/base");
9512
9878
  var import_sha26 = require("@noble/hashes/sha2.js");
9513
- var import_sdk32 = require("@arkade-os/sdk");
9879
+ var import_sdk33 = require("@arkade-os/sdk");
9514
9880
  function digestJointGraph(plan, template) {
9515
9881
  const parts = [];
9516
9882
  const pushU32 = (value) => {
@@ -9572,7 +9938,7 @@ function verifyJointGraph(plan, template) {
9572
9938
  }
9573
9939
  }
9574
9940
  function parseGraphTx(psbt) {
9575
- return import_sdk32.Transaction.fromPSBT(import_base21.base64.decode(psbt));
9941
+ return import_sdk33.Transaction.fromPSBT(import_base21.base64.decode(psbt));
9576
9942
  }
9577
9943
  function deepFreeze(value) {
9578
9944
  if (value !== null && typeof value === "object") {
@@ -9593,16 +9959,17 @@ function unsignedPsbtBytes(tx) {
9593
9959
  init_claimAmountGate();
9594
9960
  init_claimPacket();
9595
9961
  init_offer();
9962
+ init_program();
9596
9963
  init_store();
9597
9964
  init_onchainHtlc();
9598
9965
  init_onchainHtlc();
9599
9966
 
9600
9967
  // src/payment/onchainSwap.ts
9601
- var import_sdk34 = require("@arkade-os/sdk");
9968
+ var import_sdk35 = require("@arkade-os/sdk");
9602
9969
  init_onchainHtlc();
9603
9970
 
9604
9971
  // src/payment/swapRail.ts
9605
- var import_sdk33 = require("@arkade-os/sdk");
9972
+ var import_sdk34 = require("@arkade-os/sdk");
9606
9973
 
9607
9974
  // src/client/sats.ts
9608
9975
  var satsOf = (value, field) => {
@@ -9699,7 +10066,7 @@ var resultOf = (railId, swap) => ({
9699
10066
  // the tx that left THIS wallet, as on every other rail; later legs are the client's to report
9700
10067
  ...swap.fundingTxid === void 0 ? {} : { txid: swap.fundingTxid }
9701
10068
  });
9702
- var swapHandle = async (railId, client, quote) => (0, import_sdk33.makeHandle)(railId, async (emit) => {
10069
+ var swapHandle = async (railId, client, quote) => (0, import_sdk34.makeHandle)(railId, async (emit) => {
9703
10070
  const accepted = await client.accept(quote);
9704
10071
  return await new Promise((resolve, reject) => {
9705
10072
  let finished = false;
@@ -9743,23 +10110,23 @@ function onchainSwapRail(client, deps) {
9743
10110
  });
9744
10111
  return {
9745
10112
  id: ONCHAIN_SWAP_RAIL,
9746
- match: (req) => (0, import_sdk34.btcTarget)(req.raw) !== void 0,
10113
+ match: (req) => (0, import_sdk35.btcTarget)(req.raw) !== void 0,
9747
10114
  available: async (req) => {
9748
- if ((0, import_sdk34.assetsOf)(req).length > 0) return false;
9749
- const address = (0, import_sdk34.btcTarget)(req.raw);
10115
+ if ((0, import_sdk35.assetsOf)(req).length > 0) return false;
10116
+ const address = (0, import_sdk35.btcTarget)(req.raw);
9750
10117
  if (address === void 0) return false;
9751
- const amount = (0, import_sdk34.tryResolveSendAmount)(req.raw, req.amount);
10118
+ const amount = (0, import_sdk35.tryResolveSendAmount)(req.raw, req.amount);
9752
10119
  if (amount === void 0) return false;
9753
10120
  if (BigInt(amount) < ONCHAIN_DUST_SATS) return false;
9754
10121
  return railAvailable(client, inputFor2(address, amount));
9755
10122
  },
9756
10123
  quote: async (req) => {
9757
- const address = (0, import_sdk34.btcTarget)(req.raw);
10124
+ const address = (0, import_sdk35.btcTarget)(req.raw);
9758
10125
  if (address === void 0) {
9759
10126
  throw new Error(`${ONCHAIN_SWAP_RAIL}: the request carries no bitcoin address`);
9760
10127
  }
9761
- (0, import_sdk34.assertNoAssets)(ONCHAIN_SWAP_RAIL, req);
9762
- const amount = (0, import_sdk34.resolveSendAmount)(ONCHAIN_SWAP_RAIL, req.raw, req.amount);
10128
+ (0, import_sdk35.assertNoAssets)(ONCHAIN_SWAP_RAIL, req);
10129
+ const amount = (0, import_sdk35.resolveSendAmount)(ONCHAIN_SWAP_RAIL, req.raw, req.amount);
9763
10130
  const quote = await client.quote(inputFor2(address, amount));
9764
10131
  const payout = quote.take.amount - claimFee;
9765
10132
  if (payout < ONCHAIN_DUST_SATS) {
@@ -9828,13 +10195,13 @@ var lockupOf = (derived) => ({
9828
10195
  pkScript: derived.swapPkScript
9829
10196
  });
9830
10197
  var covenantInputs = (input) => {
9831
- const network = (0, import_sdk35.networkFromOperatorInfo)(input.info);
9832
- const arkade3 = input.corridors.get("arkade").deps;
10198
+ const network = (0, import_sdk36.networkFromOperatorInfo)(input.info);
10199
+ const arkade4 = input.corridors.get("arkade").deps;
9833
10200
  return {
9834
- operatorPubkey: (0, import_sdk35.toXOnly)(import_base22.hex.decode(input.info.signerPubkey), "ark signer key"),
10201
+ operatorPubkey: (0, import_sdk36.toXOnly)(import_base22.hex.decode(input.info.signerPubkey), "ark signer key"),
9835
10202
  // The resolved per-network pin, never operator-reported: it lands in a covenant leaf
9836
10203
  // that decides who can move the funds.
9837
- emulatorPubkey: (0, import_sdk35.toXOnly)(import_base22.hex.decode(arkade3.emulatorPubkey), "emulator signer key"),
10204
+ emulatorPubkey: (0, import_sdk36.toXOnly)(import_base22.hex.decode(arkade4.emulatorPubkey), "emulator signer key"),
9838
10205
  claimDelay: unilateralClaimDelay(Number(input.info.unilateralExitDelay)),
9839
10206
  hrp: network.hrp
9840
10207
  };
@@ -9892,14 +10259,13 @@ var quoteArkadeAsset = async (input) => {
9892
10259
  );
9893
10260
  }
9894
10261
  const pair = rfqPairFor(input.legs.give, input.legs.take);
9895
- const rfqId = newRfqId();
9896
10262
  const maker = await makerPosition(input.wallet);
9897
10263
  const receiveAddress = payment?.receiveAddress;
9898
10264
  const receivePkScript = resolveReceivePkScript(
9899
10265
  receiveAddress,
9900
10266
  maker.pkScript,
9901
- (0, import_sdk35.networkFromOperatorInfo)(input.info).hrp,
9902
- (0, import_sdk35.toXOnly)(import_base22.hex.decode(input.info.signerPubkey), "ark signer key")
10267
+ (0, import_sdk36.networkFromOperatorInfo)(input.info).hrp,
10268
+ (0, import_sdk36.toXOnly)(import_base22.hex.decode(input.info.signerPubkey), "ark signer key")
9903
10269
  );
9904
10270
  const choice = payment?.carrier;
9905
10271
  const carrierRequest = choice === void 0 ? void 0 : choice.mode === "purchase" ? { mode: "purchase" } : {
@@ -9917,20 +10283,29 @@ var quoteArkadeAsset = async (input) => {
9917
10283
  throw new Error("carrier quote expired before RFQ");
9918
10284
  }
9919
10285
  const request = arkadeSwapRequest({
9920
- rfqId,
10286
+ rfqId: newRfqId(),
9921
10287
  ...sides,
9922
10288
  amount: pinned.value,
9923
10289
  amountSide: toRfqAmountSide(pinned.on),
9924
10290
  makerPkScript: receivePkScript,
9925
- makerPublicKey: maker.publicKey
9926
- });
9927
- const wire = await input.transport.requestQuote({
9928
- ...request,
9929
- profile: {
9930
- ...request.profile,
9931
- ...carrierRequest === void 0 ? {} : { carrier: encodeCarrierRequest(carrierRequest) }
9932
- }
10291
+ makerPublicKey: maker.publicKey,
10292
+ contractVersions: ASSET_SWAP_CONTRACT_VERSIONS
9933
10293
  });
10294
+ const {
10295
+ quote: wire,
10296
+ rfqId,
10297
+ contractVersion
10298
+ } = await requestVersionedQuote(
10299
+ input.transport,
10300
+ {
10301
+ ...request,
10302
+ profile: {
10303
+ ...request.profile,
10304
+ ...carrierRequest === void 0 ? {} : { carrier: encodeCarrierRequest(carrierRequest) }
10305
+ }
10306
+ },
10307
+ ASSET_SWAP_CONTRACT_VERSIONS
10308
+ );
9934
10309
  verifyPair(wire.pair, pair);
9935
10310
  const parsed = parseRfqQuote(wire);
9936
10311
  verifyCrossAssetAmount({ pair, pinned, give: parsed.give, take: parsed.take });
@@ -9963,10 +10338,10 @@ var quoteArkadeAsset = async (input) => {
9963
10338
  ) - 30;
9964
10339
  if (input.now >= validUntil) throw new Error("asset payment terms lapsed before funding");
9965
10340
  assetPayment = {
9966
- receiveAddress: receiveAddress ?? new import_sdk35.ArkAddress(
9967
- (0, import_sdk35.toXOnly)(import_base22.hex.decode(input.info.signerPubkey), "ark signer key"),
10341
+ receiveAddress: receiveAddress ?? new import_sdk36.ArkAddress(
10342
+ (0, import_sdk36.toXOnly)(import_base22.hex.decode(input.info.signerPubkey), "ark signer key"),
9968
10343
  maker.pkScript.slice(2),
9969
- (0, import_sdk35.networkFromOperatorInfo)(input.info).hrp
10344
+ (0, import_sdk36.networkFromOperatorInfo)(input.info).hrp
9970
10345
  ).encode(),
9971
10346
  validUntil,
9972
10347
  ...carrier === void 0 ? {} : { carrier },
@@ -9991,7 +10366,8 @@ var quoteArkadeAsset = async (input) => {
9991
10366
  emulatorPubkey: input.corridors.get("arkade").deps.emulatorPubkey,
9992
10367
  maker,
9993
10368
  ...receiveAddress === void 0 ? {} : { receiveAddress },
9994
- info: input.info
10369
+ info: input.info,
10370
+ contractVersion
9995
10371
  });
9996
10372
  verifyingDerivation(() => verifyOfferAddress(wire, offer));
9997
10373
  return {
@@ -10046,14 +10422,14 @@ var assetSidesOf = (legs) => {
10046
10422
  { give: "arkade", take: "arkade" }
10047
10423
  );
10048
10424
  }
10049
- return giveIsBtc ? { wantAsset: import_sdk35.asset.AssetId.fromString(legs.take.assetId) } : { offerAsset: import_sdk35.asset.AssetId.fromString(legs.give.assetId) };
10425
+ return giveIsBtc ? { wantAsset: import_sdk36.asset.AssetId.fromString(legs.take.assetId) } : { offerAsset: import_sdk36.asset.AssetId.fromString(legs.give.assetId) };
10050
10426
  };
10051
10427
  var makerPosition = async (wallet) => {
10052
10428
  const [address, publicKey] = await Promise.all([
10053
10429
  wallet.getAddress(),
10054
10430
  wallet.identity.xOnlyPublicKey()
10055
10431
  ]);
10056
- return { pkScript: import_sdk35.ArkAddress.decode(address).pkScript, publicKey };
10432
+ return { pkScript: import_sdk36.ArkAddress.decode(address).pkScript, publicKey };
10057
10433
  };
10058
10434
  var quoteLightningSend = async (input) => {
10059
10435
  const invoice = input.endpoints.take.instrument;
@@ -10062,7 +10438,7 @@ var quoteLightningSend = async (input) => {
10062
10438
  }
10063
10439
  const pair = rfqPairFor(input.legs.give, input.legs.take);
10064
10440
  const rfqId = newRfqId();
10065
- const secrets = await (0, import_sdk35.provisionRefundKey)(input.wallet);
10441
+ const secrets = await (0, import_sdk36.provisionRefundKey)(input.wallet);
10066
10442
  const wire = await input.transport.requestQuote(
10067
10443
  lightningSendRequest({
10068
10444
  rfqId,
@@ -10138,7 +10514,7 @@ var quoteLightningReceive = async (input) => {
10138
10514
  const pair = rfqPairFor(input.legs.give, input.legs.take);
10139
10515
  const rfqId = newRfqId();
10140
10516
  const [secrets, payoutAddress] = await Promise.all([
10141
- (0, import_sdk35.provisionClaimSecret)(input.wallet),
10517
+ (0, import_sdk36.provisionClaimSecret)(input.wallet),
10142
10518
  input.wallet.getAddress()
10143
10519
  ]);
10144
10520
  const paymentHash = import_base22.hex.encode(secrets.paymentHash);
@@ -10258,8 +10634,8 @@ var quoteOnchainSend = async (input) => {
10258
10634
  }) : void 0;
10259
10635
  const quoted = claimFee === void 0 ? pinned : { on: pinned.on, value: pinned.value + claimFee, source: pinned.source };
10260
10636
  const [secrets, payoutKey] = await Promise.all([
10261
- (0, import_sdk35.provisionClaimSecret)(input.wallet),
10262
- (0, import_sdk35.provisionRefundKey)(input.wallet)
10637
+ (0, import_sdk36.provisionClaimSecret)(input.wallet),
10638
+ (0, import_sdk36.provisionRefundKey)(input.wallet)
10263
10639
  ]);
10264
10640
  const paymentHash = import_base22.hex.encode(secrets.paymentHash);
10265
10641
  const wire = await input.transport.requestQuote(
@@ -10367,8 +10743,8 @@ var quoteOnchainReceive = async (input) => {
10367
10743
  const rfqId = newRfqId();
10368
10744
  const l1Network = l1NetworkFromArk(input.info.network);
10369
10745
  const [secrets, refundKey, payoutAddress, boardingAddress] = await Promise.all([
10370
- (0, import_sdk35.provisionClaimSecret)(input.wallet),
10371
- (0, import_sdk35.provisionRefundKey)(input.wallet),
10746
+ (0, import_sdk36.provisionClaimSecret)(input.wallet),
10747
+ (0, import_sdk36.provisionRefundKey)(input.wallet),
10372
10748
  input.wallet.getAddress(),
10373
10749
  input.wallet.getBoardingAddress()
10374
10750
  ]);
@@ -10478,7 +10854,7 @@ var quoteOnchainReceive = async (input) => {
10478
10854
  };
10479
10855
 
10480
10856
  // src/client/verbs.ts
10481
- var import_sdk36 = require("@arkade-os/sdk");
10857
+ var import_sdk37 = require("@arkade-os/sdk");
10482
10858
  var enforceFeeCeiling = (quote, call, policy) => {
10483
10859
  let ceiling;
10484
10860
  for (const [source, limit] of [
@@ -10503,14 +10879,14 @@ var settle = async (deps, input, maxFee) => {
10503
10879
  return deps.accept(quote);
10504
10880
  };
10505
10881
  var pay = async (deps, destination, options = {}) => {
10506
- const arkade3 = (0, import_sdk36.arkTarget)(destination);
10507
- if (arkade3 !== void 0) {
10508
- const amount = (0, import_sdk36.resolveSendAmount)(
10882
+ const arkade4 = (0, import_sdk37.arkTarget)(destination);
10883
+ if (arkade4 !== void 0) {
10884
+ const amount = (0, import_sdk37.resolveSendAmount)(
10509
10885
  "ark",
10510
10886
  destination,
10511
10887
  options.amount === void 0 ? void 0 : satsOf(options.amount, "amount")
10512
10888
  );
10513
- return { kind: "payment", txid: await deps.wallet.send({ address: arkade3, amount }) };
10889
+ return { kind: "payment", txid: await deps.wallet.send({ address: arkade4, amount }) };
10514
10890
  }
10515
10891
  const swap = await settle(
10516
10892
  deps,
@@ -10716,7 +11092,7 @@ var createSwapClient = (config) => {
10716
11092
  }
10717
11093
  },
10718
11094
  accept: async (quote, options) => {
10719
- const validUntil = (0, import_sdk37.captureSendDeadline)(options?.validUntil);
11095
+ const validUntil = (0, import_sdk38.captureSendDeadline)(options?.validUntil);
10720
11096
  ensureLive("accept");
10721
11097
  const { corridors } = await resolved();
10722
11098
  const drive2 = driving();
@@ -10831,7 +11207,7 @@ init_rfq();
10831
11207
  init_repository();
10832
11208
 
10833
11209
  // src/indexedDbRepository.ts
10834
- var import_sdk38 = require("@arkade-os/sdk");
11210
+ var import_sdk39 = require("@arkade-os/sdk");
10835
11211
  init_repository();
10836
11212
  var DEFAULT_DB_NAME = "arkade-intents";
10837
11213
  var DB_VERSION = 5;
@@ -10874,7 +11250,7 @@ var IndexedDbAssetSwapRepository = class {
10874
11250
  version = 5;
10875
11251
  connection;
10876
11252
  constructor(dbName = DEFAULT_DB_NAME) {
10877
- this.connection = (0, import_sdk38.createManagedConnection)(dbName, DB_VERSION, initDatabase);
11253
+ this.connection = (0, import_sdk39.createManagedConnection)(dbName, DB_VERSION, initDatabase);
10878
11254
  }
10879
11255
  ensureDb() {
10880
11256
  return this.connection.get();
@@ -10887,7 +11263,7 @@ var IndexedDbAssetSwapRepository = class {
10887
11263
  * transaction, which `awaitTransaction` reports. */
10888
11264
  async write(name, apply) {
10889
11265
  const tx = (await this.ensureDb()).transaction([name], "readwrite");
10890
- const done = (0, import_sdk38.awaitTransaction)(tx);
11266
+ const done = (0, import_sdk39.awaitTransaction)(tx);
10891
11267
  apply(tx.objectStore(name));
10892
11268
  await done;
10893
11269
  }
@@ -10905,10 +11281,10 @@ var IndexedDbAssetSwapRepository = class {
10905
11281
  });
10906
11282
  }
10907
11283
  async getRfqSwap(rfqId) {
10908
- return (0, import_sdk38.promisifyRequest)((await this.readStore(STORE_RFQ_SWAPS)).get(rfqId));
11284
+ return (0, import_sdk39.promisifyRequest)((await this.readStore(STORE_RFQ_SWAPS)).get(rfqId));
10909
11285
  }
10910
11286
  async getRfqSwapsPage(filter, page) {
10911
- (0, import_sdk38.assertPageRequest)(page);
11287
+ (0, import_sdk39.assertPageRequest)(page);
10912
11288
  assertRfqSwapPageFilter(filter);
10913
11289
  const store = await this.readStore(STORE_RFQ_SWAPS);
10914
11290
  const state = filter.state;
@@ -10925,7 +11301,7 @@ var IndexedDbAssetSwapRepository = class {
10925
11301
  const cursor = request.result;
10926
11302
  if (!cursor || state !== void 0 && cursor.key[0] !== state) {
10927
11303
  resolve(
10928
- (0, import_sdk38.pageResult)(rows, page.limit, (row) => ({
11304
+ (0, import_sdk39.pageResult)(rows, page.limit, (row) => ({
10929
11305
  updatedAt: row.updatedAt,
10930
11306
  rfqId: row.rfqId
10931
11307
  }))
@@ -10935,7 +11311,7 @@ var IndexedDbAssetSwapRepository = class {
10935
11311
  rows.push(cursor.value);
10936
11312
  if (rows.length > page.limit) {
10937
11313
  resolve(
10938
- (0, import_sdk38.pageResult)(rows, page.limit, (row) => ({
11314
+ (0, import_sdk39.pageResult)(rows, page.limit, (row) => ({
10939
11315
  updatedAt: row.updatedAt,
10940
11316
  rfqId: row.rfqId
10941
11317
  }))
@@ -10957,13 +11333,13 @@ var IndexedDbAssetSwapRepository = class {
10957
11333
  });
10958
11334
  }
10959
11335
  async getSwapRecord(id) {
10960
- return (0, import_sdk38.promisifyRequest)((await this.readStore(STORE_SWAP_RECORDS)).get(id));
11336
+ return (0, import_sdk39.promisifyRequest)((await this.readStore(STORE_SWAP_RECORDS)).get(id));
10961
11337
  }
10962
11338
  async getSwapRecordsPage(page) {
10963
11339
  return this.pageStore(STORE_SWAP_RECORDS, page);
10964
11340
  }
10965
11341
  async pageStore(name, page) {
10966
- (0, import_sdk38.assertPageRequest)(page);
11342
+ (0, import_sdk39.assertPageRequest)(page);
10967
11343
  const store = await this.readStore(name);
10968
11344
  const range = page.after === void 0 ? void 0 : IDBKeyRange.lowerBound(page.after, true);
10969
11345
  const request = store.openCursor(range);
@@ -10986,7 +11362,7 @@ var IndexedDbAssetSwapRepository = class {
10986
11362
  });
10987
11363
  }
10988
11364
  resultOfPage(rows, limit) {
10989
- const result = (0, import_sdk38.pageResult)(rows, limit, (row) => row.key);
11365
+ const result = (0, import_sdk39.pageResult)(rows, limit, (row) => row.key);
10990
11366
  return {
10991
11367
  items: result.items.map((row) => row.value),
10992
11368
  ...result.nextCursor === void 0 ? {} : { nextCursor: result.nextCursor }
@@ -10998,7 +11374,7 @@ var IndexedDbAssetSwapRepository = class {
10998
11374
  });
10999
11375
  }
11000
11376
  async getScannedTxids() {
11001
- const keys = await (0, import_sdk38.promisifyRequest)((await this.readStore(STORE_SCANNED)).getAllKeys());
11377
+ const keys = await (0, import_sdk39.promisifyRequest)((await this.readStore(STORE_SCANNED)).getAllKeys());
11002
11378
  return new Set(keys);
11003
11379
  }
11004
11380
  async markTxidsScanned(txids) {
@@ -11008,7 +11384,7 @@ var IndexedDbAssetSwapRepository = class {
11008
11384
  }
11009
11385
  async getCachedMarkets(network, registry) {
11010
11386
  const store = await this.readStore(STORE_MARKETS);
11011
- return (0, import_sdk38.promisifyRequest)(store.get(marketsCacheKey(network, registry)));
11387
+ return (0, import_sdk39.promisifyRequest)(store.get(marketsCacheKey(network, registry)));
11012
11388
  }
11013
11389
  async saveCachedMarkets(network, registry, entry) {
11014
11390
  await this.write(STORE_MARKETS, (store) => {
@@ -11021,7 +11397,7 @@ var IndexedDbAssetSwapRepository = class {
11021
11397
  async clear() {
11022
11398
  const stores = STORES.map(([name]) => name);
11023
11399
  const tx = (await this.ensureDb()).transaction(stores, "readwrite");
11024
- const done = (0, import_sdk38.awaitTransaction)(tx);
11400
+ const done = (0, import_sdk39.awaitTransaction)(tx);
11025
11401
  for (const name of stores) tx.objectStore(name).clear();
11026
11402
  await done;
11027
11403
  }
@@ -11035,7 +11411,7 @@ init_claimPacket();
11035
11411
  init_lockupContract();
11036
11412
 
11037
11413
  // src/payment/lightning.ts
11038
- var import_sdk39 = require("@arkade-os/sdk");
11414
+ var import_sdk40 = require("@arkade-os/sdk");
11039
11415
  var LIGHTNING_RAIL = "lightning";
11040
11416
  var inputFor = (invoice, amount) => ({
11041
11417
  to: invoice,
@@ -11045,19 +11421,19 @@ function lightningRail(client) {
11045
11421
  return {
11046
11422
  id: LIGHTNING_RAIL,
11047
11423
  // classification only, so `match` is not a second gate on top of `available`
11048
- match: (req) => (0, import_sdk39.invoiceTarget)(req.raw) !== void 0,
11424
+ match: (req) => (0, import_sdk40.invoiceTarget)(req.raw) !== void 0,
11049
11425
  available: async (req) => {
11050
- if ((0, import_sdk39.assetsOf)(req).length > 0) return false;
11051
- const invoice = (0, import_sdk39.invoiceTarget)(req.raw);
11426
+ if ((0, import_sdk40.assetsOf)(req).length > 0) return false;
11427
+ const invoice = (0, import_sdk40.invoiceTarget)(req.raw);
11052
11428
  if (invoice === void 0) return false;
11053
11429
  return railAvailable(client, inputFor(invoice, req.amount));
11054
11430
  },
11055
11431
  quote: async (req) => {
11056
- const invoice = (0, import_sdk39.invoiceTarget)(req.raw);
11432
+ const invoice = (0, import_sdk40.invoiceTarget)(req.raw);
11057
11433
  if (invoice === void 0) {
11058
11434
  throw new Error(`${LIGHTNING_RAIL}: the request carries no BOLT11 invoice`);
11059
11435
  }
11060
- (0, import_sdk39.assertNoAssets)(LIGHTNING_RAIL, req);
11436
+ (0, import_sdk40.assertNoAssets)(LIGHTNING_RAIL, req);
11061
11437
  const quote = await client.quote(inputFor(invoice, req.amount));
11062
11438
  const amounts = receiverExact(LIGHTNING_RAIL, {
11063
11439
  amount: quote.take.amount,
@@ -11075,7 +11451,7 @@ function lightningRail(client) {
11075
11451
  }
11076
11452
 
11077
11453
  // src/payment/router.ts
11078
- var import_sdk40 = require("@arkade-os/sdk");
11454
+ var import_sdk41 = require("@arkade-os/sdk");
11079
11455
  var SWAP_ROUTER_PRIORITY = [
11080
11456
  "ark",
11081
11457
  LIGHTNING_RAIL,
@@ -11083,15 +11459,15 @@ var SWAP_ROUTER_PRIORITY = [
11083
11459
  "onchain"
11084
11460
  ];
11085
11461
  function createSwapPaymentRouter(wallet, client, config) {
11086
- return new import_sdk40.PaymentRouter({
11462
+ return new import_sdk41.PaymentRouter({
11087
11463
  wallet,
11088
11464
  prefs: { priority: [...SWAP_ROUTER_PRIORITY], ...config.prefs }
11089
- }).use((0, import_sdk40.arkRail)()).use((0, import_sdk40.onchainRail)({ feeInfo: (0, import_sdk40.walletFeeSource)(wallet) })).use(lightningRail(client)).use(onchainSwapRail(client, config));
11465
+ }).use((0, import_sdk41.arkRail)()).use((0, import_sdk41.onchainRail)({ feeInfo: (0, import_sdk41.walletFeeSource)(wallet) })).use(lightningRail(client)).use(onchainSwapRail(client, config));
11090
11466
  }
11091
11467
 
11092
11468
  // src/offerFillPlan.ts
11093
11469
  var import_base24 = require("@scure/base");
11094
- var import_sdk41 = require("@arkade-os/sdk");
11470
+ var import_sdk42 = require("@arkade-os/sdk");
11095
11471
  init_offer();
11096
11472
  var OFFER_FILL_TEMPLATE = "offer-fill/1";
11097
11473
  var OFFER_FILL_OWNERS = [null, "solver", "sponsor"];
@@ -11109,7 +11485,7 @@ async function buildOfferFillPlan(wallet, arkServerUrl, offerHex, opts) {
11109
11485
  const contract = await connectFillContract(wallet, arkServerUrl, offer, { swapAddress });
11110
11486
  const vtxos = await contract.getUtxos();
11111
11487
  const vtxo = resolveDeposit(vtxos, { fundingTxid, fundingOutpoint });
11112
- const solverPayout = payoutScript ?? import_sdk41.ArkAddress.decode(await wallet.getAddress()).pkScript;
11488
+ const solverPayout = payoutScript ?? import_sdk42.ArkAddress.decode(await wallet.getAddress()).pkScript;
11113
11489
  const sponsorLeg = sponsor !== void 0 ? normalizeSponsor(sponsor, assetCarrierSats) : void 0;
11114
11490
  const fill = contract.functions.fulfill();
11115
11491
  const layout = assembleOfferFill(fill, {
@@ -11176,14 +11552,14 @@ function toJointGraph(arkTx, checkpoints, layout, wantedAssetId) {
11176
11552
  }
11177
11553
  });
11178
11554
  const ext = arkTx.getOutput(payments);
11179
- if (!ext?.script || !import_sdk41.Extension.isExtension(ext.script)) {
11555
+ if (!ext?.script || !import_sdk42.Extension.isExtension(ext.script)) {
11180
11556
  throw new Error(`fill plan output ${payments} is not the extension packet`);
11181
11557
  }
11182
11558
  const anchor = arkTx.getOutput(payments + 1);
11183
- if (!anchor?.script || import_base24.hex.encode(anchor.script) !== import_base24.hex.encode(import_sdk41.P2A.script) || anchor.amount !== import_sdk41.P2A.amount) {
11559
+ if (!anchor?.script || import_base24.hex.encode(anchor.script) !== import_base24.hex.encode(import_sdk42.P2A.script) || anchor.amount !== import_sdk42.P2A.amount) {
11184
11560
  throw new Error(`fill plan output ${payments + 1} is not the anchor`);
11185
11561
  }
11186
- const packet = import_sdk41.Extension.fromTx(arkTx).getAssetPacket();
11562
+ const packet = import_sdk42.Extension.fromTx(arkTx).getAssetPacket();
11187
11563
  for (const group of packet?.groups ?? []) {
11188
11564
  if (group.assetId === null) throw new Error("fill plan carries an issuance group");
11189
11565
  const assetId = group.assetId.toString();
@@ -11194,7 +11570,7 @@ function toJointGraph(arkTx, checkpoints, layout, wantedAssetId) {
11194
11570
  }
11195
11571
  for (const output of group.outputs) {
11196
11572
  const hosted = arkTx.getOutput(output.vout);
11197
- if (output.vout >= payments || !hosted?.script || import_sdk41.Extension.isExtension(hosted.script)) {
11573
+ if (output.vout >= payments || !hosted?.script || import_sdk42.Extension.isExtension(hosted.script)) {
11198
11574
  throw new Error(
11199
11575
  `fill plan asset ${assetId} pays nonexistent output ${output.vout}`
11200
11576
  );