@sodax/sdk 2.2.0-rc.2 → 2.2.0-rc.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.cjs CHANGED
@@ -1,13 +1,13 @@
1
1
  'use strict';
2
2
 
3
3
  var viem = require('viem');
4
+ var bitcoinjsLib = require('bitcoinjs-lib');
4
5
  var bcs = require('@mysten/sui/bcs');
5
6
  var web3_js = require('@solana/web3.js');
6
7
  var stellarSdk = require('@stellar/stellar-sdk');
7
8
  var core = require('@sodax/libs/stacks/core');
8
9
  var chains = require('viem/chains');
9
10
  var rlp = require('rlp');
10
- var bitcoinjsLib = require('bitcoinjs-lib');
11
11
  var ecc = require('@bitcoinerlab/secp256k1');
12
12
  var infinitySdk = require('@pancakeswap/infinity-sdk');
13
13
  var transactions = require('@mysten/sui/transactions');
@@ -122,8 +122,8 @@ function serializeCause(cause, depth) {
122
122
  }
123
123
  function sanitizeContext(value, depth) {
124
124
  const out = {};
125
- for (const [key, v10] of Object.entries(value)) {
126
- out[key] = sanitizeValue(v10, depth + 1);
125
+ for (const [key, v12] of Object.entries(value)) {
126
+ out[key] = sanitizeValue(v12, depth + 1);
127
127
  }
128
128
  return out;
129
129
  }
@@ -134,13 +134,13 @@ function sanitizeValue(value, depth) {
134
134
  if (t === "bigint") return value.toString();
135
135
  if (t === "string" || t === "number" || t === "boolean") return value;
136
136
  if (t === "function" || t === "symbol") return safeString(value);
137
- if (Array.isArray(value)) return value.map((v10) => sanitizeValue(v10, depth + 1));
137
+ if (Array.isArray(value)) return value.map((v12) => sanitizeValue(v12, depth + 1));
138
138
  if (value instanceof Date) return value.toISOString();
139
139
  if (value instanceof Map) {
140
- return Array.from(value.entries()).map(([k, v10]) => [sanitizeValue(k, depth + 1), sanitizeValue(v10, depth + 1)]);
140
+ return Array.from(value.entries()).map(([k, v12]) => [sanitizeValue(k, depth + 1), sanitizeValue(v12, depth + 1)]);
141
141
  }
142
142
  if (value instanceof Set) {
143
- return Array.from(value.values()).map((v10) => sanitizeValue(v10, depth + 1));
143
+ return Array.from(value.values()).map((v12) => sanitizeValue(v12, depth + 1));
144
144
  }
145
145
  if (value instanceof Error) return { name: value.name, message: value.message };
146
146
  if (t === "object") {
@@ -152,9 +152,9 @@ function sanitizeValue(value, depth) {
152
152
  }
153
153
  return safeString(value);
154
154
  }
155
- function safeString(v10) {
155
+ function safeString(v12) {
156
156
  try {
157
- return String(v10);
157
+ return String(v12);
158
158
  } catch {
159
159
  return "[unserializable]";
160
160
  }
@@ -353,7 +353,20 @@ var HubVaultSymbols = [
353
353
  "sodaHBAR",
354
354
  "sodaJITOSOL",
355
355
  "sodaUSDS",
356
- "sodaUSSD"
356
+ "sodaUSSD",
357
+ "SPCX",
358
+ "NVDA",
359
+ "GME",
360
+ "MSTR",
361
+ "AAPL",
362
+ "TSLA",
363
+ "MU",
364
+ "SNDK",
365
+ "SPY",
366
+ "QQQ",
367
+ "SGOV",
368
+ "USO",
369
+ "SLV"
357
370
  ];
358
371
  var SodaTokens = {
359
372
  sodaBNB: {
@@ -616,9 +629,126 @@ var SodaTokens = {
616
629
  chainKey: ChainKeys.SONIC_MAINNET,
617
630
  hubAsset: "0xb780e09576C2667ba9F5B80FbAb2e6b8A0a21e37",
618
631
  vault: "0xb780e09576C2667ba9F5B80FbAb2e6b8A0a21e37"
632
+ },
633
+ SPCX: {
634
+ symbol: "SPCX",
635
+ name: "Space Exploration Technologies Corp. Class A Common Stock \u2022 Robinhood Token",
636
+ decimals: 18,
637
+ address: "0xB585e2EEa070eB4E4D877A707aEC3B718edb2373",
638
+ chainKey: ChainKeys.SONIC_MAINNET,
639
+ hubAsset: "0xB585e2EEa070eB4E4D877A707aEC3B718edb2373",
640
+ vault: "0xB585e2EEa070eB4E4D877A707aEC3B718edb2373"
641
+ },
642
+ NVDA: {
643
+ symbol: "NVDA",
644
+ name: "NVIDIA \u2022 Robinhood Token",
645
+ decimals: 18,
646
+ address: "0x2D5D2250EE426cA318efBd03ddf926B23c96f74B",
647
+ chainKey: ChainKeys.SONIC_MAINNET,
648
+ hubAsset: "0x2D5D2250EE426cA318efBd03ddf926B23c96f74B",
649
+ vault: "0x2D5D2250EE426cA318efBd03ddf926B23c96f74B"
650
+ },
651
+ GME: {
652
+ symbol: "GME",
653
+ name: "GameStop \u2022 Robinhood Token",
654
+ decimals: 18,
655
+ address: "0x996e5591e4692e2B7d8fB6926DeA4EE1950Ef394",
656
+ chainKey: ChainKeys.SONIC_MAINNET,
657
+ hubAsset: "0x996e5591e4692e2B7d8fB6926DeA4EE1950Ef394",
658
+ vault: "0x996e5591e4692e2B7d8fB6926DeA4EE1950Ef394"
659
+ },
660
+ MSTR: {
661
+ symbol: "MSTR",
662
+ name: "Strategy Inc. \u2022 Robinhood Token",
663
+ decimals: 18,
664
+ address: "0xE0E2aF45EBf5700a90E63c41B0ecE042A240Fab1",
665
+ chainKey: ChainKeys.SONIC_MAINNET,
666
+ hubAsset: "0xE0E2aF45EBf5700a90E63c41B0ecE042A240Fab1",
667
+ vault: "0xE0E2aF45EBf5700a90E63c41B0ecE042A240Fab1"
668
+ },
669
+ AAPL: {
670
+ symbol: "AAPL",
671
+ name: "Apple \u2022 Robinhood Token",
672
+ decimals: 18,
673
+ address: "0x4712D2D49Ba3be41DA334FCB3616FDdc0d745185",
674
+ chainKey: ChainKeys.SONIC_MAINNET,
675
+ hubAsset: "0x4712D2D49Ba3be41DA334FCB3616FDdc0d745185",
676
+ vault: "0x4712D2D49Ba3be41DA334FCB3616FDdc0d745185"
677
+ },
678
+ TSLA: {
679
+ symbol: "TSLA",
680
+ name: "Tesla \u2022 Robinhood Token",
681
+ decimals: 18,
682
+ address: "0x8B7F46967Ed9367A70b2e046D5e26a03625d53b1",
683
+ chainKey: ChainKeys.SONIC_MAINNET,
684
+ hubAsset: "0x8B7F46967Ed9367A70b2e046D5e26a03625d53b1",
685
+ vault: "0x8B7F46967Ed9367A70b2e046D5e26a03625d53b1"
686
+ },
687
+ MU: {
688
+ symbol: "MU",
689
+ name: "Micron Technology \u2022 Robinhood Token",
690
+ decimals: 18,
691
+ address: "0x108147b16186B895344F5752468190B9EE0e3A22",
692
+ chainKey: ChainKeys.SONIC_MAINNET,
693
+ hubAsset: "0x108147b16186B895344F5752468190B9EE0e3A22",
694
+ vault: "0x108147b16186B895344F5752468190B9EE0e3A22"
695
+ },
696
+ SNDK: {
697
+ symbol: "SNDK",
698
+ name: "Sandisk Corporation \u2022 Robinhood Token",
699
+ decimals: 18,
700
+ address: "0x568F29855B7B46EdA38ed95771FAeC498c507EF7",
701
+ chainKey: ChainKeys.SONIC_MAINNET,
702
+ hubAsset: "0x568F29855B7B46EdA38ed95771FAeC498c507EF7",
703
+ vault: "0x568F29855B7B46EdA38ed95771FAeC498c507EF7"
704
+ },
705
+ SPY: {
706
+ symbol: "SPY",
707
+ name: "SPDR S&P 500 ETF Trust \u2022 Robinhood Token",
708
+ decimals: 18,
709
+ address: "0x1816E408f0448D0CaD3e0D490bd2590d921Bb0c8",
710
+ chainKey: ChainKeys.SONIC_MAINNET,
711
+ hubAsset: "0x1816E408f0448D0CaD3e0D490bd2590d921Bb0c8",
712
+ vault: "0x1816E408f0448D0CaD3e0D490bd2590d921Bb0c8"
713
+ },
714
+ QQQ: {
715
+ symbol: "QQQ",
716
+ name: "Invesco QQQ \u2022 Robinhood Token",
717
+ decimals: 18,
718
+ address: "0x454ab3DeFd9df0749d450b145D4516e317E3e500",
719
+ chainKey: ChainKeys.SONIC_MAINNET,
720
+ hubAsset: "0x454ab3DeFd9df0749d450b145D4516e317E3e500",
721
+ vault: "0x454ab3DeFd9df0749d450b145D4516e317E3e500"
722
+ },
723
+ SGOV: {
724
+ symbol: "SGOV",
725
+ name: "iShares 0-3 Month Treasury Bond \u2022 Robinhood Token",
726
+ decimals: 18,
727
+ address: "0xf6938087cf794B08739b926B41FF8F1E90816E74",
728
+ chainKey: ChainKeys.SONIC_MAINNET,
729
+ hubAsset: "0xf6938087cf794B08739b926B41FF8F1E90816E74",
730
+ vault: "0xf6938087cf794B08739b926B41FF8F1E90816E74"
731
+ },
732
+ USO: {
733
+ symbol: "USO",
734
+ name: "United States Oil Fund \u2022 Robinhood Token",
735
+ decimals: 18,
736
+ address: "0x8DaBbADcecfc1a0B91fc68c72301090bc220D2bc",
737
+ chainKey: ChainKeys.SONIC_MAINNET,
738
+ hubAsset: "0x8DaBbADcecfc1a0B91fc68c72301090bc220D2bc",
739
+ vault: "0x8DaBbADcecfc1a0B91fc68c72301090bc220D2bc"
740
+ },
741
+ SLV: {
742
+ symbol: "SLV",
743
+ name: "iShares Silver Trust \u2022 Robinhood Token",
744
+ decimals: 18,
745
+ address: "0x690B92c27ac80015E57DB8cc02A81255814f49A2",
746
+ chainKey: ChainKeys.SONIC_MAINNET,
747
+ hubAsset: "0x690B92c27ac80015E57DB8cc02A81255814f49A2",
748
+ vault: "0x690B92c27ac80015E57DB8cc02A81255814f49A2"
619
749
  }
620
750
  };
621
- var LsodaSymbols = ["lsodaWEETH", "lsodaWSTETH", "lsodaJITOSOL"];
751
+ var LsodaSymbols = ["lsodaWEETH", "lsodaWSTETH", "lsodaJITOSOL", "lsodaSUSDS"];
622
752
  var LsodaTokens = {
623
753
  lsodaWEETH: {
624
754
  symbol: "lsodaWEETH",
@@ -646,6 +776,15 @@ var LsodaTokens = {
646
776
  chainKey: ChainKeys.SONIC_MAINNET,
647
777
  hubAsset: "0xD7Ae4853E0f93682F5DaA14734F5D18cBa09Bd78",
648
778
  vault: "0xD7Ae4853E0f93682F5DaA14734F5D18cBa09Bd78"
779
+ },
780
+ lsodaSUSDS: {
781
+ symbol: "lsodaSUSDS",
782
+ name: "Leveraged Soda sUSDS",
783
+ decimals: 18,
784
+ address: "0x758532F160D9D338bf662A4a59BA31a5B918A7cb",
785
+ chainKey: ChainKeys.SONIC_MAINNET,
786
+ hubAsset: "0x758532F160D9D338bf662A4a59BA31a5B918A7cb",
787
+ vault: "0x758532F160D9D338bf662A4a59BA31a5B918A7cb"
649
788
  }
650
789
  };
651
790
  var sonicSupportedTokens = {
@@ -2209,6 +2348,123 @@ var stellarSupportedTokens = {
2209
2348
  chainKey: ChainKeys.STELLAR_MAINNET,
2210
2349
  hubAsset: "0xE36b8F88651004e29FD2001aEace777671731d65",
2211
2350
  vault: SodaTokens.sodaUSDS.address
2351
+ },
2352
+ SPCX: {
2353
+ symbol: "SPCX",
2354
+ name: "SpaceX Class A",
2355
+ decimals: 7,
2356
+ address: "CAI4HHAYO57QICZOZ4JF7R66RLGJRD7BGTX7H6MILCITVEYYEFRYFISK",
2357
+ chainKey: ChainKeys.STELLAR_MAINNET,
2358
+ hubAsset: "0xd24B7ba6c066E024A86e76BAb3baBd4625c346C0",
2359
+ vault: SodaTokens.SPCX.address
2360
+ },
2361
+ NVDA: {
2362
+ symbol: "NVDA",
2363
+ name: "NVIDIA",
2364
+ decimals: 7,
2365
+ address: "CCQFCT4FHJURUQ4RQA4NHYW5GQRHCBDXF33ADXZRTDTDVGKOJO3ZPEMY",
2366
+ chainKey: ChainKeys.STELLAR_MAINNET,
2367
+ hubAsset: "0x46609A9bEDb673caade4F36c4114dAc758564e76",
2368
+ vault: SodaTokens.NVDA.address
2369
+ },
2370
+ GME: {
2371
+ symbol: "GME",
2372
+ name: "GameStop",
2373
+ decimals: 7,
2374
+ address: "CAPSLSLCTFOZM22SUIPQENMM54T24GTDRHZ5STYAO6EYMK5GGGYVKWBX",
2375
+ chainKey: ChainKeys.STELLAR_MAINNET,
2376
+ hubAsset: "0x7A45571d28E8d2D8548a56965837bd7F35d5Fb20",
2377
+ vault: SodaTokens.GME.address
2378
+ },
2379
+ MSTR: {
2380
+ symbol: "MSTR",
2381
+ name: "Strategy",
2382
+ decimals: 7,
2383
+ address: "CAFQQXZSECLJNU76OS2OKLJQJBQHYJCVAYZJ4KGEN7VHXH5BTGNLVQND",
2384
+ chainKey: ChainKeys.STELLAR_MAINNET,
2385
+ hubAsset: "0xaC6Ab7ef0F46aAb624f1Cfd811a7f2229F7FFC1c",
2386
+ vault: SodaTokens.MSTR.address
2387
+ },
2388
+ AAPL: {
2389
+ symbol: "AAPL",
2390
+ name: "Apple",
2391
+ decimals: 7,
2392
+ address: "CAZSFDNSSR2RKJ2LIIB2Y4G4WOSYYKC4646EUJ63PQLDDHOVQYZ4HDTK",
2393
+ chainKey: ChainKeys.STELLAR_MAINNET,
2394
+ hubAsset: "0x9B37F4b9d9E47f5b4fA5eC3566a55D52030AEC4C",
2395
+ vault: SodaTokens.AAPL.address
2396
+ },
2397
+ TSLA: {
2398
+ symbol: "TSLA",
2399
+ name: "Tesla",
2400
+ decimals: 7,
2401
+ address: "CARLFQDI2S2FSYFB47AZLKGUFZVGBEUVNW77SCJHHHGL2KPGT3TN5PAB",
2402
+ chainKey: ChainKeys.STELLAR_MAINNET,
2403
+ hubAsset: "0x595bA45dA064bA4fF4de821A0b5105dbDfac5C9f",
2404
+ vault: SodaTokens.TSLA.address
2405
+ },
2406
+ MU: {
2407
+ symbol: "MU",
2408
+ name: "Micron",
2409
+ decimals: 7,
2410
+ address: "CBPTKA32BTUEX4VFAER6AUFWQZCWJKQAMLV2PMFFN7EHLGLJN4JWIZ3F",
2411
+ chainKey: ChainKeys.STELLAR_MAINNET,
2412
+ hubAsset: "0x14a28CFb7ef407EdEfD377c4Fe59e86e9B050A20",
2413
+ vault: SodaTokens.MU.address
2414
+ },
2415
+ SNDK: {
2416
+ symbol: "SNDK",
2417
+ name: "SanDisk",
2418
+ decimals: 7,
2419
+ address: "CDXNTHFMGQM33UGQBSLZI3BV5UWW62QGZLCEKOXJKMFN2W3KQZKE3LTQ",
2420
+ chainKey: ChainKeys.STELLAR_MAINNET,
2421
+ hubAsset: "0xeb6a0595F42Ba66AF7716d92F8Db45633FFec29f",
2422
+ vault: SodaTokens.SNDK.address
2423
+ },
2424
+ SPY: {
2425
+ symbol: "SPY",
2426
+ name: "SPDR S&P 500 ETF Trust",
2427
+ decimals: 7,
2428
+ address: "CD3ZMWOS4PZS2RQITEHBOTS27DTDP4QKOK7IEO5IB64GQKHRJYTVL3SW",
2429
+ chainKey: ChainKeys.STELLAR_MAINNET,
2430
+ hubAsset: "0x31FBa56e8b2e539B2f295fD35d76Fa0AE4f9d4DE",
2431
+ vault: SodaTokens.SPY.address
2432
+ },
2433
+ QQQ: {
2434
+ symbol: "QQQ",
2435
+ name: "Invesco QQQ Trust",
2436
+ decimals: 7,
2437
+ address: "CC7DQX43J2KBK5MJACQWTNHENIYB5GUVCFXGDKQWDLUWA4VKLOOU5PWB",
2438
+ chainKey: ChainKeys.STELLAR_MAINNET,
2439
+ hubAsset: "0xbf6d4C1C71A7E0Df2e5a9AE4b10d7488fb1A09D3",
2440
+ vault: SodaTokens.QQQ.address
2441
+ },
2442
+ SGOV: {
2443
+ symbol: "SGOV",
2444
+ name: "iShares 0-3 Month Treasury Bond ETF",
2445
+ decimals: 7,
2446
+ address: "CBQMRO2JTUJ6NXVBQ3XGJV34PDTXR34DD74TLLRCW5SV2CV2NN2VDMLH",
2447
+ chainKey: ChainKeys.STELLAR_MAINNET,
2448
+ hubAsset: "0xFB92b29Cf80Fb600fe8C51B0f0e932529C1509dF",
2449
+ vault: SodaTokens.SGOV.address
2450
+ },
2451
+ USO: {
2452
+ symbol: "USO",
2453
+ name: "United States Oil Fund LP",
2454
+ decimals: 7,
2455
+ address: "CCFRCTIW5EK2OK626V6C4YRTJCKACIRDI2GHOKWM57ZXACK2ZTWWWLC7",
2456
+ chainKey: ChainKeys.STELLAR_MAINNET,
2457
+ hubAsset: "0xa9f388938Eb8956BDe9fE047885a175e38Fa90C1",
2458
+ vault: SodaTokens.USO.address
2459
+ },
2460
+ SLV: {
2461
+ symbol: "SLV",
2462
+ name: "iShares Silver Trust",
2463
+ decimals: 7,
2464
+ address: "CBY3U32O5T2B555HNJLX6C6HW3O2FLRSJGH472UOOHT6H6ZMGMSSZTLW",
2465
+ chainKey: ChainKeys.STELLAR_MAINNET,
2466
+ hubAsset: "0x7eaF987431ce072feBEB2124fEB4d1cEf8Cf4e2e",
2467
+ vault: SodaTokens.SLV.address
2212
2468
  }
2213
2469
  };
2214
2470
  var suiSupportedTokens = {
@@ -2881,6 +3137,123 @@ var hederaSupportedTokens = {
2881
3137
  chainKey: ChainKeys.HEDERA_MAINNET,
2882
3138
  hubAsset: "0xce6260224897fe05aad4b00df6cf9d318fe4ae23",
2883
3139
  vault: SodaTokens.sodaXLM.address
3140
+ },
3141
+ SPCX: {
3142
+ symbol: "SPCX",
3143
+ name: "SpaceX Class A",
3144
+ decimals: 8,
3145
+ address: "0x0000000000000000000000000000000000a5669e",
3146
+ chainKey: ChainKeys.HEDERA_MAINNET,
3147
+ hubAsset: "0x5b31b616600531e80e28d266526D8d2F4dB2B46c",
3148
+ vault: SodaTokens.SPCX.address
3149
+ },
3150
+ NVDA: {
3151
+ symbol: "NVDA",
3152
+ name: "NVIDIA",
3153
+ decimals: 8,
3154
+ address: "0x0000000000000000000000000000000000a5669f",
3155
+ chainKey: ChainKeys.HEDERA_MAINNET,
3156
+ hubAsset: "0xfef4B7437485062D07EfdC46C667163E4beaa451",
3157
+ vault: SodaTokens.NVDA.address
3158
+ },
3159
+ GME: {
3160
+ symbol: "GME",
3161
+ name: "GameStop",
3162
+ decimals: 8,
3163
+ address: "0x0000000000000000000000000000000000a567d9",
3164
+ chainKey: ChainKeys.HEDERA_MAINNET,
3165
+ hubAsset: "0x074B3035D7046D5f75Dfc8e2aD1848a915BD308E",
3166
+ vault: SodaTokens.GME.address
3167
+ },
3168
+ MSTR: {
3169
+ symbol: "MSTR",
3170
+ name: "Strategy",
3171
+ decimals: 8,
3172
+ address: "0x0000000000000000000000000000000000a567e0",
3173
+ chainKey: ChainKeys.HEDERA_MAINNET,
3174
+ hubAsset: "0xa8b6f37FDc7D084A6C2530cc1De597ccEC526570",
3175
+ vault: SodaTokens.MSTR.address
3176
+ },
3177
+ AAPL: {
3178
+ symbol: "AAPL",
3179
+ name: "Apple",
3180
+ decimals: 8,
3181
+ address: "0x0000000000000000000000000000000000a567e1",
3182
+ chainKey: ChainKeys.HEDERA_MAINNET,
3183
+ hubAsset: "0xFDFf1e1Bec68fC9c75A2c89474C848A31Be49242",
3184
+ vault: SodaTokens.AAPL.address
3185
+ },
3186
+ TSLA: {
3187
+ symbol: "TSLA",
3188
+ name: "Tesla",
3189
+ decimals: 8,
3190
+ address: "0x0000000000000000000000000000000000a567e2",
3191
+ chainKey: ChainKeys.HEDERA_MAINNET,
3192
+ hubAsset: "0x1ff47B26bfd9019671f543E6dd8c61b06f1358b4",
3193
+ vault: SodaTokens.TSLA.address
3194
+ },
3195
+ MU: {
3196
+ symbol: "MU",
3197
+ name: "Micron",
3198
+ decimals: 8,
3199
+ address: "0x0000000000000000000000000000000000a567e3",
3200
+ chainKey: ChainKeys.HEDERA_MAINNET,
3201
+ hubAsset: "0x3b94E6d81FA505F20dda3cC25A18b80E921b8580",
3202
+ vault: SodaTokens.MU.address
3203
+ },
3204
+ SNDK: {
3205
+ symbol: "SNDK",
3206
+ name: "SanDisk",
3207
+ decimals: 8,
3208
+ address: "0x0000000000000000000000000000000000a567e5",
3209
+ chainKey: ChainKeys.HEDERA_MAINNET,
3210
+ hubAsset: "0x2D27112f45275F3B6B00A2a8A1434CA0E36488Ef",
3211
+ vault: SodaTokens.SNDK.address
3212
+ },
3213
+ SPY: {
3214
+ symbol: "SPY",
3215
+ name: "SPDR S&P 500 ETF Trust",
3216
+ decimals: 8,
3217
+ address: "0x0000000000000000000000000000000000a567e7",
3218
+ chainKey: ChainKeys.HEDERA_MAINNET,
3219
+ hubAsset: "0x555f6A769C3c20E8Ec3e77a2DD61c774997Bf9Eb",
3220
+ vault: SodaTokens.SPY.address
3221
+ },
3222
+ QQQ: {
3223
+ symbol: "QQQ",
3224
+ name: "Invesco QQQ Trust",
3225
+ decimals: 8,
3226
+ address: "0x0000000000000000000000000000000000a567ea",
3227
+ chainKey: ChainKeys.HEDERA_MAINNET,
3228
+ hubAsset: "0x49E76ce05878B1eCaAaA8683eA6C9773862F7F6C",
3229
+ vault: SodaTokens.QQQ.address
3230
+ },
3231
+ SGOV: {
3232
+ symbol: "SGOV",
3233
+ name: "iShares 0-3 Month Treasury Bond ETF",
3234
+ decimals: 8,
3235
+ address: "0x0000000000000000000000000000000000a567ec",
3236
+ chainKey: ChainKeys.HEDERA_MAINNET,
3237
+ hubAsset: "0x7E0b366d53B9f45aB02048DAD426bec55c36181C",
3238
+ vault: SodaTokens.SGOV.address
3239
+ },
3240
+ USO: {
3241
+ symbol: "USO",
3242
+ name: "United States Oil Fund LP",
3243
+ decimals: 8,
3244
+ address: "0x0000000000000000000000000000000000a567ed",
3245
+ chainKey: ChainKeys.HEDERA_MAINNET,
3246
+ hubAsset: "0x7bbd99721639c5862B16E109eE9Ae1f14C50B5f8",
3247
+ vault: SodaTokens.USO.address
3248
+ },
3249
+ SLV: {
3250
+ symbol: "SLV",
3251
+ name: "iShares Silver Trust",
3252
+ decimals: 8,
3253
+ address: "0x0000000000000000000000000000000000a567f2",
3254
+ chainKey: ChainKeys.HEDERA_MAINNET,
3255
+ hubAsset: "0x914672C5336f5E00126e431368005f7C22aCe952",
3256
+ vault: SodaTokens.SLV.address
2884
3257
  }
2885
3258
  };
2886
3259
  var robinhoodSupportedTokens = {
@@ -2919,6 +3292,128 @@ var robinhoodSupportedTokens = {
2919
3292
  chainKey: ChainKeys.ROBINHOOD_MAINNET,
2920
3293
  hubAsset: "0xb2e81dddffcc9e49e9c9ded644091dfecf4ff4e7",
2921
3294
  vault: SodaTokens.sodaUSDC.address
3295
+ },
3296
+ // Tokenized stocks, ETFs and commodity ETPs — Robinhood's own "<Company> •
3297
+ // Robinhood Token" product. No dedicated Sonic vault exists for any of these
3298
+ // yet, so `vault` mirrors `hubAsset` (same convention as the Solana xStock
3299
+ // entries). DJT, GLD and RDDT are intentionally omitted — no Chainlink price
3300
+ // feed exists for them, so the solver cannot price or swap them.
3301
+ SPCX: {
3302
+ symbol: "SPCX",
3303
+ name: "SpaceX Class A",
3304
+ decimals: 18,
3305
+ address: "0x4a0E65A3EcceC6dBe60AE065F2e7bb85Fae35eEa",
3306
+ chainKey: ChainKeys.ROBINHOOD_MAINNET,
3307
+ hubAsset: "0x2676b346bea3a760fe5386014e51760b511f65fb",
3308
+ vault: SodaTokens.SPCX.address
3309
+ },
3310
+ NVDA: {
3311
+ symbol: "NVDA",
3312
+ name: "NVIDIA",
3313
+ decimals: 18,
3314
+ address: "0xd0601CE157Db5bdC3162BbaC2a2C8aF5320D9EEC",
3315
+ chainKey: ChainKeys.ROBINHOOD_MAINNET,
3316
+ hubAsset: "0xa754bf15f0289b539aae5ce1a453e28898b7704e",
3317
+ vault: SodaTokens.NVDA.address
3318
+ },
3319
+ GME: {
3320
+ symbol: "GME",
3321
+ name: "GameStop",
3322
+ decimals: 18,
3323
+ address: "0x1b0E319c6A659F002271B69dB8A7df2F911c153E",
3324
+ chainKey: ChainKeys.ROBINHOOD_MAINNET,
3325
+ hubAsset: "0x9f9a7d7283a897b2d4b16eb6dd07faa40fead168",
3326
+ vault: SodaTokens.GME.address
3327
+ },
3328
+ MSTR: {
3329
+ symbol: "MSTR",
3330
+ name: "Strategy",
3331
+ decimals: 18,
3332
+ address: "0xec262a75e413fAfD0dF80480274532C79D42da09",
3333
+ chainKey: ChainKeys.ROBINHOOD_MAINNET,
3334
+ hubAsset: "0x3dea14c781e6750e8524c47cb2a9becc1c63d599",
3335
+ vault: SodaTokens.MSTR.address
3336
+ },
3337
+ AAPL: {
3338
+ symbol: "AAPL",
3339
+ name: "Apple",
3340
+ decimals: 18,
3341
+ address: "0xaF3D76f1834A1d425780943C99Ea8A608f8a93f9",
3342
+ chainKey: ChainKeys.ROBINHOOD_MAINNET,
3343
+ hubAsset: "0xf66a3327066c97c00915d5017262fb37d000a5df",
3344
+ vault: SodaTokens.AAPL.address
3345
+ },
3346
+ TSLA: {
3347
+ symbol: "TSLA",
3348
+ name: "Tesla",
3349
+ decimals: 18,
3350
+ address: "0x322F0929c4625eD5bAd873c95208D54E1c003b2d",
3351
+ chainKey: ChainKeys.ROBINHOOD_MAINNET,
3352
+ hubAsset: "0x22bd6dc64fca01887818b5c701bf3f8cc5679461",
3353
+ vault: SodaTokens.TSLA.address
3354
+ },
3355
+ MU: {
3356
+ symbol: "MU",
3357
+ name: "Micron",
3358
+ decimals: 18,
3359
+ address: "0xfF080c8ce2E5feadaCa0Da81314Ae59D232d4afD",
3360
+ chainKey: ChainKeys.ROBINHOOD_MAINNET,
3361
+ hubAsset: "0xab01212d77d27b1098bf64b812300f81e1448f37",
3362
+ vault: SodaTokens.MU.address
3363
+ },
3364
+ SNDK: {
3365
+ symbol: "SNDK",
3366
+ name: "SanDisk",
3367
+ decimals: 18,
3368
+ address: "0xB90A19fF0Af67f7779afF50A882A9CfF42446400",
3369
+ chainKey: ChainKeys.ROBINHOOD_MAINNET,
3370
+ hubAsset: "0xc30bf06eafff781cddb65b3bd337a214be9ff7f7",
3371
+ vault: SodaTokens.SNDK.address
3372
+ },
3373
+ SPY: {
3374
+ symbol: "SPY",
3375
+ name: "SPDR S&P 500 ETF Trust",
3376
+ decimals: 18,
3377
+ address: "0x117cc2133c37B721F49dE2A7a74833232B3B4C0C",
3378
+ chainKey: ChainKeys.ROBINHOOD_MAINNET,
3379
+ hubAsset: "0x6ec91122458067b436c84bd8c0be5d8cd5f222e8",
3380
+ vault: SodaTokens.SPY.address
3381
+ },
3382
+ QQQ: {
3383
+ symbol: "QQQ",
3384
+ name: "Invesco QQQ Trust",
3385
+ decimals: 18,
3386
+ address: "0xD5f3879160bc7c32ebb4dC785F8a4F505888de68",
3387
+ chainKey: ChainKeys.ROBINHOOD_MAINNET,
3388
+ hubAsset: "0xb3b0b8ae18c34545d8e0234d3e4ba86db46eca5b",
3389
+ vault: SodaTokens.QQQ.address
3390
+ },
3391
+ SGOV: {
3392
+ symbol: "SGOV",
3393
+ name: "iShares 0-3 Month Treasury Bond ETF",
3394
+ decimals: 18,
3395
+ address: "0x92FD66527192E3e61d4DDd13322Aa222DE86F9B5",
3396
+ chainKey: ChainKeys.ROBINHOOD_MAINNET,
3397
+ hubAsset: "0x8f33dbcbdc6572adb8b030508a02b599380f3cc7",
3398
+ vault: SodaTokens.SGOV.address
3399
+ },
3400
+ USO: {
3401
+ symbol: "USO",
3402
+ name: "United States Oil Fund LP",
3403
+ decimals: 18,
3404
+ address: "0xa30FA36Db767ad9eD3f7a60fC79526fB4d56D344",
3405
+ chainKey: ChainKeys.ROBINHOOD_MAINNET,
3406
+ hubAsset: "0x9c188579ba2ed2e8ea15e5f53392820add3af9ce",
3407
+ vault: SodaTokens.USO.address
3408
+ },
3409
+ SLV: {
3410
+ symbol: "SLV",
3411
+ name: "iShares Silver Trust",
3412
+ decimals: 18,
3413
+ address: "0x411eFb0E7f985935DAec3D4C3ebaEa0d0AD7D89f",
3414
+ chainKey: ChainKeys.ROBINHOOD_MAINNET,
3415
+ hubAsset: "0x17348849806c8b1b5d1d3abbcb527d05d21d09d5",
3416
+ vault: SodaTokens.SLV.address
2922
3417
  }
2923
3418
  };
2924
3419
  var stacksSupportedTokens = {
@@ -3673,6 +4168,71 @@ var spokeChainConfig = {
3673
4168
  assetCode: "USDS",
3674
4169
  contractId: "CC552JLYIJROE24VZFSMO7GBKQOOIQ6R52E3VQSQYC7NMFYAVMC7GQHS",
3675
4170
  assetIssuer: "GDYUTHY75A7WUZJQDPOP66FB32BOYGZRXHWTWO4Q6LQTANT5X3V5HNFA"
4171
+ },
4172
+ {
4173
+ assetCode: "SPCX",
4174
+ contractId: "CAI4HHAYO57QICZOZ4JF7R66RLGJRD7BGTX7H6MILCITVEYYEFRYFISK",
4175
+ assetIssuer: "GDYUTHY75A7WUZJQDPOP66FB32BOYGZRXHWTWO4Q6LQTANT5X3V5HNFA"
4176
+ },
4177
+ {
4178
+ assetCode: "NVDA",
4179
+ contractId: "CCQFCT4FHJURUQ4RQA4NHYW5GQRHCBDXF33ADXZRTDTDVGKOJO3ZPEMY",
4180
+ assetIssuer: "GDYUTHY75A7WUZJQDPOP66FB32BOYGZRXHWTWO4Q6LQTANT5X3V5HNFA"
4181
+ },
4182
+ {
4183
+ assetCode: "GME",
4184
+ contractId: "CAPSLSLCTFOZM22SUIPQENMM54T24GTDRHZ5STYAO6EYMK5GGGYVKWBX",
4185
+ assetIssuer: "GDYUTHY75A7WUZJQDPOP66FB32BOYGZRXHWTWO4Q6LQTANT5X3V5HNFA"
4186
+ },
4187
+ {
4188
+ assetCode: "MSTR",
4189
+ contractId: "CAFQQXZSECLJNU76OS2OKLJQJBQHYJCVAYZJ4KGEN7VHXH5BTGNLVQND",
4190
+ assetIssuer: "GDYUTHY75A7WUZJQDPOP66FB32BOYGZRXHWTWO4Q6LQTANT5X3V5HNFA"
4191
+ },
4192
+ {
4193
+ assetCode: "AAPL",
4194
+ contractId: "CAZSFDNSSR2RKJ2LIIB2Y4G4WOSYYKC4646EUJ63PQLDDHOVQYZ4HDTK",
4195
+ assetIssuer: "GDYUTHY75A7WUZJQDPOP66FB32BOYGZRXHWTWO4Q6LQTANT5X3V5HNFA"
4196
+ },
4197
+ {
4198
+ assetCode: "TSLA",
4199
+ contractId: "CARLFQDI2S2FSYFB47AZLKGUFZVGBEUVNW77SCJHHHGL2KPGT3TN5PAB",
4200
+ assetIssuer: "GDYUTHY75A7WUZJQDPOP66FB32BOYGZRXHWTWO4Q6LQTANT5X3V5HNFA"
4201
+ },
4202
+ {
4203
+ assetCode: "MU",
4204
+ contractId: "CBPTKA32BTUEX4VFAER6AUFWQZCWJKQAMLV2PMFFN7EHLGLJN4JWIZ3F",
4205
+ assetIssuer: "GDYUTHY75A7WUZJQDPOP66FB32BOYGZRXHWTWO4Q6LQTANT5X3V5HNFA"
4206
+ },
4207
+ {
4208
+ assetCode: "SNDK",
4209
+ contractId: "CDXNTHFMGQM33UGQBSLZI3BV5UWW62QGZLCEKOXJKMFN2W3KQZKE3LTQ",
4210
+ assetIssuer: "GDYUTHY75A7WUZJQDPOP66FB32BOYGZRXHWTWO4Q6LQTANT5X3V5HNFA"
4211
+ },
4212
+ {
4213
+ assetCode: "SPY",
4214
+ contractId: "CD3ZMWOS4PZS2RQITEHBOTS27DTDP4QKOK7IEO5IB64GQKHRJYTVL3SW",
4215
+ assetIssuer: "GDYUTHY75A7WUZJQDPOP66FB32BOYGZRXHWTWO4Q6LQTANT5X3V5HNFA"
4216
+ },
4217
+ {
4218
+ assetCode: "QQQ",
4219
+ contractId: "CC7DQX43J2KBK5MJACQWTNHENIYB5GUVCFXGDKQWDLUWA4VKLOOU5PWB",
4220
+ assetIssuer: "GDYUTHY75A7WUZJQDPOP66FB32BOYGZRXHWTWO4Q6LQTANT5X3V5HNFA"
4221
+ },
4222
+ {
4223
+ assetCode: "SGOV",
4224
+ contractId: "CBQMRO2JTUJ6NXVBQ3XGJV34PDTXR34DD74TLLRCW5SV2CV2NN2VDMLH",
4225
+ assetIssuer: "GDYUTHY75A7WUZJQDPOP66FB32BOYGZRXHWTWO4Q6LQTANT5X3V5HNFA"
4226
+ },
4227
+ {
4228
+ assetCode: "USO",
4229
+ contractId: "CCFRCTIW5EK2OK626V6C4YRTJCKACIRDI2GHOKWM57ZXACK2ZTWWWLC7",
4230
+ assetIssuer: "GDYUTHY75A7WUZJQDPOP66FB32BOYGZRXHWTWO4Q6LQTANT5X3V5HNFA"
4231
+ },
4232
+ {
4233
+ assetCode: "SLV",
4234
+ contractId: "CBY3U32O5T2B555HNJLX6C6HW3O2FLRSJGH472UOOHT6H6ZMGMSSZTLW",
4235
+ assetIssuer: "GDYUTHY75A7WUZJQDPOP66FB32BOYGZRXHWTWO4Q6LQTANT5X3V5HNFA"
3676
4236
  }
3677
4237
  ],
3678
4238
  supportedTokens: stellarSupportedTokens,
@@ -3873,7 +4433,7 @@ var DEFAULT_BACKEND_API_HEADERS = {
3873
4433
  "Content-Type": "application/json",
3874
4434
  Accept: "application/json"
3875
4435
  };
3876
- var DEFAULT_RELAYER_API_ENDPOINT = "https://xcall-relay.nw.iconblockchain.xyz";
4436
+ var DEFAULT_RELAYER_API_ENDPOINT = "https://api.sodax.com/v1/relay";
3877
4437
  var VAULT_TOKEN_DECIMALS = 18;
3878
4438
  var DEFAULT_SPONSORING_API_ENDPOINT = "https://api.sodax.com/v1";
3879
4439
  var SPONSORING_API_STELLAR_BASE_PATH = "/sponsorships/stellar";
@@ -3894,6 +4454,37 @@ var relayConfig = {
3894
4454
  };
3895
4455
 
3896
4456
  // ../types/dist/moneyMarket/moneyMarket.js
4457
+ var moneyMarketHubVaults = [
4458
+ SodaTokens.sodaBNB,
4459
+ SodaTokens.sodaAVAX,
4460
+ SodaTokens.sodaETH,
4461
+ SodaTokens.sodaBTC,
4462
+ SodaTokens.sodaWBTC,
4463
+ SodaTokens.sodaSOL,
4464
+ SodaTokens.sodaXLM,
4465
+ SodaTokens.sodaINJ,
4466
+ SodaTokens.sodaSUI,
4467
+ SodaTokens.bnUSD,
4468
+ SodaTokens.sodaUSDC,
4469
+ SodaTokens.sodaUSDT,
4470
+ SodaTokens.IbnUSD,
4471
+ SodaTokens.sodaS,
4472
+ SodaTokens.sodaPOL,
4473
+ SodaTokens.sodaSODA,
4474
+ SodaTokens.sodaHYPE,
4475
+ SodaTokens.sodaRBNT,
4476
+ SodaTokens.sodaLL,
4477
+ SodaTokens.sodaWEETH,
4478
+ SodaTokens.sodaWSTETH,
4479
+ SodaTokens.sodaNEAR,
4480
+ SodaTokens.sodaKAIA,
4481
+ SodaTokens.sodaSTX,
4482
+ SodaTokens.sodaSUSDS,
4483
+ SodaTokens.sodaHBAR,
4484
+ SodaTokens.sodaJITOSOL,
4485
+ SodaTokens.sodaUSDS,
4486
+ SodaTokens.sodaUSSD
4487
+ ];
3897
4488
  var moneyMarketSupportedTokens = {
3898
4489
  [ChainKeys.AVALANCHE_MAINNET]: [
3899
4490
  spokeChainConfig[ChainKeys.AVALANCHE_MAINNET].supportedTokens.AVAX,
@@ -4036,7 +4627,7 @@ var moneyMarketSupportedTokens = {
4036
4627
  spokeChainConfig[ChainKeys.SONIC_MAINNET].supportedTokens.wS,
4037
4628
  spokeChainConfig[ChainKeys.SONIC_MAINNET].supportedTokens.SODA,
4038
4629
  spokeChainConfig[ChainKeys.SONIC_MAINNET].supportedTokens.USSD,
4039
- ...Object.values(SodaTokens)
4630
+ ...moneyMarketHubVaults
4040
4631
  ],
4041
4632
  [ChainKeys.NEAR_MAINNET]: [
4042
4633
  spokeChainConfig[ChainKeys.NEAR_MAINNET].supportedTokens.NEAR,
@@ -4116,7 +4707,7 @@ var moneyMarketSupportedTokens = {
4116
4707
  ]
4117
4708
  };
4118
4709
  var moneyMarketReserveAssets = [
4119
- ...Object.values(SodaTokens).map((vault) => vault.address),
4710
+ ...moneyMarketHubVaults.map((vault) => vault.address),
4120
4711
  hubConfig.bnUSD
4121
4712
  ];
4122
4713
  var moneyMarketConfig = {
@@ -4290,9 +4881,49 @@ var swapSupportedTokens = {
4290
4881
  spokeChainConfig[ChainKeys.SONIC_MAINNET].supportedTokens.wS,
4291
4882
  spokeChainConfig[ChainKeys.SONIC_MAINNET].supportedTokens.SODA,
4292
4883
  // spokeChainConfig[ChainKeys.SONIC_MAINNET].supportedTokens.USSD, // NOTE: Not Implemented
4293
- // sodaSUSDS is staging-only; sodaUSDS / sodaUSSD are parked until the solver fills them
4294
- ...Object.values(SodaTokens).filter((t) => t !== SodaTokens.sodaSUSDS && t !== SodaTokens.sodaUSDS && t !== SodaTokens.sodaUSSD),
4295
- ...Object.values(LsodaTokens)
4884
+ // Swap membership is per-vault, not every SodaTokens entry: sodaSUSDS is staging-only,
4885
+ // and sodaUSDS / sodaUSSD are parked until the solver fills them.
4886
+ SodaTokens.sodaBNB,
4887
+ SodaTokens.sodaAVAX,
4888
+ SodaTokens.sodaETH,
4889
+ SodaTokens.sodaBTC,
4890
+ SodaTokens.sodaWBTC,
4891
+ SodaTokens.sodaSOL,
4892
+ SodaTokens.sodaXLM,
4893
+ SodaTokens.sodaINJ,
4894
+ SodaTokens.sodaSUI,
4895
+ SodaTokens.bnUSD,
4896
+ SodaTokens.sodaUSDC,
4897
+ SodaTokens.sodaUSDT,
4898
+ SodaTokens.IbnUSD,
4899
+ SodaTokens.sodaS,
4900
+ SodaTokens.sodaPOL,
4901
+ SodaTokens.sodaSODA,
4902
+ SodaTokens.sodaHYPE,
4903
+ SodaTokens.sodaRBNT,
4904
+ SodaTokens.sodaLL,
4905
+ SodaTokens.sodaWEETH,
4906
+ SodaTokens.sodaWSTETH,
4907
+ SodaTokens.sodaNEAR,
4908
+ SodaTokens.sodaKAIA,
4909
+ SodaTokens.sodaSTX,
4910
+ SodaTokens.sodaHBAR,
4911
+ SodaTokens.sodaJITOSOL,
4912
+ ...Object.values(LsodaTokens),
4913
+ // Robinhood tokenized equities — swap-only, deliberately absent from the money market.
4914
+ SodaTokens.SPCX,
4915
+ SodaTokens.NVDA,
4916
+ SodaTokens.GME,
4917
+ SodaTokens.MSTR,
4918
+ SodaTokens.AAPL,
4919
+ SodaTokens.TSLA,
4920
+ SodaTokens.MU,
4921
+ SodaTokens.SNDK,
4922
+ SodaTokens.SPY,
4923
+ SodaTokens.QQQ,
4924
+ SodaTokens.SGOV,
4925
+ SodaTokens.USO,
4926
+ SodaTokens.SLV
4296
4927
  ],
4297
4928
  [ChainKeys.AVALANCHE_MAINNET]: [
4298
4929
  spokeChainConfig[ChainKeys.AVALANCHE_MAINNET].supportedTokens.AVAX,
@@ -4451,7 +5082,20 @@ var swapSupportedTokens = {
4451
5082
  spokeChainConfig[ChainKeys.STELLAR_MAINNET].supportedTokens.HYPE,
4452
5083
  spokeChainConfig[ChainKeys.STELLAR_MAINNET].supportedTokens.NEAR,
4453
5084
  spokeChainConfig[ChainKeys.STELLAR_MAINNET].supportedTokens.HBAR,
4454
- spokeChainConfig[ChainKeys.STELLAR_MAINNET].supportedTokens.USDS
5085
+ spokeChainConfig[ChainKeys.STELLAR_MAINNET].supportedTokens.USDS,
5086
+ spokeChainConfig[ChainKeys.STELLAR_MAINNET].supportedTokens.SPCX,
5087
+ spokeChainConfig[ChainKeys.STELLAR_MAINNET].supportedTokens.NVDA,
5088
+ spokeChainConfig[ChainKeys.STELLAR_MAINNET].supportedTokens.GME,
5089
+ spokeChainConfig[ChainKeys.STELLAR_MAINNET].supportedTokens.MSTR,
5090
+ spokeChainConfig[ChainKeys.STELLAR_MAINNET].supportedTokens.AAPL,
5091
+ spokeChainConfig[ChainKeys.STELLAR_MAINNET].supportedTokens.TSLA,
5092
+ spokeChainConfig[ChainKeys.STELLAR_MAINNET].supportedTokens.MU,
5093
+ spokeChainConfig[ChainKeys.STELLAR_MAINNET].supportedTokens.SNDK,
5094
+ spokeChainConfig[ChainKeys.STELLAR_MAINNET].supportedTokens.SPY,
5095
+ spokeChainConfig[ChainKeys.STELLAR_MAINNET].supportedTokens.QQQ,
5096
+ spokeChainConfig[ChainKeys.STELLAR_MAINNET].supportedTokens.SGOV,
5097
+ spokeChainConfig[ChainKeys.STELLAR_MAINNET].supportedTokens.USO,
5098
+ spokeChainConfig[ChainKeys.STELLAR_MAINNET].supportedTokens.SLV
4455
5099
  ],
4456
5100
  [ChainKeys.SUI_MAINNET]: [
4457
5101
  spokeChainConfig[ChainKeys.SUI_MAINNET].supportedTokens.SUI,
@@ -4557,13 +5201,41 @@ var swapSupportedTokens = {
4557
5201
  spokeChainConfig[ChainKeys.HEDERA_MAINNET].supportedTokens.HYPE,
4558
5202
  spokeChainConfig[ChainKeys.HEDERA_MAINNET].supportedTokens.NEAR,
4559
5203
  spokeChainConfig[ChainKeys.HEDERA_MAINNET].supportedTokens.USDS,
4560
- spokeChainConfig[ChainKeys.HEDERA_MAINNET].supportedTokens.XLM
5204
+ spokeChainConfig[ChainKeys.HEDERA_MAINNET].supportedTokens.XLM,
5205
+ spokeChainConfig[ChainKeys.HEDERA_MAINNET].supportedTokens.SPCX,
5206
+ spokeChainConfig[ChainKeys.HEDERA_MAINNET].supportedTokens.NVDA,
5207
+ spokeChainConfig[ChainKeys.HEDERA_MAINNET].supportedTokens.GME,
5208
+ spokeChainConfig[ChainKeys.HEDERA_MAINNET].supportedTokens.MSTR,
5209
+ spokeChainConfig[ChainKeys.HEDERA_MAINNET].supportedTokens.AAPL,
5210
+ spokeChainConfig[ChainKeys.HEDERA_MAINNET].supportedTokens.TSLA,
5211
+ spokeChainConfig[ChainKeys.HEDERA_MAINNET].supportedTokens.MU,
5212
+ spokeChainConfig[ChainKeys.HEDERA_MAINNET].supportedTokens.SNDK,
5213
+ spokeChainConfig[ChainKeys.HEDERA_MAINNET].supportedTokens.SPY,
5214
+ spokeChainConfig[ChainKeys.HEDERA_MAINNET].supportedTokens.QQQ,
5215
+ spokeChainConfig[ChainKeys.HEDERA_MAINNET].supportedTokens.SGOV,
5216
+ spokeChainConfig[ChainKeys.HEDERA_MAINNET].supportedTokens.USO,
5217
+ spokeChainConfig[ChainKeys.HEDERA_MAINNET].supportedTokens.SLV
4561
5218
  ],
4562
5219
  [ChainKeys.ROBINHOOD_MAINNET]: [
4563
5220
  spokeChainConfig[ChainKeys.ROBINHOOD_MAINNET].supportedTokens.ETH,
4564
5221
  spokeChainConfig[ChainKeys.ROBINHOOD_MAINNET].supportedTokens.bnUSD,
4565
5222
  spokeChainConfig[ChainKeys.ROBINHOOD_MAINNET].supportedTokens.SODA,
4566
- spokeChainConfig[ChainKeys.ROBINHOOD_MAINNET].supportedTokens.USDG
5223
+ spokeChainConfig[ChainKeys.ROBINHOOD_MAINNET].supportedTokens.USDG,
5224
+ // Tokenized equities / ETFs — oracle-priced only, so DJT, GLD and RDDT are excluded
5225
+ // (no Chainlink feed). Production membership is what the staging union reads too.
5226
+ spokeChainConfig[ChainKeys.ROBINHOOD_MAINNET].supportedTokens.SPCX,
5227
+ spokeChainConfig[ChainKeys.ROBINHOOD_MAINNET].supportedTokens.NVDA,
5228
+ spokeChainConfig[ChainKeys.ROBINHOOD_MAINNET].supportedTokens.GME,
5229
+ spokeChainConfig[ChainKeys.ROBINHOOD_MAINNET].supportedTokens.MSTR,
5230
+ spokeChainConfig[ChainKeys.ROBINHOOD_MAINNET].supportedTokens.AAPL,
5231
+ spokeChainConfig[ChainKeys.ROBINHOOD_MAINNET].supportedTokens.TSLA,
5232
+ spokeChainConfig[ChainKeys.ROBINHOOD_MAINNET].supportedTokens.MU,
5233
+ spokeChainConfig[ChainKeys.ROBINHOOD_MAINNET].supportedTokens.SNDK,
5234
+ spokeChainConfig[ChainKeys.ROBINHOOD_MAINNET].supportedTokens.SPY,
5235
+ spokeChainConfig[ChainKeys.ROBINHOOD_MAINNET].supportedTokens.QQQ,
5236
+ spokeChainConfig[ChainKeys.ROBINHOOD_MAINNET].supportedTokens.SGOV,
5237
+ spokeChainConfig[ChainKeys.ROBINHOOD_MAINNET].supportedTokens.USO,
5238
+ spokeChainConfig[ChainKeys.ROBINHOOD_MAINNET].supportedTokens.SLV
4567
5239
  ]
4568
5240
  };
4569
5241
  var stagingSwapSupportedTokens = {
@@ -4656,6 +5328,21 @@ var leverageYieldVaults = [
4656
5328
  fallbackAprPct: 5.5,
4657
5329
  label: "Jito (JitoSOL)"
4658
5330
  }
5331
+ },
5332
+ {
5333
+ name: LsodaTokens.lsodaSUSDS.symbol,
5334
+ vault: LsodaTokens.lsodaSUSDS.vault,
5335
+ asset: SodaTokens.sodaSUSDS.address,
5336
+ // sodaSUSDS (sUSDS) on Sonic — eMode-3 collateral
5337
+ borrowToken: SodaTokens.sodaUSSD.address,
5338
+ // sodaUSSD (USSD) on Sonic — eMode-3 borrowable
5339
+ lsdSource: {
5340
+ // DefiLlama pool for the Sky Savings Rate on sUSDS (project: 'sky-lending', Ethereum).
5341
+ // sUSDS appreciates against USDS at the SSR — yield AAVE's currentLiquidityRate omits.
5342
+ poolId: "d8c4eff5-c8a9-46fc-a888-057c4c668e72",
5343
+ fallbackAprPct: 3.5,
5344
+ label: "Sky (sUSDS)"
5345
+ }
4659
5346
  }
4660
5347
  ];
4661
5348
  var leverageYieldConfig = {
@@ -4892,7 +5579,7 @@ function isValidWalletProviderForChainKey(chainKey, walletProvider) {
4892
5579
  }
4893
5580
 
4894
5581
  // ../types/dist/index.js
4895
- var CONFIG_VERSION = 232;
5582
+ var CONFIG_VERSION = 234;
4896
5583
 
4897
5584
  // src/shared/utils/resolveTimeoutMs.ts
4898
5585
  function resolveTimeoutMs(timeout, fallbackMs) {
@@ -4905,6 +5592,33 @@ function isEvmSpokeChainConfig(value) {
4905
5592
  function isIconAddress(value) {
4906
5593
  return typeof value === "string" && /^hx[a-f0-9]{40}$|^cx[a-f0-9]{40}$/.test(value);
4907
5594
  }
5595
+ var NEAR_ACCOUNT_ID_REGEX = /^(([a-z\d]+[-_])*[a-z\d]+\.)*([a-z\d]+[-_])*[a-z\d]+$/;
5596
+ function isValidNearAccountId(accountId) {
5597
+ return accountId.length >= 2 && accountId.length <= 64 && NEAR_ACCOUNT_ID_REGEX.test(accountId);
5598
+ }
5599
+ var INJECTIVE_ADDRESS_REGEX = /^inj1(?:[02-9ac-hj-np-z]{38}|[02-9ac-hj-np-z]{58})$/;
5600
+ var BECH32_CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
5601
+ var BECH32_GENERATOR = [996825010, 642813549, 513874426, 1027748829, 705979059];
5602
+ function bech32ChecksumVerifies(hrp, dataChars) {
5603
+ const values = [
5604
+ ...[...hrp].map((c) => c.charCodeAt(0) >>> 5),
5605
+ 0,
5606
+ ...[...hrp].map((c) => c.charCodeAt(0) & 31),
5607
+ ...[...dataChars].map((c) => BECH32_CHARSET.indexOf(c))
5608
+ ];
5609
+ let chk = 1;
5610
+ for (const value of values) {
5611
+ const top = chk >>> 25;
5612
+ chk = (chk & 33554431) << 5 ^ value;
5613
+ for (let i = 0; i < 5; i++) {
5614
+ if (top >>> i & 1) chk ^= BECH32_GENERATOR[i];
5615
+ }
5616
+ }
5617
+ return chk === 1;
5618
+ }
5619
+ function isValidInjectiveAddress(address) {
5620
+ return INJECTIVE_ADDRESS_REGEX.test(address) && bech32ChecksumVerifies("inj", address.slice(4));
5621
+ }
4908
5622
  function isResponseAddressType(value) {
4909
5623
  return typeof value === "object" && value !== null && "type" in value && "payload" in value && value.type === "RESPONSE_ADDRESS" && isIconAddress(value.payload);
4910
5624
  }
@@ -5012,6 +5726,81 @@ function isUndefinedOrValidWalletProviderForChainKey(chainKey, walletProvider) {
5012
5726
  function isOptionalBitcoinWalletProviderType(walletProvider) {
5013
5727
  return walletProvider === void 0 || isBitcoinWalletProviderType(walletProvider);
5014
5728
  }
5729
+ var BITCOIN_FEE_SAFETY_VBYTES = 20;
5730
+ function calcOpReturnOutputVbytes(payloadByteLength) {
5731
+ let scriptSize;
5732
+ if (payloadByteLength <= 75) {
5733
+ scriptSize = 3 + payloadByteLength;
5734
+ } else if (payloadByteLength <= 255) {
5735
+ scriptSize = 4 + payloadByteLength;
5736
+ } else {
5737
+ scriptSize = 5 + payloadByteLength;
5738
+ }
5739
+ const scriptLenVarint = scriptSize <= 252 ? 1 : 3;
5740
+ return 8 + scriptLenVarint + scriptSize;
5741
+ }
5742
+ function estimateBitcoinTxSize(inputCount, outputCount, addressType, opReturnOutputVbytes = 44) {
5743
+ let inputWeight;
5744
+ switch (addressType) {
5745
+ case "P2PKH":
5746
+ inputWeight = 148;
5747
+ break;
5748
+ case "P2SH":
5749
+ inputWeight = 91;
5750
+ break;
5751
+ case "P2TR":
5752
+ inputWeight = 58;
5753
+ break;
5754
+ default:
5755
+ inputWeight = 68;
5756
+ break;
5757
+ }
5758
+ return Math.ceil(
5759
+ 10.5 + opReturnOutputVbytes + BITCOIN_FEE_SAFETY_VBYTES + inputCount * inputWeight + outputCount * 31
5760
+ );
5761
+ }
5762
+ function encodeBtcPayloadToBytes(payload) {
5763
+ const isBase58Check = payload.address_type === "P2PKH" || payload.address_type === "P2SH";
5764
+ return JSON.stringify({
5765
+ src_address: isBase58Check ? payload.src_address : payload.src_address.toLowerCase(),
5766
+ data: payload.data.toLowerCase(),
5767
+ src_chain_id: payload.src_chain_id,
5768
+ dst_chain_id: payload.dst_chain_id,
5769
+ wallet_used: payload.wallet_used,
5770
+ timestamp: payload.timestamp,
5771
+ address_type: payload.address_type
5772
+ });
5773
+ }
5774
+ function isValidBitcoinAddress(address) {
5775
+ try {
5776
+ const { prefix: prefix2, version, data } = bitcoinjsLib.address.fromBech32(address);
5777
+ if (prefix2 !== "bc" && prefix2 !== "tb") return false;
5778
+ return version === 0 && (data.length === 20 || data.length === 32) || version === 1 && data.length === 32;
5779
+ } catch {
5780
+ }
5781
+ try {
5782
+ const { version } = bitcoinjsLib.address.fromBase58Check(address);
5783
+ return version === 0 || version === 5 || version === 111 || version === 196;
5784
+ } catch {
5785
+ return false;
5786
+ }
5787
+ }
5788
+ function canonicalizeBitcoinAddress(address) {
5789
+ try {
5790
+ bitcoinjsLib.address.fromBech32(address);
5791
+ return address.toLowerCase();
5792
+ } catch {
5793
+ return address;
5794
+ }
5795
+ }
5796
+ function normalizePsbtToBase64(signedPsbt) {
5797
+ const isHex2 = /^[0-9a-fA-F]+$/.test(signedPsbt);
5798
+ return isHex2 ? Buffer.from(signedPsbt, "hex").toString("base64") : signedPsbt;
5799
+ }
5800
+ function normalizeSignatureToBase64(signature) {
5801
+ const isHex2 = /^[0-9a-fA-F]+$/.test(signature);
5802
+ return isHex2 ? Buffer.from(signature, "hex").toString("base64") : signature;
5803
+ }
5015
5804
  function isNativeBitcoinTransfer(config, chainKey, token) {
5016
5805
  return isBitcoinChainKeyType(chainKey) && !!token && isNativeBitcoinToken(config.getChainConfig(chainKey), token.address);
5017
5806
  }
@@ -5031,11 +5820,10 @@ async function retry(action, retryCount = DEFAULT_MAX_RETRY, delayMs = DEFAULT_R
5031
5820
  throw new Error(`Retry exceeded MAX_RETRY_DEFAULT=${DEFAULT_MAX_RETRY}`);
5032
5821
  }
5033
5822
  function getRandomBytes(length) {
5034
- const array3 = new Uint8Array(length);
5035
- for (let i = 0; i < length; i++) {
5036
- array3[i] = Math.floor(Math.random() * 256);
5823
+ if (!globalThis.crypto?.getRandomValues) {
5824
+ throw new Error("Web Crypto (crypto.getRandomValues) is unavailable in this runtime");
5037
5825
  }
5038
- return array3;
5826
+ return globalThis.crypto.getRandomValues(new Uint8Array(length));
5039
5827
  }
5040
5828
  function randomUint256() {
5041
5829
  const bytes = getRandomBytes(32);
@@ -5084,6 +5872,7 @@ function encodeAddress(spokeChainId, address) {
5084
5872
  const chainType = getChainType(spokeChainId);
5085
5873
  switch (chainType) {
5086
5874
  case "EVM":
5875
+ invariant(viem.isAddress(address), `Invalid EVM address: ${address}`);
5087
5876
  return address;
5088
5877
  case "ICON": {
5089
5878
  invariant(isIconAddress(address), `Invalid ICON address: ${address}`);
@@ -5099,8 +5888,13 @@ function encodeAddress(spokeChainId, address) {
5099
5888
  case "STACKS":
5100
5889
  return `0x${core.serializeCV(core.Cl.principal(address))}`;
5101
5890
  case "BITCOIN":
5891
+ invariant(isValidBitcoinAddress(address), `Invalid Bitcoin address: ${address}`);
5892
+ return viem.toHex(Buffer.from(canonicalizeBitcoinAddress(address), "utf-8"));
5102
5893
  case "NEAR":
5894
+ invariant(isValidNearAccountId(address), `Invalid NEAR account id: ${address}`);
5895
+ return viem.toHex(Buffer.from(address, "utf-8"));
5103
5896
  case "INJECTIVE":
5897
+ invariant(isValidInjectiveAddress(address), `Invalid Injective address: ${address}`);
5104
5898
  return viem.toHex(Buffer.from(address, "utf-8"));
5105
5899
  default: {
5106
5900
  const exhaustiveCheck = chainType;
@@ -5108,6 +5902,16 @@ function encodeAddress(spokeChainId, address) {
5108
5902
  }
5109
5903
  }
5110
5904
  }
5905
+ function encodeTokenIdentifier(spokeChainId, token) {
5906
+ switch (getChainType(spokeChainId)) {
5907
+ case "BITCOIN":
5908
+ case "NEAR":
5909
+ case "INJECTIVE":
5910
+ return viem.toHex(Buffer.from(token, "utf-8"));
5911
+ default:
5912
+ return encodeAddress(spokeChainId, token);
5913
+ }
5914
+ }
5111
5915
  function reverseEncodeAddress(spokeChainId, encoded) {
5112
5916
  const chainType = getChainType(spokeChainId);
5113
5917
  switch (chainType) {
@@ -14807,6 +15611,11 @@ var ConfigService = class {
14807
15611
  get bridgeUseBackendSubmitTx() {
14808
15612
  return this.bridge.useBackendSubmitTx ?? this.sodax.bridgeOptions?.useBackendSubmitTx ?? true;
14809
15613
  }
15614
+ // Opt-in (default OFF), unlike the swaps/bridge toggles above: the leverage-yield submit-tx
15615
+ // backend path is newer, so an omitted flag keeps the proven client-side relay.
15616
+ get leverageYieldUseBackendSubmitTx() {
15617
+ return this.leverageYield.useBackendSubmitTx ?? false;
15618
+ }
14810
15619
  get dex() {
14811
15620
  return this.sodax.dex;
14812
15621
  }
@@ -14858,7 +15667,7 @@ function mergeSodaxConfig(base2, override) {
14858
15667
  }
14859
15668
  function encodeContractCalls(calls) {
14860
15669
  return viem.encodeAbiParameters(viem.parseAbiParameters("(address,uint256,bytes)[]"), [
14861
- calls.map((v10) => [v10.address, v10.value, v10.data])
15670
+ calls.map((v12) => [v12.address, v12.value, v12.data])
14862
15671
  ]);
14863
15672
  }
14864
15673
  async function waitForTransactionReceipt(hash, provider) {
@@ -15061,16 +15870,20 @@ var EvmVaultTokenService = class {
15061
15870
  */
15062
15871
  static async deposit(vault, token, amount, walletProvider) {
15063
15872
  const from = await walletProvider.getWalletAddress();
15064
- return walletProvider.sendTransaction({
15065
- from,
15066
- to: vault,
15067
- value: 0n,
15068
- data: viem.encodeFunctionData({
15069
- abi: vaultTokenAbi,
15070
- functionName: "deposit",
15071
- args: [token, amount]
15072
- })
15073
- });
15873
+ return walletProvider.sendTransaction(
15874
+ {
15875
+ from,
15876
+ to: vault,
15877
+ value: 0n,
15878
+ data: viem.encodeFunctionData({
15879
+ abi: vaultTokenAbi,
15880
+ functionName: "deposit",
15881
+ args: [token, amount]
15882
+ })
15883
+ },
15884
+ // Vaults live on the hub; refuse to broadcast from a wallet on another EVM network.
15885
+ { expectedChainId: getEvmViemChain(ChainKeys.SONIC_MAINNET).id }
15886
+ );
15074
15887
  }
15075
15888
  /**
15076
15889
  * Withdraws a specified amount of a token from the vault.
@@ -15082,16 +15895,19 @@ var EvmVaultTokenService = class {
15082
15895
  */
15083
15896
  static async withdraw(vault, token, amount, provider) {
15084
15897
  const from = await provider.getWalletAddress();
15085
- return provider.sendTransaction({
15086
- from,
15087
- to: vault,
15088
- value: 0n,
15089
- data: viem.encodeFunctionData({
15090
- abi: vaultTokenAbi,
15091
- functionName: "withdraw",
15092
- args: [token, amount]
15093
- })
15094
- });
15898
+ return provider.sendTransaction(
15899
+ {
15900
+ from,
15901
+ to: vault,
15902
+ value: 0n,
15903
+ data: viem.encodeFunctionData({
15904
+ abi: vaultTokenAbi,
15905
+ functionName: "withdraw",
15906
+ args: [token, amount]
15907
+ })
15908
+ },
15909
+ { expectedChainId: getEvmViemChain(ChainKeys.SONIC_MAINNET).id }
15910
+ );
15095
15911
  }
15096
15912
  /**
15097
15913
  * Encodes the deposit transaction data for the vault.
@@ -15292,7 +16108,9 @@ var Erc20Service = class _Erc20Service {
15292
16108
  if (params.raw) {
15293
16109
  return rawTx;
15294
16110
  }
15295
- return await params.walletProvider.sendTransaction(rawTx);
16111
+ return await params.walletProvider.sendTransaction(rawTx, {
16112
+ expectedChainId: params.expectedChainId
16113
+ });
15296
16114
  }
15297
16115
  /**
15298
16116
  * Encodes a transfer transaction for a token.
@@ -15605,7 +16423,9 @@ var EvmSpokeService = class {
15605
16423
  if (params.raw === true) {
15606
16424
  return rawTx;
15607
16425
  }
15608
- return params.walletProvider.sendTransaction(rawTx);
16426
+ return params.walletProvider.sendTransaction(rawTx, {
16427
+ expectedChainId: getEvmViemChain(srcChainKey).id
16428
+ });
15609
16429
  }
15610
16430
  /**
15611
16431
  * Get the balance of the token deposited in the spoke chain asset manager.
@@ -15718,7 +16538,9 @@ var EvmSpokeService = class {
15718
16538
  if (params.raw) {
15719
16539
  return rawTx;
15720
16540
  }
15721
- return params.walletProvider.sendTransaction(rawTx);
16541
+ return params.walletProvider.sendTransaction(rawTx, {
16542
+ expectedChainId: getEvmViemChain(srcChainKey).id
16543
+ });
15722
16544
  }
15723
16545
  async waitForTransactionReceipt(params) {
15724
16546
  try {
@@ -15810,6 +16632,24 @@ var StacksSpokeService = class {
15810
16632
  });
15811
16633
  return result.value.value;
15812
16634
  }
16635
+ ftAssetNames = /* @__PURE__ */ new Map();
16636
+ /** Post-conditions need the on-chain `define-fungible-token` names; SIP-10 exposes no read for them. */
16637
+ async getFtAssetNames(tokenContractId) {
16638
+ const cached = this.ftAssetNames.get(tokenContractId);
16639
+ if (cached) return cached;
16640
+ const [address, name] = core.parseContractId(tokenContractId);
16641
+ const response = await fetch(`${this.network.client.baseUrl}/v2/contracts/interface/${address}/${name}`);
16642
+ if (!response.ok) {
16643
+ throw new Error(`Failed to fetch the contract interface for ${tokenContractId}: ${response.statusText}`);
16644
+ }
16645
+ const abi = await response.json();
16646
+ const assetNames = (abi.fungible_tokens ?? []).map((token) => token.name);
16647
+ if (assetNames.length === 0) {
16648
+ throw new Error(`${tokenContractId} defines no fungible token \u2014 not a SIP-10 contract`);
16649
+ }
16650
+ this.ftAssetNames.set(tokenContractId, assetNames);
16651
+ return assetNames;
16652
+ }
15813
16653
  async getImplContractAddress(stateContract) {
15814
16654
  const [contractAddress, contractName] = core.parseContractId(stateContract);
15815
16655
  const txParams = {
@@ -15832,18 +16672,18 @@ var StacksSpokeService = class {
15832
16672
  const assetManagerImpl = await this.getImplContractAddress(chainConfig.addresses.assetManager);
15833
16673
  const [implAddress, implName] = core.parseContractId(assetManagerImpl);
15834
16674
  const [connectionAddress, connectionName] = core.parseContractId(chainConfig.addresses.connection);
16675
+ const isNative = isNativeToken(params.srcChainKey, params.token);
15835
16676
  const reqData = {
15836
16677
  contractAddress: implAddress,
15837
16678
  contractName: implName,
15838
16679
  functionName: "transfer",
15839
16680
  functionArgs: [
15840
- isNativeToken(params.srcChainKey, params.token) ? core.noneCV() : core.someCV(core.Cl.principal(params.token)),
16681
+ isNative ? core.noneCV() : core.someCV(core.Cl.principal(params.token)),
15841
16682
  core.Cl.bufferFromHex(params.to),
15842
16683
  core.uintCV(params.amount),
15843
16684
  core.Cl.bufferFromHex(params.data),
15844
16685
  core.Cl.contractPrincipal(connectionAddress, connectionName)
15845
- ],
15846
- postConditionMode: core.PostConditionMode.Allow
16686
+ ]
15847
16687
  };
15848
16688
  if (params.raw === true) {
15849
16689
  if (!params.srcPublicKey) {
@@ -15872,9 +16712,25 @@ var StacksSpokeService = class {
15872
16712
  payload: viem.bytesToHex(core.serializePayloadBytes(tx.payload))
15873
16713
  };
15874
16714
  }
15875
- const txId = await params.walletProvider.sendTransaction(reqData);
16715
+ const txId = await params.walletProvider.sendTransaction({
16716
+ ...reqData,
16717
+ postConditionMode: core.PostConditionMode.Deny,
16718
+ postConditions: await this.depositPostConditions(params.srcAddress, params.token, params.amount, isNative)
16719
+ });
15876
16720
  return txId;
15877
16721
  }
16722
+ /**
16723
+ * Caps for a Deny-mode deposit: asset-manager-state.deposit moves exactly `amount` from the
16724
+ * caller, so cap the sender at `amount` — one cap per FT the token contract defines (sBTC has
16725
+ * two; the unmoved ones pass at 0 trivially), or uSTX for native.
16726
+ */
16727
+ async depositPostConditions(srcAddress, token, amount, isNative) {
16728
+ if (isNative) return [core.Pc.principal(srcAddress).willSendLte(amount).ustx()];
16729
+ const assetNames = await this.getFtAssetNames(token);
16730
+ return assetNames.map(
16731
+ (assetName) => core.Pc.principal(srcAddress).willSendLte(amount).ft(token, assetName)
16732
+ );
16733
+ }
15878
16734
  /**
15879
16735
  * Get the balance of the token deposited in the spoke chain asset manager.
15880
16736
  * @param {GetDepositParams<StacksChainKey>} params - The parameters for the deposit, including the user's address, token address, and chain id.
@@ -15924,8 +16780,7 @@ var StacksSpokeService = class {
15924
16780
  contractAddress: connectionAddress,
15925
16781
  contractName: connectionName,
15926
16782
  functionName: "send-message",
15927
- functionArgs: [core.uintCV(dstRelayChainId), core.Cl.bufferFromHex(params.dstAddress), core.Cl.bufferFromHex(params.payload)],
15928
- postConditionMode: core.PostConditionMode.Allow
16783
+ functionArgs: [core.uintCV(dstRelayChainId), core.Cl.bufferFromHex(params.dstAddress), core.Cl.bufferFromHex(params.payload)]
15929
16784
  };
15930
16785
  if (params.raw === true) {
15931
16786
  const tx = await core.makeUnsignedContractCall({
@@ -15940,7 +16795,12 @@ var StacksSpokeService = class {
15940
16795
  payload: viem.bytesToHex(core.serializePayloadBytes(tx.payload))
15941
16796
  };
15942
16797
  }
15943
- const txId = await params.walletProvider.sendTransaction(reqData);
16798
+ const txId = await params.walletProvider.sendTransaction({
16799
+ ...reqData,
16800
+ // send-message moves no assets — deny with no conditions aborts if it ever tries.
16801
+ postConditionMode: core.PostConditionMode.Deny,
16802
+ postConditions: []
16803
+ });
15944
16804
  return txId;
15945
16805
  }
15946
16806
  async waitForTransactionReceipt(params) {
@@ -16387,60 +17247,6 @@ var RadfiProvider = class {
16387
17247
  }
16388
17248
  };
16389
17249
 
16390
- // src/shared/entities/btc/btc-utils.ts
16391
- var BITCOIN_FEE_SAFETY_VBYTES = 20;
16392
- function calcOpReturnOutputVbytes(payloadByteLength) {
16393
- let scriptSize;
16394
- if (payloadByteLength <= 75) {
16395
- scriptSize = 3 + payloadByteLength;
16396
- } else if (payloadByteLength <= 255) {
16397
- scriptSize = 4 + payloadByteLength;
16398
- } else {
16399
- scriptSize = 5 + payloadByteLength;
16400
- }
16401
- const scriptLenVarint = scriptSize <= 252 ? 1 : 3;
16402
- return 8 + scriptLenVarint + scriptSize;
16403
- }
16404
- function estimateBitcoinTxSize(inputCount, outputCount, addressType, opReturnOutputVbytes = 44) {
16405
- let inputWeight;
16406
- switch (addressType) {
16407
- case "P2PKH":
16408
- inputWeight = 148;
16409
- break;
16410
- case "P2SH":
16411
- inputWeight = 91;
16412
- break;
16413
- case "P2TR":
16414
- inputWeight = 58;
16415
- break;
16416
- default:
16417
- inputWeight = 68;
16418
- break;
16419
- }
16420
- return Math.ceil(
16421
- 10.5 + opReturnOutputVbytes + BITCOIN_FEE_SAFETY_VBYTES + inputCount * inputWeight + outputCount * 31
16422
- );
16423
- }
16424
- function encodeBtcPayloadToBytes(payload) {
16425
- return JSON.stringify({
16426
- src_address: payload.src_address.toLowerCase(),
16427
- data: payload.data.toLowerCase(),
16428
- src_chain_id: payload.src_chain_id,
16429
- dst_chain_id: payload.dst_chain_id,
16430
- wallet_used: payload.wallet_used,
16431
- timestamp: payload.timestamp,
16432
- address_type: payload.address_type
16433
- });
16434
- }
16435
- function normalizePsbtToBase64(signedPsbt) {
16436
- const isHex2 = /^[0-9a-fA-F]+$/.test(signedPsbt);
16437
- return isHex2 ? Buffer.from(signedPsbt, "hex").toString("base64") : signedPsbt;
16438
- }
16439
- function normalizeSignatureToBase64(signature) {
16440
- const isHex2 = /^[0-9a-fA-F]+$/.test(signature);
16441
- return isHex2 ? Buffer.from(signature, "hex").toString("base64") : signature;
16442
- }
16443
-
16444
17250
  // src/shared/services/spoke/BitcoinSpokeService.ts
16445
17251
  bitcoinjsLib.initEccLib(ecc__namespace);
16446
17252
  var BITCOIN_DEFAULT_FEE_RATE = 3;
@@ -17098,7 +17904,7 @@ function hexToBytes2(hex) {
17098
17904
  const al = hl / 2;
17099
17905
  if (hl % 2)
17100
17906
  throw new Error("hex string expected, got unpadded hex of length " + hl);
17101
- const array3 = new Uint8Array(al);
17907
+ const array4 = new Uint8Array(al);
17102
17908
  for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
17103
17909
  const n1 = asciiToBase16(hex.charCodeAt(hi));
17104
17910
  const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
@@ -17106,9 +17912,9 @@ function hexToBytes2(hex) {
17106
17912
  const char = hex[hi] + hex[hi + 1];
17107
17913
  throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
17108
17914
  }
17109
- array3[ai] = n1 * 16 + n2;
17915
+ array4[ai] = n1 * 16 + n2;
17110
17916
  }
17111
- return array3;
17917
+ return array4;
17112
17918
  }
17113
17919
  function concatBytes(...arrays) {
17114
17920
  let sum = 0;
@@ -17738,22 +18544,22 @@ function createHmacDrbg(hashLen, qByteLen, hmacFn) {
17738
18544
  const byte0 = Uint8Array.of(0);
17739
18545
  const byte1 = Uint8Array.of(1);
17740
18546
  const _maxDrbgIters = 1e3;
17741
- let v10 = u8n(hashLen);
18547
+ let v12 = u8n(hashLen);
17742
18548
  let k = u8n(hashLen);
17743
18549
  let i = 0;
17744
18550
  const reset = () => {
17745
- v10.fill(1);
18551
+ v12.fill(1);
17746
18552
  k.fill(0);
17747
18553
  i = 0;
17748
18554
  };
17749
- const h = (...msgs) => hmacFn(k, concatBytes(v10, ...msgs));
18555
+ const h = (...msgs) => hmacFn(k, concatBytes(v12, ...msgs));
17750
18556
  const reseed = (seed = NULL) => {
17751
18557
  k = h(byte0, seed);
17752
- v10 = h();
18558
+ v12 = h();
17753
18559
  if (seed.length === 0)
17754
18560
  return;
17755
18561
  k = h(byte1, seed);
17756
- v10 = h();
18562
+ v12 = h();
17757
18563
  };
17758
18564
  const gen = () => {
17759
18565
  if (i++ >= _maxDrbgIters)
@@ -17761,10 +18567,10 @@ function createHmacDrbg(hashLen, qByteLen, hmacFn) {
17761
18567
  let len = 0;
17762
18568
  const out = [];
17763
18569
  while (len < qByteLen) {
17764
- v10 = h();
17765
- const sl = v10.slice();
18570
+ v12 = h();
18571
+ const sl = v12.slice();
17766
18572
  out.push(sl);
17767
- len += v10.length;
18573
+ len += v12.length;
17768
18574
  }
17769
18575
  return concatBytes(...out);
17770
18576
  };
@@ -17779,18 +18585,18 @@ function createHmacDrbg(hashLen, qByteLen, hmacFn) {
17779
18585
  };
17780
18586
  return genUntil;
17781
18587
  }
17782
- function validateObject(object5, fields = {}, optFields = {}) {
17783
- if (!object5 || typeof object5 !== "object")
18588
+ function validateObject(object6, fields = {}, optFields = {}) {
18589
+ if (!object6 || typeof object6 !== "object")
17784
18590
  throw new Error("expected valid options object");
17785
18591
  function checkField(fieldName, expectedType, isOpt) {
17786
- const val = object5[fieldName];
18592
+ const val = object6[fieldName];
17787
18593
  if (isOpt && val === void 0)
17788
18594
  return;
17789
18595
  const current = typeof val;
17790
18596
  if (current !== expectedType || val === null)
17791
18597
  throw new Error(`param "${fieldName}" is invalid: expected ${expectedType}, got ${current}`);
17792
18598
  }
17793
- const iter = (f, isOpt) => Object.entries(f).forEach(([k, v10]) => checkField(k, v10, isOpt));
18599
+ const iter = (f, isOpt) => Object.entries(f).forEach(([k, v12]) => checkField(k, v12, isOpt));
17794
18600
  iter(fields, false);
17795
18601
  iter(optFields, true);
17796
18602
  }
@@ -17829,12 +18635,12 @@ function pow2(x, power, modulo) {
17829
18635
  }
17830
18636
  return res;
17831
18637
  }
17832
- function invert(number5, modulo) {
17833
- if (number5 === _0n2)
18638
+ function invert(number6, modulo) {
18639
+ if (number6 === _0n2)
17834
18640
  throw new Error("invert: expected non-zero number");
17835
18641
  if (modulo <= _0n2)
17836
18642
  throw new Error("invert: expected positive modulus, got " + modulo);
17837
- let a = mod(number5, modulo);
18643
+ let a = mod(number6, modulo);
17838
18644
  let b = modulo;
17839
18645
  let x = _0n2, u = _1n2;
17840
18646
  while (a !== _0n2) {
@@ -17861,9 +18667,9 @@ function sqrt3mod4(Fp, n) {
17861
18667
  function sqrt5mod8(Fp, n) {
17862
18668
  const p5div8 = (Fp.ORDER - _5n) / _8n;
17863
18669
  const n2 = Fp.mul(n, _2n);
17864
- const v10 = Fp.pow(n2, p5div8);
17865
- const nv = Fp.mul(n, v10);
17866
- const i = Fp.mul(Fp.mul(nv, _2n), v10);
18670
+ const v12 = Fp.pow(n2, p5div8);
18671
+ const nv = Fp.mul(n, v12);
18672
+ const i = Fp.mul(Fp.mul(nv, _2n), v12);
17867
18673
  const root = Fp.mul(nv, Fp.sub(i, Fp.ONE));
17868
18674
  assertIsSquare(Fp, root, n);
17869
18675
  return root;
@@ -18445,9 +19251,9 @@ function edwards(params, extraOpts = {}) {
18445
19251
  validateObject(extraOpts, {}, { uvRatio: "function" });
18446
19252
  const MASK = _2n2 << BigInt(Fn.BYTES * 8) - _1n4;
18447
19253
  const modP = (n) => Fp.create(n);
18448
- const uvRatio2 = extraOpts.uvRatio || ((u, v10) => {
19254
+ const uvRatio2 = extraOpts.uvRatio || ((u, v12) => {
18449
19255
  try {
18450
- return { isValid: true, value: Fp.sqrt(Fp.div(u, v10)) };
19256
+ return { isValid: true, value: Fp.sqrt(Fp.div(u, v12)) };
18451
19257
  } catch (e) {
18452
19258
  return { isValid: false, value: _0n4 };
18453
19259
  }
@@ -18543,8 +19349,8 @@ function edwards(params, extraOpts = {}) {
18543
19349
  aInRange("point.y", y, _0n4, max);
18544
19350
  const y2 = modP(y * y);
18545
19351
  const u = modP(y2 - _1n4);
18546
- const v10 = modP(d * y2 - a);
18547
- let { isValid, value: x } = uvRatio2(u, v10);
19352
+ const v12 = modP(d * y2 - a);
19353
+ let { isValid, value: x } = uvRatio2(u, v12);
18548
19354
  if (!isValid)
18549
19355
  throw new Error("bad point: invalid y coordinate");
18550
19356
  const isXOdd = (x & _1n4) === _1n4;
@@ -18884,13 +19690,13 @@ function adjustScalarBytes(bytes) {
18884
19690
  return bytes;
18885
19691
  }
18886
19692
  var ED25519_SQRT_M1 = /* @__PURE__ */ BigInt("19681161376707505956807079304988542015446066515923890162744021073123829784752");
18887
- function uvRatio(u, v10) {
19693
+ function uvRatio(u, v12) {
18888
19694
  const P = ed25519_CURVE_p;
18889
- const v32 = mod(v10 * v10 * v10, P);
18890
- const v72 = mod(v32 * v32 * v10, P);
19695
+ const v32 = mod(v12 * v12 * v12, P);
19696
+ const v72 = mod(v32 * v32 * v12, P);
18891
19697
  const pow = ed25519_pow_2_252_3(u * v72).pow_p_5_8;
18892
19698
  let x = mod(u * v32 * pow, P);
18893
- const vx2 = mod(v10 * x * x, P);
19699
+ const vx2 = mod(v12 * x * x, P);
18894
19700
  const root1 = x;
18895
19701
  const root2 = mod(x * ED25519_SQRT_M1, P);
18896
19702
  const useRoot1 = vx2 === u;
@@ -19221,7 +20027,7 @@ function findSeatPrice(validators, maxNumberOfSeats, minimumStakeRatio, protocol
19221
20027
  return findSeatPriceForProtocolAfter49(validators, maxNumberOfSeats, minimumStakeRatio);
19222
20028
  }
19223
20029
  function findSeatPriceForProtocolBefore49(validators, numSeats) {
19224
- const stakes = validators.map((v10) => BigInt(v10.stake)).sort(sortBigIntAsc);
20030
+ const stakes = validators.map((v12) => BigInt(v12.stake)).sort(sortBigIntAsc);
19225
20031
  const num = BigInt(numSeats);
19226
20032
  const stakesSum = stakes.reduce((a, b) => a + b);
19227
20033
  if (stakesSum < num) {
@@ -19250,7 +20056,7 @@ function findSeatPriceForProtocolAfter49(validators, maxNumberOfSeats, minimumSt
19250
20056
  if (minimumStakeRatio.length != 2) {
19251
20057
  throw Error("minimumStakeRatio should have 2 elements");
19252
20058
  }
19253
- const stakes = validators.map((v10) => BigInt(v10.stake)).sort(sortBigIntAsc);
20059
+ const stakes = validators.map((v12) => BigInt(v12.stake)).sort(sortBigIntAsc);
19254
20060
  const stakesSum = stakes.reduce((a, b) => a + b);
19255
20061
  if (validators.length < maxNumberOfSeats) {
19256
20062
  return stakesSum * BigInt(minimumStakeRatio[0]) / BigInt(minimumStakeRatio[1]);
@@ -19422,10 +20228,10 @@ var DER = {
19422
20228
  if (length < 128)
19423
20229
  throw new E("tlv.decode(long): not minimal encoding");
19424
20230
  }
19425
- const v10 = data.subarray(pos, pos + length);
19426
- if (v10.length !== length)
20231
+ const v12 = data.subarray(pos, pos + length);
20232
+ if (v12.length !== length)
19427
20233
  throw new E("tlv.decode: wrong value length");
19428
- return { v: v10, l: data.subarray(pos + length) };
20234
+ return { v: v12, l: data.subarray(pos + length) };
19429
20235
  }
19430
20236
  },
19431
20237
  // https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag,
@@ -19993,9 +20799,9 @@ function ecdsa(Point, hash, ecdsaOpts = {}) {
19993
20799
  extraEntropy: false
19994
20800
  };
19995
20801
  const hasLargeCofactor = CURVE_ORDER * _2n4 < Fp.ORDER;
19996
- function isBiggerThanHalfOrder(number5) {
20802
+ function isBiggerThanHalfOrder(number6) {
19997
20803
  const HALF = CURVE_ORDER >> _1n6;
19998
- return number5 > HALF;
20804
+ return number6 > HALF;
19999
20805
  }
20000
20806
  function validateRS(title, num) {
20001
20807
  if (!Fn.isValidNot0(num))
@@ -20178,8 +20984,8 @@ function ecdsa(Point, hash, ecdsaOpts = {}) {
20178
20984
  const R = Point.BASE.multiplyUnsafe(u1).add(P.multiplyUnsafe(u2));
20179
20985
  if (R.is0())
20180
20986
  return false;
20181
- const v10 = Fn.create(R.x);
20182
- return v10 === r;
20987
+ const v12 = Fn.create(R.x);
20988
+ return v12 === r;
20183
20989
  } catch (e) {
20184
20990
  return false;
20185
20991
  }
@@ -23867,7 +24673,9 @@ var SonicSpokeService = class {
23867
24673
  if (params.raw === true) {
23868
24674
  return rawTx;
23869
24675
  }
23870
- return params.walletProvider.sendTransaction(rawTx);
24676
+ return params.walletProvider.sendTransaction(rawTx, {
24677
+ expectedChainId: getEvmViemChain(ChainKeys.SONIC_MAINNET).id
24678
+ });
23871
24679
  }
23872
24680
  static async createSwapIntent(params) {
23873
24681
  const { createIntentParams, creatorHubWalletAddress, solverConfig: solverConfig2, fee, hubProvider } = params;
@@ -23917,7 +24725,9 @@ var SonicSpokeService = class {
23917
24725
  return [rawTx, intent, feeAmount, txData.data];
23918
24726
  }
23919
24727
  return [
23920
- await params.walletProvider.sendTransaction(rawTx),
24728
+ await params.walletProvider.sendTransaction(rawTx, {
24729
+ expectedChainId: getEvmViemChain(ChainKeys.SONIC_MAINNET).id
24730
+ }),
23921
24731
  intent,
23922
24732
  feeAmount,
23923
24733
  txData.data
@@ -24048,7 +24858,9 @@ var SonicSpokeService = class {
24048
24858
  if (params.raw === true) {
24049
24859
  return rawTx;
24050
24860
  }
24051
- return params.walletProvider.sendTransaction(rawTx);
24861
+ return params.walletProvider.sendTransaction(rawTx, {
24862
+ expectedChainId: getEvmViemChain(ChainKeys.SONIC_MAINNET).id
24863
+ });
24052
24864
  }
24053
24865
  };
24054
24866
  async function toMystenTransaction(txn) {
@@ -24133,16 +24945,16 @@ var SuiGrpcTransport = class {
24133
24945
  return effects.gasUsed;
24134
24946
  }
24135
24947
  async fetchLatestPackageId(objectId) {
24136
- let object5;
24948
+ let object6;
24137
24949
  try {
24138
- ({ object: object5 } = await this.client.core.getObject({ objectId, include: { json: true } }));
24950
+ ({ object: object6 } = await this.client.core.getObject({ objectId, include: { json: true } }));
24139
24951
  } catch (error) {
24140
24952
  throw new Error("Failed to fetch asset manager id", { cause: error });
24141
24953
  }
24142
- if (!object5) {
24954
+ if (!object6) {
24143
24955
  throw new Error("Asset manager id not found (no data)");
24144
24956
  }
24145
- const fields = object5.json;
24957
+ const fields = object6.json;
24146
24958
  if (!fields) {
24147
24959
  throw new Error("Asset manager id not found (not a move object)");
24148
24960
  }
@@ -26199,7 +27011,9 @@ var SpokeService = class _SpokeService {
26199
27011
  from: params.owner,
26200
27012
  spender: params.spender,
26201
27013
  raw: false,
26202
- walletProvider
27014
+ walletProvider,
27015
+ // Covers the reset leg too — an approval must not broadcast on the wrong EVM network.
27016
+ expectedChainId: getEvmViemChain(params.srcChainKey).id
26203
27017
  });
26204
27018
  if (plan.resetAmount !== void 0) {
26205
27019
  const resetHash = await sendApprove(plan.resetAmount);
@@ -26406,7 +27220,8 @@ var SpokeService = class _SpokeService {
26406
27220
  return this.sui.encodeSimulationParams(token, assetManager);
26407
27221
  default:
26408
27222
  return {
26409
- encodedToken: encodeAddress(srcChainKey, token),
27223
+ // Token identifiers on BITCOIN/NEAR/INJECTIVE are not addresses — recipient validation stays on the address leg only.
27224
+ encodedToken: encodeTokenIdentifier(srcChainKey, token),
26410
27225
  encodedSrcAddress: encodeAddress(srcChainKey, assetManager)
26411
27226
  };
26412
27227
  }
@@ -27033,6 +27848,7 @@ var SpokeService = class _SpokeService {
27033
27848
  }
27034
27849
  }
27035
27850
  };
27851
+ var HUB_CHAIN_ID = getEvmViemChain(ChainKeys.SONIC_MAINNET).id;
27036
27852
  var Erc4626Service = class {
27037
27853
  constructor() {
27038
27854
  }
@@ -27211,7 +28027,7 @@ var Erc4626Service = class {
27211
28027
  if (raw) {
27212
28028
  return rawTx;
27213
28029
  }
27214
- return walletProvider.sendTransaction(rawTx);
28030
+ return walletProvider.sendTransaction(rawTx, { expectedChainId: HUB_CHAIN_ID });
27215
28031
  }
27216
28032
  /**
27217
28033
  * Get the maximum amount of shares that can be minted
@@ -27288,7 +28104,7 @@ var Erc4626Service = class {
27288
28104
  if (raw) {
27289
28105
  return rawTx;
27290
28106
  }
27291
- return walletProvider.sendTransaction(rawTx);
28107
+ return walletProvider.sendTransaction(rawTx, { expectedChainId: HUB_CHAIN_ID });
27292
28108
  }
27293
28109
  /**
27294
28110
  * Get the maximum amount of assets that can be withdrawn
@@ -27366,7 +28182,7 @@ var Erc4626Service = class {
27366
28182
  if (raw) {
27367
28183
  return rawTx;
27368
28184
  }
27369
- return walletProvider.sendTransaction(rawTx);
28185
+ return walletProvider.sendTransaction(rawTx, { expectedChainId: HUB_CHAIN_ID });
27370
28186
  }
27371
28187
  /**
27372
28188
  * Get the maximum amount of shares that can be redeemed
@@ -27444,7 +28260,7 @@ var Erc4626Service = class {
27444
28260
  if (raw) {
27445
28261
  return rawTx;
27446
28262
  }
27447
- return walletProvider.sendTransaction(rawTx);
28263
+ return walletProvider.sendTransaction(rawTx, { expectedChainId: HUB_CHAIN_ID });
27448
28264
  }
27449
28265
  /**
27450
28266
  * Encodes a deposit transaction for a vault.
@@ -27521,6 +28337,7 @@ var Erc4626Service = class {
27521
28337
  };
27522
28338
  }
27523
28339
  };
28340
+ var HUB_CHAIN_ID2 = getEvmViemChain(ChainKeys.SONIC_MAINNET).id;
27524
28341
  var Permit2Service = class _Permit2Service {
27525
28342
  constructor() {
27526
28343
  }
@@ -27609,7 +28426,7 @@ var Permit2Service = class _Permit2Service {
27609
28426
  if (raw) {
27610
28427
  return rawTx;
27611
28428
  }
27612
- return walletProvider.sendTransaction(rawTx);
28429
+ return walletProvider.sendTransaction(rawTx, { expectedChainId: HUB_CHAIN_ID2 });
27613
28430
  }
27614
28431
  /**
27615
28432
  * Execute a permit for a single token
@@ -27634,7 +28451,7 @@ var Permit2Service = class _Permit2Service {
27634
28451
  if (raw) {
27635
28452
  return rawTx;
27636
28453
  }
27637
- return walletProvider.sendTransaction(rawTx);
28454
+ return walletProvider.sendTransaction(rawTx, { expectedChainId: HUB_CHAIN_ID2 });
27638
28455
  }
27639
28456
  /**
27640
28457
  * Execute a permit for multiple tokens
@@ -27659,7 +28476,7 @@ var Permit2Service = class _Permit2Service {
27659
28476
  if (raw) {
27660
28477
  return rawTx;
27661
28478
  }
27662
- return walletProvider.sendTransaction(rawTx);
28479
+ return walletProvider.sendTransaction(rawTx, { expectedChainId: HUB_CHAIN_ID2 });
27663
28480
  }
27664
28481
  /**
27665
28482
  * Transfer tokens from one address to another using Permit2
@@ -27685,7 +28502,7 @@ var Permit2Service = class _Permit2Service {
27685
28502
  if (raw) {
27686
28503
  return rawTx;
27687
28504
  }
27688
- return walletProvider.sendTransaction(rawTx);
28505
+ return walletProvider.sendTransaction(rawTx, { expectedChainId: HUB_CHAIN_ID2 });
27689
28506
  }
27690
28507
  /**
27691
28508
  * Transfer multiple tokens in a batch using Permit2
@@ -27708,7 +28525,7 @@ var Permit2Service = class _Permit2Service {
27708
28525
  if (raw) {
27709
28526
  return rawTx;
27710
28527
  }
27711
- return walletProvider.sendTransaction(rawTx);
28528
+ return walletProvider.sendTransaction(rawTx, { expectedChainId: HUB_CHAIN_ID2 });
27712
28529
  }
27713
28530
  /**
27714
28531
  * Lockdown approvals to prevent malicious usage
@@ -27731,7 +28548,7 @@ var Permit2Service = class _Permit2Service {
27731
28548
  if (raw) {
27732
28549
  return rawTx;
27733
28550
  }
27734
- return walletProvider.sendTransaction(rawTx);
28551
+ return walletProvider.sendTransaction(rawTx, { expectedChainId: HUB_CHAIN_ID2 });
27735
28552
  }
27736
28553
  /**
27737
28554
  * Invalidate nonces to prevent replay attacks
@@ -27756,7 +28573,7 @@ var Permit2Service = class _Permit2Service {
27756
28573
  if (raw) {
27757
28574
  return rawTx;
27758
28575
  }
27759
- return walletProvider.sendTransaction(rawTx);
28576
+ return walletProvider.sendTransaction(rawTx, { expectedChainId: HUB_CHAIN_ID2 });
27760
28577
  }
27761
28578
  /**
27762
28579
  * Encodes an approve transaction for Permit2.
@@ -31014,7 +31831,9 @@ var BalnSwapService = class {
31014
31831
  if (walletProviderSlot.raw) {
31015
31832
  return tx;
31016
31833
  }
31017
- return walletProviderSlot.walletProvider.sendTransaction(tx);
31834
+ return walletProviderSlot.walletProvider.sendTransaction(tx, {
31835
+ expectedChainId: getEvmViemChain(ChainKeys.SONIC_MAINNET).id
31836
+ });
31018
31837
  }
31019
31838
  };
31020
31839
 
@@ -32153,6 +32972,9 @@ function resolveSponsoringApiConfig(layers) {
32153
32972
  function resolveBridgeApiConfig(layers) {
32154
32973
  return resolveSharedApiConfig(layers);
32155
32974
  }
32975
+ function resolveLeverageYieldApiConfig(layers) {
32976
+ return resolveSharedApiConfig(layers);
32977
+ }
32156
32978
  var SwapsApiService = class _SwapsApiService {
32157
32979
  // Fully-resolved swaps-API config supplied by the caller (BackendApiService resolves the
32158
32980
  // `ApiConfig` union via `resolveSwapsApiConfig`); this service does not resolve the union.
@@ -32878,6 +33700,623 @@ var BridgeApiService = class {
32878
33700
  return this.config.timeout;
32879
33701
  }
32880
33702
  };
33703
+ var LsdSourceSchema = v__namespace.object({
33704
+ poolId: v__namespace.string(),
33705
+ fallbackAprPct: v__namespace.number(),
33706
+ label: v__namespace.string()
33707
+ });
33708
+ var LeverageVaultSchema = v__namespace.object({
33709
+ name: v__namespace.string(),
33710
+ vault: v__namespace.string(),
33711
+ asset: v__namespace.string(),
33712
+ borrowToken: v__namespace.string(),
33713
+ lsdSource: v__namespace.optional(LsdSourceSchema)
33714
+ });
33715
+ var GetLeverageVaultsResponseSchema = v__namespace.array(LeverageVaultSchema);
33716
+ var GetLeverageVaultResponseSchema = LeverageVaultSchema;
33717
+ var VaultAssetResponseSchema = v__namespace.object({
33718
+ asset: v__namespace.string()
33719
+ });
33720
+ var LeverageYieldPositionSchema = v__namespace.object({
33721
+ collateral: v__namespace.string(),
33722
+ debt: v__namespace.string(),
33723
+ ltv: v__namespace.string(),
33724
+ healthFactor: v__namespace.string(),
33725
+ idleAsset: v__namespace.string()
33726
+ });
33727
+ var LeverageYieldAprSchema = v__namespace.object({
33728
+ supplyAprRay: v__namespace.string(),
33729
+ borrowAprRay: v__namespace.string(),
33730
+ targetLtvBps: v__namespace.string(),
33731
+ leverageMultiplierWad: v__namespace.string(),
33732
+ netAprRay: v__namespace.string()
33733
+ });
33734
+ var LeverageYieldLsdAprSchema = v__namespace.object({
33735
+ aprRay: v__namespace.string(),
33736
+ label: v__namespace.string(),
33737
+ stale: v__namespace.boolean()
33738
+ });
33739
+ var LeverageYieldEffectiveAprSchema = v__namespace.object({
33740
+ supplyAprRay: v__namespace.string(),
33741
+ borrowAprRay: v__namespace.string(),
33742
+ targetLtvBps: v__namespace.string(),
33743
+ leverageMultiplierWad: v__namespace.string(),
33744
+ netAprRay: v__namespace.string(),
33745
+ lsdApr: LeverageYieldLsdAprSchema,
33746
+ effectiveSupplyAprRay: v__namespace.string(),
33747
+ effectiveNetAprRay: v__namespace.string()
33748
+ });
33749
+ var VaultTotalAssetsResponseSchema = v__namespace.object({
33750
+ totalAssets: v__namespace.string()
33751
+ });
33752
+ var PreviewDepositResponseSchema = v__namespace.object({
33753
+ shares: v__namespace.string()
33754
+ });
33755
+ var PreviewWithdrawResponseSchema = v__namespace.object({
33756
+ shares: v__namespace.string()
33757
+ });
33758
+ var PreviewRedeemResponseSchema = v__namespace.object({
33759
+ assets: v__namespace.string()
33760
+ });
33761
+ var ShareBalanceResponseSchema = v__namespace.object({
33762
+ balance: v__namespace.string()
33763
+ });
33764
+ var MaxWithdrawResponseSchema = v__namespace.object({
33765
+ maxWithdraw: v__namespace.string()
33766
+ });
33767
+
33768
+ // src/backendApi/LeverageYieldApiService.ts
33769
+ var LeverageYieldApiService = class _LeverageYieldApiService {
33770
+ // Fully-resolved API config supplied by the caller (BackendApiService resolves the ApiConfig
33771
+ // union via `resolveBaseApiConfig`); leverage-yield endpoints are sub-paths under the base URL.
33772
+ config;
33773
+ headers;
33774
+ logger;
33775
+ /** See {@link LeverageYieldApiServiceOptions.trimLegacyOverrides}. */
33776
+ trimsLegacyOverrides;
33777
+ constructor(config, logger = consoleLogger, options = {}) {
33778
+ this.config = config;
33779
+ this.headers = { ...config.headers };
33780
+ this.logger = logger;
33781
+ this.trimsLegacyOverrides = options.trimLegacyOverrides ?? true;
33782
+ }
33783
+ /**
33784
+ * Issues a single HTTP request, validates the JSON body against `schema`, and wraps the
33785
+ * result in `Result<T>`. Mirrors `SwapsApiService.request`; every public method delegates here.
33786
+ */
33787
+ async request(endpoint, config, schema, overrideConfig) {
33788
+ try {
33789
+ const raw = await makeRequest({
33790
+ endpoint,
33791
+ config: { baseURL: this.config.baseURL, timeout: this.config.timeout, headers: this.headers, ...config },
33792
+ // Normalized like a configured base URL: the override is the gateway root, so a legacy
33793
+ // `/be`-suffixed value must not nest `/leverage-yield/*` under the data API's mount — unless the
33794
+ // config opted out of the legacy trim, in which case the per-call value is left as given.
33795
+ overrideConfig: this.trimsLegacyOverrides ? normalizeOverrideBaseURL(overrideConfig) : overrideConfig,
33796
+ logger: this.logger,
33797
+ serviceLabel: "LeverageYieldApiService"
33798
+ });
33799
+ const parsed = v__namespace.safeParse(schema, raw);
33800
+ if (!parsed.success) {
33801
+ return {
33802
+ ok: false,
33803
+ error: toInvalidResponseShapeError({
33804
+ api: "leverageYield",
33805
+ feature: "backend",
33806
+ endpoint,
33807
+ issues: v__namespace.flatten(parsed.issues)
33808
+ })
33809
+ };
33810
+ }
33811
+ return { ok: true, value: parsed.output };
33812
+ } catch (error) {
33813
+ return { ok: false, error: toExternalApiError({ api: "leverageYield", feature: "backend", endpoint, error }) };
33814
+ }
33815
+ }
33816
+ /**
33817
+ * Drop the SDK-only display field `feeAmount` before an intent reaches the strict wire serializer.
33818
+ * `sodax.leverageYield.createVaultIntent` returns `Intent & FeeAmount`, which is structurally
33819
+ * assignable to the wire `IntentRequestV2` and so gets passed straight into the intent-carrying
33820
+ * endpoints; the lenient JSON serializer would send the extra bigint wholesale. Mirrors
33821
+ * `SwapsApiService.toWireIntent`; a no-op for an already-clean `IntentRequestV2`.
33822
+ */
33823
+ static toWireIntent(intent) {
33824
+ const { feeAmount: _feeAmount, ...rest } = intent;
33825
+ return rest;
33826
+ }
33827
+ /** Append `params` to `base` as a query string, returning `base` unchanged when `params` is empty. */
33828
+ withQuery(base2, params) {
33829
+ const queryString = new URLSearchParams(params).toString();
33830
+ return queryString.length > 0 ? `${base2}?${queryString}` : base2;
33831
+ }
33832
+ // ──────────────────────────────────────────────────────────────────────
33833
+ // Vault registry
33834
+ // ──────────────────────────────────────────────────────────────────────
33835
+ /**
33836
+ * Fetch the registry of deployed leverage-yield vaults.
33837
+ *
33838
+ * @returns `Result<GetLeverageVaultsResponseV2>` — array of vault descriptors.
33839
+ */
33840
+ async getVaults(config) {
33841
+ return this.request("/leverage-yield/vaults", { method: "GET" }, GetLeverageVaultsResponseSchema, config);
33842
+ }
33843
+ /**
33844
+ * Fetch a single vault descriptor by its lsoda* share-token name (e.g. `lsodaWEETH`).
33845
+ *
33846
+ * @returns `Result<GetLeverageVaultResponseV2>` — the vault descriptor.
33847
+ */
33848
+ async getVault(name, config) {
33849
+ return this.request(
33850
+ `/leverage-yield/vaults/${name}`,
33851
+ { method: "GET" },
33852
+ GetLeverageVaultResponseSchema,
33853
+ config
33854
+ );
33855
+ }
33856
+ // ──────────────────────────────────────────────────────────────────────
33857
+ // Vault reads
33858
+ // ──────────────────────────────────────────────────────────────────────
33859
+ /**
33860
+ * Get the vault's underlying hub asset (Sodax vault-token wrapper).
33861
+ *
33862
+ * @returns `Result<VaultAssetResponseV2>` — `{ asset }`.
33863
+ */
33864
+ async getAsset(query, config) {
33865
+ return this.request(
33866
+ this.withQuery("/leverage-yield/asset", { vault: query.vault }),
33867
+ { method: "GET" },
33868
+ VaultAssetResponseSchema,
33869
+ config
33870
+ );
33871
+ }
33872
+ /**
33873
+ * Get a leveraged-position snapshot for the vault.
33874
+ *
33875
+ * @returns `Result<LeverageYieldPositionV2>` — `{ collateral, debt, ltv, healthFactor, idleAsset }` (decimal strings).
33876
+ */
33877
+ async getPosition(query, config) {
33878
+ return this.request(
33879
+ this.withQuery("/leverage-yield/position", { vault: query.vault }),
33880
+ { method: "GET" },
33881
+ LeverageYieldPositionSchema,
33882
+ config
33883
+ );
33884
+ }
33885
+ /**
33886
+ * Get the AAVE-only steady-state APR for the vault (goes negative when the LSD yield is the alpha).
33887
+ *
33888
+ * @returns `Result<LeverageYieldAprV2>` — RAY-denominated rates as decimal strings.
33889
+ */
33890
+ async getApr(query, config) {
33891
+ return this.request(
33892
+ this.withQuery("/leverage-yield/apr", { vault: query.vault }),
33893
+ { method: "GET" },
33894
+ LeverageYieldAprSchema,
33895
+ config
33896
+ );
33897
+ }
33898
+ /**
33899
+ * Get the honest combined AAVE + LSD effective APR for the vault.
33900
+ *
33901
+ * @returns `Result<LeverageYieldEffectiveAprV2>` — includes `effectiveNetAprRay` (the headline number).
33902
+ */
33903
+ async getEffectiveApr(query, config) {
33904
+ return this.request(
33905
+ this.withQuery("/leverage-yield/apr/effective", { vault: query.vault }),
33906
+ { method: "GET" },
33907
+ LeverageYieldEffectiveAprSchema,
33908
+ config
33909
+ );
33910
+ }
33911
+ /**
33912
+ * Get the off-chain LSD staking-APR snapshot for the vault's underlying asset.
33913
+ *
33914
+ * @returns `Result<LeverageYieldLsdAprV2>` — `{ aprRay, label, stale }`.
33915
+ */
33916
+ async getLsdApr(query, config) {
33917
+ return this.request(
33918
+ this.withQuery("/leverage-yield/apr/lsd", { vault: query.vault }),
33919
+ { method: "GET" },
33920
+ LeverageYieldLsdAprSchema,
33921
+ config
33922
+ );
33923
+ }
33924
+ /**
33925
+ * Get the total assets managed by the vault.
33926
+ *
33927
+ * @returns `Result<VaultTotalAssetsResponseV2>` — `{ totalAssets }` (decimal string).
33928
+ */
33929
+ async getTotalAssets(query, config) {
33930
+ return this.request(
33931
+ this.withQuery("/leverage-yield/total-assets", { vault: query.vault }),
33932
+ { method: "GET" },
33933
+ VaultTotalAssetsResponseSchema,
33934
+ config
33935
+ );
33936
+ }
33937
+ /**
33938
+ * Preview the shares minted for depositing `assets` into the vault (ERC-4626 `previewDeposit`).
33939
+ *
33940
+ * @returns `Result<PreviewDepositResponseV2>` — `{ shares }` (decimal string).
33941
+ */
33942
+ async previewDeposit(query, config) {
33943
+ return this.request(
33944
+ this.withQuery("/leverage-yield/preview/deposit", { vault: query.vault, assets: query.assets }),
33945
+ { method: "GET" },
33946
+ PreviewDepositResponseSchema,
33947
+ config
33948
+ );
33949
+ }
33950
+ /**
33951
+ * Preview the shares burned to withdraw `assets` from the vault (ERC-4626 `previewWithdraw`).
33952
+ *
33953
+ * @returns `Result<PreviewWithdrawResponseV2>` — `{ shares }` (decimal string).
33954
+ */
33955
+ async previewWithdraw(query, config) {
33956
+ return this.request(
33957
+ this.withQuery("/leverage-yield/preview/withdraw", { vault: query.vault, assets: query.assets }),
33958
+ { method: "GET" },
33959
+ PreviewWithdrawResponseSchema,
33960
+ config
33961
+ );
33962
+ }
33963
+ /**
33964
+ * Preview the assets returned for redeeming `shares` from the vault (ERC-4626 `previewRedeem`).
33965
+ *
33966
+ * @returns `Result<PreviewRedeemResponseV2>` — `{ assets }` (decimal string).
33967
+ */
33968
+ async previewRedeem(query, config) {
33969
+ return this.request(
33970
+ this.withQuery("/leverage-yield/preview/redeem", { vault: query.vault, shares: query.shares }),
33971
+ { method: "GET" },
33972
+ PreviewRedeemResponseSchema,
33973
+ config
33974
+ );
33975
+ }
33976
+ /**
33977
+ * Get an owner's vault share (lsoda*) balance.
33978
+ *
33979
+ * @returns `Result<ShareBalanceResponseV2>` — `{ balance }` (decimal string).
33980
+ */
33981
+ async getShareBalance(query, config) {
33982
+ return this.request(
33983
+ this.withQuery("/leverage-yield/share-balance", { vault: query.vault, owner: query.owner }),
33984
+ { method: "GET" },
33985
+ ShareBalanceResponseSchema,
33986
+ config
33987
+ );
33988
+ }
33989
+ /**
33990
+ * Get an owner's RAW ERC-4626 `maxWithdraw` — NOT dust-trimmed, unlike the SDK-local
33991
+ * `sodax.leverageYield.getMaxWithdrawForUser`. Apply a margin before using it as a withdraw amount.
33992
+ *
33993
+ * @returns `Result<MaxWithdrawResponseV2>` — `{ maxWithdraw }` (decimal string).
33994
+ */
33995
+ async getMaxWithdraw(query, config) {
33996
+ return this.request(
33997
+ this.withQuery("/leverage-yield/max-withdraw", { vault: query.vault, owner: query.owner }),
33998
+ { method: "GET" },
33999
+ MaxWithdrawResponseSchema,
34000
+ config
34001
+ );
34002
+ }
34003
+ // ──────────────────────────────────────────────────────────────────────
34004
+ // Quote · deadline
34005
+ // ──────────────────────────────────────────────────────────────────────
34006
+ /**
34007
+ * Quote a swap-style deposit: any solver-supported `tokenSrc` → the vault's lsoda* shares.
34008
+ * Pass `query.includeTxData = true` to also build the unsigned create-intent tx (`srcAddress`
34009
+ * required in the body then).
34010
+ *
34011
+ * @returns `Result<QuoteResponseV2>` — `quotedAmount` (shares) and optional `txData`.
34012
+ */
34013
+ async getDepositQuote(body, query, config) {
34014
+ const endpoint = query?.includeTxData ? "/leverage-yield/quote/deposit?includeTxData=true" : "/leverage-yield/quote/deposit";
34015
+ const txSchema = swapsApi.rawTxSchemaForChainKey(body.tokenSrcChainKey);
34016
+ return this.request(
34017
+ endpoint,
34018
+ { method: "POST", body: toJsonBody(body) },
34019
+ swapsApi.makeQuoteResponseSchema(txSchema),
34020
+ config
34021
+ );
34022
+ }
34023
+ /**
34024
+ * Quote a swap-style withdraw: the vault's lsoda* shares → any solver-supported `tokenDst`.
34025
+ * Pass `query.includeTxData = true` to also build the unsigned tx (signed on `srcChainKey`;
34026
+ * `srcAddress`/`dstAddress` required in the body then).
34027
+ *
34028
+ * @returns `Result<QuoteResponseV2>` — `quotedAmount` (output token) and optional `txData`.
34029
+ */
34030
+ async getWithdrawQuote(body, query, config) {
34031
+ const endpoint = query?.includeTxData ? "/leverage-yield/quote/withdraw?includeTxData=true" : "/leverage-yield/quote/withdraw";
34032
+ const txSchema = swapsApi.rawTxSchemaForChainKey(body.srcChainKey);
34033
+ return this.request(
34034
+ endpoint,
34035
+ { method: "POST", body: toJsonBody(body) },
34036
+ swapsApi.makeQuoteResponseSchema(txSchema),
34037
+ config
34038
+ );
34039
+ }
34040
+ /**
34041
+ * Compute a deposit/withdraw deadline (hub timestamp + `offsetSeconds`, default 300s).
34042
+ *
34043
+ * @returns `Result<DeadlineResponseV2>` — unix-seconds deadline (decimal string).
34044
+ */
34045
+ async getDeadline(query, config) {
34046
+ const params = {};
34047
+ if (query?.offsetSeconds !== void 0) params.offsetSeconds = String(query.offsetSeconds);
34048
+ return this.request(
34049
+ this.withQuery("/leverage-yield/deadline", params),
34050
+ { method: "GET" },
34051
+ swapsApi.DeadlineResponseSchema,
34052
+ config
34053
+ );
34054
+ }
34055
+ // ──────────────────────────────────────────────────────────────────────
34056
+ // Deposit allowance · approve · create intent (deposit / withdraw)
34057
+ // ──────────────────────────────────────────────────────────────────────
34058
+ /**
34059
+ * Check whether the deposit input-token allowance is already sufficient for the intent.
34060
+ * (Withdraw needs no spoke allowance — it spends lsoda* from the hub wallet.)
34061
+ *
34062
+ * @returns `Result<AllowanceCheckResponseV2>` — `{ valid }`.
34063
+ */
34064
+ async checkAllowance(body, config) {
34065
+ return this.request(
34066
+ "/leverage-yield/allowance/check",
34067
+ { method: "POST", body: toJsonBody(body) },
34068
+ swapsApi.AllowanceCheckResponseSchema,
34069
+ config
34070
+ );
34071
+ }
34072
+ /**
34073
+ * Build an unsigned token-approval transaction for the deposit input token.
34074
+ *
34075
+ * @returns `Result<ApproveResponseV2>` — `{ tx }` (chain-specific unsigned tx).
34076
+ */
34077
+ async approve(body, config) {
34078
+ const txSchema = swapsApi.rawTxSchemaForChainKey(body.srcChainKey);
34079
+ return this.request(
34080
+ "/leverage-yield/approve",
34081
+ { method: "POST", body: toJsonBody(body) },
34082
+ swapsApi.makeApproveResponseSchema(txSchema),
34083
+ config
34084
+ );
34085
+ }
34086
+ /**
34087
+ * Build an unsigned deposit create-intent transaction (any token → lsoda* shares).
34088
+ *
34089
+ * @returns `Result<CreateIntentResponseV2>` — `{ tx, intent, relayData }`.
34090
+ */
34091
+ async createDepositIntent(body, config) {
34092
+ const txSchema = swapsApi.rawTxSchemaForChainKey(body.srcChainKey);
34093
+ return this.request(
34094
+ "/leverage-yield/intents/deposit",
34095
+ { method: "POST", body: toJsonBody(body) },
34096
+ swapsApi.makeCreateIntentResponseSchema(txSchema),
34097
+ config
34098
+ );
34099
+ }
34100
+ /**
34101
+ * Build an unsigned withdraw create-intent transaction (lsoda* shares → any token). The backend
34102
+ * sets `hubWalletSwap` internally so the swap spends the lsoda* held in the user's hub wallet.
34103
+ *
34104
+ * @returns `Result<CreateIntentResponseV2>` — `{ tx, intent, relayData }`.
34105
+ */
34106
+ async createWithdrawIntent(body, config) {
34107
+ const txSchema = swapsApi.rawTxSchemaForChainKey(body.srcChainKey);
34108
+ return this.request(
34109
+ "/leverage-yield/intents/withdraw",
34110
+ { method: "POST", body: toJsonBody(body) },
34111
+ swapsApi.makeCreateIntentResponseSchema(txSchema),
34112
+ config
34113
+ );
34114
+ }
34115
+ // ──────────────────────────────────────────────────────────────────────
34116
+ // Intent lifecycle: submit · status · cancel · hash · packet · extra-data
34117
+ // ──────────────────────────────────────────────────────────────────────
34118
+ /**
34119
+ * Submit the broadcast intent tx to the relay.
34120
+ *
34121
+ * @returns `Result<SubmitIntentResponseV2>` — `{ result }` (opaque relay response).
34122
+ */
34123
+ async submitIntent(body, config) {
34124
+ return this.request(
34125
+ "/leverage-yield/intents/submit",
34126
+ { method: "POST", body: toJsonBody(body) },
34127
+ swapsApi.SubmitIntentResponseSchema,
34128
+ config
34129
+ );
34130
+ }
34131
+ /**
34132
+ * Poll the solver for intent execution status.
34133
+ *
34134
+ * @returns `Result<StatusResponseV2>` — `{ status, fillTxHash? }`.
34135
+ */
34136
+ async getStatus(body, config) {
34137
+ return this.request(
34138
+ "/leverage-yield/intents/status",
34139
+ { method: "POST", body: toJsonBody(body) },
34140
+ swapsApi.StatusResponseSchema,
34141
+ config
34142
+ );
34143
+ }
34144
+ /**
34145
+ * Build an unsigned cancel-intent transaction. The `intent` field carries `bigint` numerics —
34146
+ * {@link toJsonBody} serializes them to decimal strings.
34147
+ *
34148
+ * @returns `Result<CancelIntentResponseV2>` — `{ tx }`.
34149
+ */
34150
+ async cancelIntent(body, config) {
34151
+ const txSchema = swapsApi.rawTxSchemaForChainKey(body.srcChainKey);
34152
+ return this.request(
34153
+ "/leverage-yield/intents/cancel",
34154
+ { method: "POST", body: toJsonBody({ ...body, intent: _LeverageYieldApiService.toWireIntent(body.intent) }) },
34155
+ swapsApi.makeCancelIntentResponseSchema(txSchema),
34156
+ config
34157
+ );
34158
+ }
34159
+ /**
34160
+ * Compute the keccak256 hash of an Intent struct. The `intent` field carries `bigint` numerics.
34161
+ *
34162
+ * @returns `Result<IntentHashResponseV2>` — `{ hash }`.
34163
+ */
34164
+ async getIntentHash(body, config) {
34165
+ return this.request(
34166
+ "/leverage-yield/intents/hash",
34167
+ { method: "POST", body: toJsonBody({ ...body, intent: _LeverageYieldApiService.toWireIntent(body.intent) }) },
34168
+ swapsApi.IntentHashResponseSchema,
34169
+ config
34170
+ );
34171
+ }
34172
+ /**
34173
+ * Long-poll the relayer until the fill packet lands on the destination chain.
34174
+ *
34175
+ * @returns `Result<IntentPacketResponseV2>` — delivered packet data.
34176
+ */
34177
+ async getSolvedIntentPacket(body, config) {
34178
+ return this.request(
34179
+ "/leverage-yield/intents/packet",
34180
+ { method: "POST", body: toJsonBody(body) },
34181
+ swapsApi.IntentPacketResponseSchema,
34182
+ config
34183
+ );
34184
+ }
34185
+ /**
34186
+ * Recover the relay extra data needed by `/leverage-yield/intents/submit`. Provide EITHER
34187
+ * `txHash` OR `intent` (whose `bigint` numerics {@link toJsonBody} serializes).
34188
+ *
34189
+ * @returns `Result<IntentExtraDataResponseV2>` — `{ address, payload }`.
34190
+ */
34191
+ async getIntentSubmitTxExtraData(body, config) {
34192
+ const normalized = body.intent ? { ...body, intent: _LeverageYieldApiService.toWireIntent(body.intent) } : body;
34193
+ return this.request(
34194
+ "/leverage-yield/intents/extra-data",
34195
+ { method: "POST", body: toJsonBody(normalized) },
34196
+ swapsApi.RelayExtraDataResponseSchema,
34197
+ config
34198
+ );
34199
+ }
34200
+ /**
34201
+ * Get the on-chain fill state for an intent by its hub-chain tx hash.
34202
+ *
34203
+ * @returns `Result<IntentStateV2>` — `{ exists, remainingInput, receivedOutput, pendingPayment }`.
34204
+ */
34205
+ async getFilledIntent(txHash, config) {
34206
+ return this.request(
34207
+ `/leverage-yield/intents/${txHash}/fill`,
34208
+ { method: "GET" },
34209
+ swapsApi.IntentStateSchema,
34210
+ config
34211
+ );
34212
+ }
34213
+ /**
34214
+ * Look up an Intent struct by its hub-chain creation tx hash.
34215
+ *
34216
+ * @returns `Result<GetIntentResponseV2>` — the decoded intent (bigint fields as decimal strings).
34217
+ */
34218
+ async getIntent(txHash, config) {
34219
+ return this.request(`/leverage-yield/intents/${txHash}`, { method: "GET" }, swapsApi.IntentResponseSchema, config);
34220
+ }
34221
+ // ──────────────────────────────────────────────────────────────────────
34222
+ // Gas · fees
34223
+ // ──────────────────────────────────────────────────────────────────────
34224
+ /**
34225
+ * Estimate gas for a raw transaction on a spoke chain.
34226
+ *
34227
+ * @returns `Result<GasEstimateResponseV2>` — `{ gas }` (chain-specific shape).
34228
+ */
34229
+ async estimateGas(body, config) {
34230
+ return this.request(
34231
+ "/leverage-yield/gas/estimate",
34232
+ { method: "POST", body: toJsonBody(body) },
34233
+ swapsApi.GasEstimateResponseSchema,
34234
+ config
34235
+ );
34236
+ }
34237
+ /**
34238
+ * Compute the partner fee for a given input amount.
34239
+ *
34240
+ * @returns `Result<FeeResponseV2>` — `{ fee }` (decimal string).
34241
+ */
34242
+ async getPartnerFee(query, config) {
34243
+ return this.request(
34244
+ this.withQuery("/leverage-yield/fees/partner", { amount: query.amount }),
34245
+ { method: "GET" },
34246
+ swapsApi.FeeResponseSchema,
34247
+ config
34248
+ );
34249
+ }
34250
+ /**
34251
+ * Compute the protocol (solver) fee for a given input amount.
34252
+ *
34253
+ * @returns `Result<FeeResponseV2>` — `{ fee }` (decimal string).
34254
+ */
34255
+ async getSolverFee(query, config) {
34256
+ return this.request(
34257
+ this.withQuery("/leverage-yield/fees/solver", { amount: query.amount }),
34258
+ { method: "GET" },
34259
+ swapsApi.FeeResponseSchema,
34260
+ config
34261
+ );
34262
+ }
34263
+ // ──────────────────────────────────────────────────────────────────────
34264
+ // Submit-tx state machine
34265
+ // ──────────────────────────────────────────────────────────────────────
34266
+ /**
34267
+ * Submit a vault-swap transaction to be processed (relay, post-execution, etc.). The `intent`
34268
+ * field carries `bigint` numerics — {@link toJsonBody} serializes them. Idempotent on
34269
+ * `(txHash, srcChainKey)`.
34270
+ *
34271
+ * @returns `Result<SubmitTxResponseV2>` — `{ success, data: { status, message } }`.
34272
+ */
34273
+ async submitTx(body, config) {
34274
+ return this.request(
34275
+ "/leverage-yield/submit-tx",
34276
+ { method: "POST", body: toJsonBody({ ...body, intent: _LeverageYieldApiService.toWireIntent(body.intent) }) },
34277
+ swapsApi.SubmitTxResponseSchema,
34278
+ config
34279
+ );
34280
+ }
34281
+ /**
34282
+ * Get the processing status of a submitted vault-swap transaction by `(txHash, srcChainKey)`.
34283
+ *
34284
+ * @returns `Result<SubmitTxStatusResponseV2>` — `{ success, data }` (processing state).
34285
+ */
34286
+ async getSubmitTxStatus(query, config) {
34287
+ return this.request(
34288
+ this.withQuery("/leverage-yield/submit-tx/status", { txHash: query.txHash, srcChainKey: query.srcChainKey }),
34289
+ { method: "GET" },
34290
+ swapsApi.SubmitTxStatusResponseSchema,
34291
+ config
34292
+ );
34293
+ }
34294
+ // ──────────────────────────────────────────────────────────────────────
34295
+ // Utilities (parity with SwapsApiService)
34296
+ // ──────────────────────────────────────────────────────────────────────
34297
+ /**
34298
+ * Merge additional headers into the service's default header set. Existing keys are
34299
+ * overwritten; keys absent from `headers` are preserved.
34300
+ */
34301
+ setHeaders(headers) {
34302
+ assignHeaders(this.headers, headers);
34303
+ }
34304
+ /** Return the base URL the service is currently pointing at. */
34305
+ getBaseURL() {
34306
+ return this.config.baseURL;
34307
+ }
34308
+ /**
34309
+ * Return the effective per-request timeout (ms).
34310
+ *
34311
+ * Callers bounding a request tighter than this need it as the CEILING, because a
34312
+ * `RequestOverrideConfig.timeout` REPLACES the service value rather than lowering it: an override
34313
+ * derived from a caller budget alone would raise the bound whenever that budget is the larger of the
34314
+ * two. `SubmitTxAttempt.requestTimeout` clamps against both (`min(budget left in the attempt, this)`).
34315
+ */
34316
+ getTimeout() {
34317
+ return this.config.timeout;
34318
+ }
34319
+ };
32881
34320
 
32882
34321
  // src/backendApi/BackendApiService.ts
32883
34322
  var BackendApiService = class {
@@ -32885,6 +34324,7 @@ var BackendApiService = class {
32885
34324
  swaps;
32886
34325
  sponsoring;
32887
34326
  bridge;
34327
+ leverageYield;
32888
34328
  // resolved base-API config: the flat fields of the ApiConfig union with any `baseApiConfig` layered on
32889
34329
  // top. `baseURL` is the gateway root; `basePath` is this service's own mount below it.
32890
34330
  config;
@@ -32913,6 +34353,7 @@ var BackendApiService = class {
32913
34353
  const swapsConfig2 = resolveSwapsApiConfig(config);
32914
34354
  const sponsoringConfig = resolveSponsoringApiConfig(config);
32915
34355
  const bridgeConfig2 = resolveBridgeApiConfig(config);
34356
+ const leverageYieldConfig2 = resolveLeverageYieldApiConfig(config);
32916
34357
  const shortRoots = [
32917
34358
  ["backendApi", this.config.baseURL],
32918
34359
  ["api.swaps", swapsConfig2.baseURL],
@@ -32937,6 +34378,11 @@ var BackendApiService = class {
32937
34378
  inheritedApiKeyBaseURLs: [DEFAULT_SPONSORING_API_ENDPOINT, this.config.baseURL]
32938
34379
  });
32939
34380
  this.bridge = new BridgeApiService(withApiKey(bridgeConfig2, options.apiKey), this.logger, overrideOptions);
34381
+ this.leverageYield = new LeverageYieldApiService(
34382
+ withApiKey(leverageYieldConfig2, options.apiKey),
34383
+ this.logger,
34384
+ overrideOptions
34385
+ );
32940
34386
  }
32941
34387
  /**
32942
34388
  * Issue the HTTP call for a route.
@@ -33340,15 +34786,17 @@ var BackendApiService = class {
33340
34786
  * without constructing a new service instance. Existing header keys are
33341
34787
  * overwritten; keys absent from `headers` are preserved.
33342
34788
  *
33343
- * Headers also reach `swaps` and `bridge`, but never `sponsoring`: it is configured independently, so
33344
- * base-API credentials must not be forwarded to whatever origin it points at. Note `swaps` can also be
33345
- * retargeted to another origin via `swapsApiConfig`, in which case a header set here follows it.
34789
+ * Headers also reach `swaps`, `bridge` and `leverageYield`, but never `sponsoring`: it is configured
34790
+ * independently, so base-API credentials must not be forwarded to whatever origin it points at. Note
34791
+ * `swaps` can also be retargeted to another origin via `swapsApiConfig`, in which case a header set
34792
+ * here follows it.
33346
34793
  *
33347
34794
  * @param headers - Key-value pairs to add or overwrite in the default headers.
33348
34795
  */
33349
34796
  setHeaders(headers) {
33350
34797
  assignHeaders(this.headers, headers);
33351
34798
  this.swaps.setHeaders(headers);
34799
+ this.leverageYield.setHeaders(headers);
33352
34800
  this.bridge.setHeaders(headers);
33353
34801
  }
33354
34802
  /**
@@ -36290,7 +37738,7 @@ var AssetService = class {
36290
37738
  ok: true,
36291
37739
  value: {
36292
37740
  tx: txResult.value,
36293
- relayData: { address: recipient, payload: data }
37741
+ relayData: { address: fromHubWallet, payload: data }
36294
37742
  }
36295
37743
  };
36296
37744
  } catch (error) {
@@ -41574,7 +43022,9 @@ var PartnerFeeClaimService = class {
41574
43022
  isEvmWalletProviderType(walletProvider),
41575
43023
  "PartnerFeeClaimService only supports Evm (sonic) wallet provider"
41576
43024
  );
41577
- const txHash = await walletProvider.sendTransaction(rawTx);
43025
+ const txHash = await walletProvider.sendTransaction(rawTx, {
43026
+ expectedChainId: getEvmViemChain(ChainKeys.SONIC_MAINNET).id
43027
+ });
41578
43028
  return {
41579
43029
  ok: true,
41580
43030
  value: txHash
@@ -41769,7 +43219,9 @@ var PartnerFeeClaimService = class {
41769
43219
  value: rawTx
41770
43220
  };
41771
43221
  }
41772
- const txHash = await _params.walletProvider.sendTransaction(rawTx);
43222
+ const txHash = await _params.walletProvider.sendTransaction(rawTx, {
43223
+ expectedChainId: getEvmViemChain(ChainKeys.SONIC_MAINNET).id
43224
+ });
41773
43225
  return {
41774
43226
  ok: true,
41775
43227
  value: txHash
@@ -41916,7 +43368,9 @@ var PartnerFeeClaimService = class {
41916
43368
  value: rawTx
41917
43369
  };
41918
43370
  }
41919
- const txHash = await _params.walletProvider.sendTransaction(rawTx);
43371
+ const txHash = await _params.walletProvider.sendTransaction(rawTx, {
43372
+ expectedChainId: getEvmViemChain(ChainKeys.SONIC_MAINNET).id
43373
+ });
41920
43374
  return {
41921
43375
  ok: true,
41922
43376
  value: txHash
@@ -42293,10 +43747,20 @@ var LeverageYieldService = class {
42293
43747
  hubProvider;
42294
43748
  config;
42295
43749
  spoke;
42296
- constructor({ hubProvider, config, spoke }) {
43750
+ backendApi;
43751
+ /**
43752
+ * Effective backend submit-tx flow (`leverageYield.useBackendSubmitTx`, default off). Read live off
43753
+ * `ConfigService`, like `config.leverageYieldPartnerFee`, so the config object and the behavior can
43754
+ * never disagree.
43755
+ */
43756
+ get useBackendSubmitTx() {
43757
+ return this.config.leverageYieldUseBackendSubmitTx;
43758
+ }
43759
+ constructor({ hubProvider, config, spoke, backendApi }) {
42297
43760
  this.hubProvider = hubProvider;
42298
43761
  this.config = config;
42299
43762
  this.spoke = spoke;
43763
+ this.backendApi = backendApi;
42300
43764
  }
42301
43765
  // ─── Registry ──────────────────────────────────────────────────────────
42302
43766
  /** Returns the static registry of known leverage-yield vaults. */
@@ -42305,7 +43769,7 @@ var LeverageYieldService = class {
42305
43769
  }
42306
43770
  /** Looks up a vault by its `name` field. Returns `undefined` when not registered. */
42307
43771
  getVault(name) {
42308
- return this.listVaults().find((v10) => v10.name === name);
43772
+ return this.listVaults().find((v12) => v12.name === name);
42309
43773
  }
42310
43774
  /**
42311
43775
  * Looks up a registered vault by its on-chain proxy address (case-insensitive).
@@ -42313,7 +43777,7 @@ var LeverageYieldService = class {
42313
43777
  */
42314
43778
  getVaultByAddress(address) {
42315
43779
  const normalized = address.toLowerCase();
42316
- return this.listVaults().find((v10) => v10.vault.toLowerCase() === normalized);
43780
+ return this.listVaults().find((v12) => v12.vault.toLowerCase() === normalized);
42317
43781
  }
42318
43782
  /**
42319
43783
  * Resolves the intent `deadline`: returns the caller-supplied value verbatim, otherwise
@@ -42736,62 +44200,21 @@ var LeverageYieldService = class {
42736
44200
  "vaultSwap",
42737
44201
  async () => {
42738
44202
  try {
42739
- const timeout = _params.timeout;
42740
44203
  const createIntentResult = await this.createVaultIntent(_params);
42741
44204
  if (!createIntentResult.ok) {
42742
44205
  return { ok: false, error: createIntentResult.error };
42743
44206
  }
42744
- const { tx: spokeTxHash, intent, relayData } = createIntentResult.value;
42745
- const verifyTxHashResult = await this.spoke.verifyTxHash({
42746
- txHash: spokeTxHash,
42747
- chainKey: srcChainKey
42748
- });
42749
- if (!verifyTxHashResult.ok) {
42750
- return {
42751
- ok: false,
42752
- error: verifyFailed("leverageYield", verifyTxHashResult.error, baseCtx)
42753
- };
42754
- }
42755
- let dstIntentTxHash;
42756
- if (isHubChainKeyType(srcChainKey)) {
42757
- dstIntentTxHash = spokeTxHash;
42758
- } else {
42759
- const packet = await relayTxAndWaitPacket({
42760
- srcTxHash: spokeTxHash,
42761
- data: relayData,
42762
- chainKey: srcChainKey,
42763
- relayerApiEndpoint: this.config.relay.relayerApiEndpoint,
42764
- timeout
42765
- });
42766
- if (!packet.ok) {
42767
- return {
42768
- ok: false,
42769
- error: mapRelayFailure(packet.error, { feature: "leverageYield", ...baseCtx })
42770
- };
42771
- }
42772
- dstIntentTxHash = packet.value.dst_tx_hash;
42773
- }
42774
- const postExecResult = await this.notifySolver({
42775
- intent_tx_hash: dstIntentTxHash
42776
- });
42777
- if (!postExecResult.ok) {
42778
- return { ok: false, error: postExecResult.error };
44207
+ const created = createIntentResult.value;
44208
+ const timeoutMs = resolveTimeoutMs(_params.timeout, DEFAULT_RELAY_TX_TIMEOUT);
44209
+ if (this.useBackendSubmitTx) {
44210
+ const submitted = await this.submitTx(_params, created, createSubmitTxAttempt(timeoutMs));
44211
+ if (submitted.ok) return submitted;
44212
+ this.config.logger.warn(
44213
+ "[leverageYield] backend submit-tx did not complete; falling back to the client-side relay",
44214
+ { error: submitted.error }
44215
+ );
42779
44216
  }
42780
- return {
42781
- ok: true,
42782
- value: {
42783
- solverExecutionResponse: postExecResult.value,
42784
- intent,
42785
- intentDeliveryInfo: {
42786
- srcChainKey,
42787
- srcTxHash: spokeTxHash,
42788
- srcAddress: params.srcAddress,
42789
- dstChainKey: params.dstChainKey,
42790
- dstTxHash: dstIntentTxHash,
42791
- dstAddress: params.dstAddress
42792
- }
42793
- }
42794
- };
44217
+ return this.fallbackVaultSwapSteps(_params, created, timeoutMs);
42795
44218
  } catch (error) {
42796
44219
  if (isLeverageYieldSwapError(error)) return { ok: false, error };
42797
44220
  return {
@@ -42819,6 +44242,129 @@ var LeverageYieldService = class {
42819
44242
  }
42820
44243
  );
42821
44244
  }
44245
+ /**
44246
+ * Client-side vault-swap completion (the default path): verify the broadcast intent tx landed,
44247
+ * relay it to the hub (Sonic) — or use it directly when the source IS the hub — then notify the
44248
+ * solver via {@link LeverageYieldService.notifySolver} and build the {@link VaultSwapResponse}.
44249
+ * Extracted from `vaultSwap()` so the opt-in backend 2-step path ({@link LeverageYieldService.submitTx})
44250
+ * can fall back to it on any non-success. Leverage-yield copy of `SwapService.fallbackSwapSteps`.
44251
+ */
44252
+ async fallbackVaultSwapSteps(_params, created, timeoutMs) {
44253
+ const { params } = _params;
44254
+ const srcChainKey = params.srcChainKey;
44255
+ const baseCtx = { srcChainKey, dstChainKey: params.dstChainKey, action: "vaultSwap" };
44256
+ const { tx: spokeTxHash, intent, relayData } = created;
44257
+ const verifyTxHashResult = await this.spoke.verifyTxHash({
44258
+ txHash: spokeTxHash,
44259
+ chainKey: srcChainKey
44260
+ });
44261
+ if (!verifyTxHashResult.ok) {
44262
+ return { ok: false, error: verifyFailed("leverageYield", verifyTxHashResult.error, baseCtx) };
44263
+ }
44264
+ let dstIntentTxHash;
44265
+ if (isHubChainKeyType(srcChainKey)) {
44266
+ dstIntentTxHash = spokeTxHash;
44267
+ } else {
44268
+ const packet = await relayTxAndWaitPacket({
44269
+ srcTxHash: spokeTxHash,
44270
+ data: relayData,
44271
+ chainKey: srcChainKey,
44272
+ relayerApiEndpoint: this.config.relay.relayerApiEndpoint,
44273
+ // The caller's full `timeout`, starting HERE — whether this runs as the only path or as the
44274
+ // backend's fallback, so a stalled backend attempt cannot shorten the relay wait. The floor
44275
+ // covers a sub-floor caller `timeout`: `relayTxAndWaitPacket` SUBMITS before `timeout` bounds
44276
+ // anything, so a zero budget would strand an already-landed tx unrelayed.
44277
+ timeout: Math.max(timeoutMs, RELAY_FALLBACK_FLOOR_MS)
44278
+ });
44279
+ if (!packet.ok) {
44280
+ return { ok: false, error: mapRelayFailure(packet.error, { feature: "leverageYield", ...baseCtx }) };
44281
+ }
44282
+ dstIntentTxHash = packet.value.dst_tx_hash;
44283
+ }
44284
+ const postExecResult = await this.notifySolver({
44285
+ intent_tx_hash: dstIntentTxHash
44286
+ });
44287
+ if (!postExecResult.ok) {
44288
+ return { ok: false, error: postExecResult.error };
44289
+ }
44290
+ return {
44291
+ ok: true,
44292
+ value: {
44293
+ solverExecutionResponse: postExecResult.value,
44294
+ intent,
44295
+ intentDeliveryInfo: {
44296
+ srcChainKey,
44297
+ srcTxHash: spokeTxHash,
44298
+ srcAddress: params.srcAddress,
44299
+ dstChainKey: params.dstChainKey,
44300
+ dstTxHash: dstIntentTxHash,
44301
+ dstAddress: params.dstAddress
44302
+ }
44303
+ }
44304
+ };
44305
+ }
44306
+ /**
44307
+ * Backend 2-step vault-swap path (opt-in via `leverageYield.useBackendSubmitTx`): hand the
44308
+ * broadcast intent tx to the leverage-yield API (`POST /leverage-yield/submit-tx`); the backend
44309
+ * relays + post-executes server-side. Polls `getSubmitTxStatus` until `solved`, then reconstructs
44310
+ * the same {@link VaultSwapResponse} the client-side path returns.
44311
+ *
44312
+ * Never throws — returns `{ ok: false }` on any non-success (submit `!ok`, a 200 the backend did not
44313
+ * accept, terminal `failed` / abandoned, or poll timeout) so `vaultSwap()` falls back to
44314
+ * {@link LeverageYieldService.fallbackVaultSwapSteps}. Falling back is safe: re-relaying / re-posting
44315
+ * an already-processed vault swap is idempotent (the relay dedups the `executed` packet and the solver
44316
+ * re-affirms the intent — no double-fill), and load-bearing rather than belt-and-braces: the backend
44317
+ * keeps processing after this attempt gives up, so the fallback's relay can race the backend's own.
44318
+ *
44319
+ * The attempt itself — POST, budget clamps, status poll — is {@link runBackendSubmitTx}, shared with
44320
+ * swaps and bridge. What is leverage-yield-specific and lives here: the request body (including the
44321
+ * `operation` discriminator), the `solved` terminal status, the mapping to a
44322
+ * {@link VaultSwapResponse}, and the leverage-yield error taxonomy.
44323
+ *
44324
+ * `attempt` bounds this attempt alone — the POST and every status request draw on it, and the
44325
+ * client-side fallback holds a separate fresh `timeout`.
44326
+ */
44327
+ async submitTx(_params, created, attempt) {
44328
+ const { params } = _params;
44329
+ const srcChainKey = params.srcChainKey;
44330
+ const baseCtx = { srcChainKey, dstChainKey: params.dstChainKey, action: "vaultSwap" };
44331
+ const { tx: spokeTxHash, intent, relayData } = created;
44332
+ try {
44333
+ const outcome = await runBackendSubmitTx({
44334
+ attempt,
44335
+ api: this.backendApi.leverageYield,
44336
+ body: {
44337
+ txHash: spokeTxHash,
44338
+ srcChainKey,
44339
+ walletAddress: params.srcAddress,
44340
+ intent,
44341
+ relayData: relayData.payload,
44342
+ // `withdraw` sets `hubWalletSwap: true` (spends the hub-wallet lsoda*); a plain deposit doesn't.
44343
+ operation: _params.hubWalletSwap ? "withdraw" : "deposit"
44344
+ },
44345
+ statusQuery: { txHash: spokeTxHash, srcChainKey },
44346
+ // A vault deposit/withdraw IS a solver swap, so terminal success is `solved` — not bridge's
44347
+ // `executed`.
44348
+ terminalStatus: "solved",
44349
+ onExecuted: (result) => result?.dstIntentTxHash && result.intent_hash ? {
44350
+ // Backend serializes the hex intent_hash as a plain string; brand it at the boundary.
44351
+ solverExecutionResponse: { answer: "OK", intent_hash: result.intent_hash },
44352
+ intent,
44353
+ intentDeliveryInfo: {
44354
+ srcChainKey,
44355
+ srcTxHash: spokeTxHash,
44356
+ srcAddress: params.srcAddress,
44357
+ dstChainKey: params.dstChainKey,
44358
+ dstTxHash: result.dstIntentTxHash,
44359
+ dstAddress: params.dstAddress
44360
+ }
44361
+ } : void 0
44362
+ });
44363
+ return outcome.ok ? { ok: true, value: outcome.value } : { ok: false, error: executionFailed("leverageYield", outcome.cause, baseCtx) };
44364
+ } catch (error) {
44365
+ return { ok: false, error: unknownFailed("leverageYield", error, baseCtx) };
44366
+ }
44367
+ }
42822
44368
  /**
42823
44369
  * Notifies the solver that the vault intent landed on the hub, triggering it to fill.
42824
44370
  * Leverage-yield copy of the swap domain's `postExecution` — emits only
@@ -43830,7 +45376,8 @@ var Sodax = class {
43830
45376
  this.leverageYield = new LeverageYieldService({
43831
45377
  hubProvider: this.hubProvider,
43832
45378
  config: this.config,
43833
- spoke: this.spoke
45379
+ spoke: this.spoke,
45380
+ backendApi: this.backendApi
43834
45381
  });
43835
45382
  this.sponsoring = new SponsoringService({
43836
45383
  config: this.config,
@@ -43961,6 +45508,7 @@ exports.IntentsAbi = IntentsAbi;
43961
45508
  exports.LOOKUP_CODES = LOOKUP_CODES;
43962
45509
  exports.LTV_PRECISION = LTV_PRECISION;
43963
45510
  exports.LendingPoolService = LendingPoolService;
45511
+ exports.LeverageYieldApiService = LeverageYieldApiService;
43964
45512
  exports.LeverageYieldService = LeverageYieldService;
43965
45513
  exports.LockupMultiplier = LockupMultiplier;
43966
45514
  exports.LockupPeriod = LockupPeriod;
@@ -44064,6 +45612,7 @@ exports.calculateHealthFactorFromBalances = calculateHealthFactorFromBalances;
44064
45612
  exports.calculateHealthFactorFromBalancesBigUnits = calculateHealthFactorFromBalancesBigUnits;
44065
45613
  exports.calculateLinearInterest = calculateLinearInterest;
44066
45614
  exports.calculatePercentageFeeAmount = calculatePercentageFeeAmount;
45615
+ exports.canonicalizeBitcoinAddress = canonicalizeBitcoinAddress;
44067
45616
  exports.clPoolAbi = clPoolAbi;
44068
45617
  exports.clPoolManagerAbi = clPoolManagerAbi;
44069
45618
  exports.clPositionManagerAbi = clPositionManagerAbi;
@@ -44086,6 +45635,7 @@ exports.dexPools = dexPools;
44086
45635
  exports.encodeAddress = encodeAddress;
44087
45636
  exports.encodeBtcPayloadToBytes = encodeBtcPayloadToBytes;
44088
45637
  exports.encodeContractCalls = encodeContractCalls;
45638
+ exports.encodeTokenIdentifier = encodeTokenIdentifier;
44089
45639
  exports.erc20Abi = erc20Abi;
44090
45640
  exports.erc4626Abi = erc4626Abi;
44091
45641
  exports.estimateBitcoinTxSize = estimateBitcoinTxSize;
@@ -44255,6 +45805,9 @@ exports.isSwapError = isSwapError;
44255
45805
  exports.isSwapSupportedToken = isSwapSupportedToken;
44256
45806
  exports.isUndefinedOrValidWalletProviderForChainKey = isUndefinedOrValidWalletProviderForChainKey;
44257
45807
  exports.isUnifiedBnUSDMigrateParams = isUnifiedBnUSDMigrateParams;
45808
+ exports.isValidBitcoinAddress = isValidBitcoinAddress;
45809
+ exports.isValidInjectiveAddress = isValidInjectiveAddress;
45810
+ exports.isValidNearAccountId = isValidNearAccountId;
44258
45811
  exports.isValidWalletProviderForChainKey = isValidWalletProviderForChainKey;
44259
45812
  exports.kaiaSupportedTokens = kaiaSupportedTokens;
44260
45813
  exports.leverageYieldConfig = leverageYieldConfig;