@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 +1783 -230
- package/dist/index.d.cts +374 -7
- package/dist/index.d.ts +374 -7
- package/dist/index.mjs +1781 -234
- package/package.json +4 -4
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,
|
|
126
|
-
out[key] = sanitizeValue(
|
|
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((
|
|
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,
|
|
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((
|
|
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(
|
|
155
|
+
function safeString(v12) {
|
|
156
156
|
try {
|
|
157
|
-
return String(
|
|
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://
|
|
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
|
-
...
|
|
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
|
-
...
|
|
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
|
-
//
|
|
4294
|
-
|
|
4295
|
-
|
|
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 =
|
|
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
|
-
|
|
5035
|
-
|
|
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
|
|
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((
|
|
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
|
-
|
|
15066
|
-
|
|
15067
|
-
|
|
15068
|
-
|
|
15069
|
-
|
|
15070
|
-
|
|
15071
|
-
|
|
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
|
-
|
|
15087
|
-
|
|
15088
|
-
|
|
15089
|
-
|
|
15090
|
-
|
|
15091
|
-
|
|
15092
|
-
|
|
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
|
-
|
|
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(
|
|
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(
|
|
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
|
|
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
|
-
|
|
17915
|
+
array4[ai] = n1 * 16 + n2;
|
|
17110
17916
|
}
|
|
17111
|
-
return
|
|
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
|
|
18547
|
+
let v12 = u8n(hashLen);
|
|
17742
18548
|
let k = u8n(hashLen);
|
|
17743
18549
|
let i = 0;
|
|
17744
18550
|
const reset = () => {
|
|
17745
|
-
|
|
18551
|
+
v12.fill(1);
|
|
17746
18552
|
k.fill(0);
|
|
17747
18553
|
i = 0;
|
|
17748
18554
|
};
|
|
17749
|
-
const h = (...msgs) => hmacFn(k, concatBytes(
|
|
18555
|
+
const h = (...msgs) => hmacFn(k, concatBytes(v12, ...msgs));
|
|
17750
18556
|
const reseed = (seed = NULL) => {
|
|
17751
18557
|
k = h(byte0, seed);
|
|
17752
|
-
|
|
18558
|
+
v12 = h();
|
|
17753
18559
|
if (seed.length === 0)
|
|
17754
18560
|
return;
|
|
17755
18561
|
k = h(byte1, seed);
|
|
17756
|
-
|
|
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
|
-
|
|
17765
|
-
const sl =
|
|
18570
|
+
v12 = h();
|
|
18571
|
+
const sl = v12.slice();
|
|
17766
18572
|
out.push(sl);
|
|
17767
|
-
len +=
|
|
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(
|
|
17783
|
-
if (!
|
|
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 =
|
|
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,
|
|
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(
|
|
17833
|
-
if (
|
|
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(
|
|
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
|
|
17865
|
-
const nv = Fp.mul(n,
|
|
17866
|
-
const i = Fp.mul(Fp.mul(nv, _2n),
|
|
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,
|
|
19254
|
+
const uvRatio2 = extraOpts.uvRatio || ((u, v12) => {
|
|
18449
19255
|
try {
|
|
18450
|
-
return { isValid: true, value: Fp.sqrt(Fp.div(u,
|
|
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
|
|
18547
|
-
let { isValid, value: x } = uvRatio2(u,
|
|
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,
|
|
19693
|
+
function uvRatio(u, v12) {
|
|
18888
19694
|
const P = ed25519_CURVE_p;
|
|
18889
|
-
const v32 = mod(
|
|
18890
|
-
const v72 = mod(v32 * v32 *
|
|
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(
|
|
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((
|
|
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((
|
|
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
|
|
19426
|
-
if (
|
|
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:
|
|
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(
|
|
20802
|
+
function isBiggerThanHalfOrder(number6) {
|
|
19997
20803
|
const HALF = CURVE_ORDER >> _1n6;
|
|
19998
|
-
return
|
|
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
|
|
20182
|
-
return
|
|
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
|
|
24948
|
+
let object6;
|
|
24137
24949
|
try {
|
|
24138
|
-
({ object:
|
|
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 (!
|
|
24954
|
+
if (!object6) {
|
|
24143
24955
|
throw new Error("Asset manager id not found (no data)");
|
|
24144
24956
|
}
|
|
24145
|
-
const fields =
|
|
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
|
-
|
|
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 `
|
|
33344
|
-
* base-API credentials must not be forwarded to whatever origin it points at. Note
|
|
33345
|
-
* retargeted to another origin via `swapsApiConfig`, in which case a header set
|
|
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:
|
|
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
|
-
|
|
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((
|
|
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((
|
|
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
|
|
42745
|
-
const
|
|
42746
|
-
|
|
42747
|
-
|
|
42748
|
-
|
|
42749
|
-
|
|
42750
|
-
|
|
42751
|
-
|
|
42752
|
-
|
|
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;
|