@chainflip/sdk 1.8.4-beta.0 → 1.9.0-beta.0

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/swap.mjs CHANGED
@@ -1,19 +1,18 @@
1
- import { isString, InternalAssets, Chains, Assets, ChainflipNetworks, isValidAssetAndChain, getInternalAssets, getEnvironment, assetConstants, getEvmChainId, getSupportedAssets, getInternalAsset, isNotNullish, getAllBoostPoolsDepth, assert, getAssetAndChain, isTestnet, readChainAssetValue, ADDRESSES } from './chunk-HBQFFIRA.mjs';
2
- export { Assets, InternalAssets as ChainflipIds, ChainflipNetworks, Chains, getInternalAsset as getChainflipId } from './chunk-HBQFFIRA.mjs';
1
+ import { getEnvironment, getEvmChainId, getAllBoostPoolsDepth, assert, isNotNullish, ADDRESSES } from './chunk-GWPJTKIG.mjs';
2
+ import { chainflipChains, assetSymbols, isValidAssetAndChain, getInternalAssets, assetConstants, getInternalAsset, internalAssetToRpcAsset, chainflipNetworks, chainflipAssets, readAssetValue } from '@chainflip/utils/chainflip';
3
+ export { getInternalAsset as getChainflipId } from '@chainflip/utils/chainflip';
3
4
  import { createTRPCProxyClient, httpBatchLink } from '@trpc/client';
4
5
  import superjson from 'superjson';
5
6
  import { HttpClient } from '@chainflip/rpc';
6
- import * as ss582 from '@chainflip/utils/ss58';
7
+ import * as ss58 from '@chainflip/utils/ss58';
7
8
  import { isHex, toUpperCase } from '@chainflip/utils/string';
8
9
  import { priceX128ToPrice } from '@chainflip/utils/tickMath';
9
10
  import BigNumber2 from 'bignumber.js';
10
11
  import { z } from 'zod';
11
- import * as bitcoin from '@chainflip/bitcoin';
12
12
  import { isValidSolanaAddress } from '@chainflip/solana';
13
- import * as base58 from '@chainflip/utils/base58';
14
- import { hexToBytes } from '@chainflip/utils/bytes';
15
- import * as ethers from 'ethers';
16
13
  import { hexEncodeNumber } from '@chainflip/utils/number';
14
+ import * as bitcoin from '@chainflip/bitcoin';
15
+ import * as ethers from 'ethers';
17
16
  import axios from 'axios';
18
17
 
19
18
  // ../shared/src/strings.ts
@@ -34,108 +33,25 @@ var transformKeysToCamelCase = (obj) => {
34
33
  }
35
34
  return obj;
36
35
  };
37
- var validatePolkadotAddress = (address) => {
38
- if (isHex(address)) return address.length === 66;
39
- try {
40
- ss582.decode(address);
41
- return true;
42
- } catch {
43
- return false;
44
- }
45
- };
46
- var validateEvmAddress = (address) => ethers.isAddress(address);
47
- var validateBitcoinMainnetAddress = (address) => bitcoin.isValidAddressForNetwork(address, "mainnet");
48
- var validateBitcoinTestnetAddress = (address) => bitcoin.isValidAddressForNetwork(address, "testnet");
49
- var validateBitcoinRegtestAddress = (address) => bitcoin.isValidAddressForNetwork(address, "regtest");
50
- var validateSolanaAddress = isValidSolanaAddress;
51
- var validators = {
52
- mainnet: {
53
- Bitcoin: validateBitcoinMainnetAddress,
54
- Ethereum: validateEvmAddress,
55
- Polkadot: validatePolkadotAddress,
56
- Arbitrum: validateEvmAddress,
57
- Solana: validateSolanaAddress
58
- },
59
- perseverance: {
60
- Bitcoin: validateBitcoinTestnetAddress,
61
- Ethereum: validateEvmAddress,
62
- Polkadot: validatePolkadotAddress,
63
- Arbitrum: validateEvmAddress,
64
- Solana: validateSolanaAddress
65
- },
66
- sisyphos: {
67
- Bitcoin: validateBitcoinTestnetAddress,
68
- Ethereum: validateEvmAddress,
69
- Polkadot: validatePolkadotAddress,
70
- Arbitrum: validateEvmAddress,
71
- Solana: validateSolanaAddress
72
- },
73
- backspin: {
74
- Bitcoin: validateBitcoinRegtestAddress,
75
- Ethereum: validateEvmAddress,
76
- Polkadot: validatePolkadotAddress,
77
- Arbitrum: validateEvmAddress,
78
- Solana: validateSolanaAddress
79
- },
80
- localnet: {
81
- Bitcoin: validateBitcoinRegtestAddress,
82
- Ethereum: validateEvmAddress,
83
- Polkadot: validatePolkadotAddress,
84
- Arbitrum: validateEvmAddress,
85
- Solana: validateSolanaAddress
86
- }
87
- };
88
- var validateAddress = (chain2, address, network) => validators[network][chain2](address);
89
-
90
- // ../shared/src/parsers.ts
91
- var chainflipSS58Prefix = 2112;
92
- var enumValues = Object.values;
93
- var safeStringify = (obj) => JSON.stringify(obj, (key, value) => typeof value === "bigint" ? value.toString() : value);
94
- var errorMap = (_issue, context) => ({
95
- message: `received: ${safeStringify(context.data)}`
96
- });
97
- var string = z.string({ errorMap });
98
- var number = z.number({ errorMap });
99
- var booleanString = string.regex(/^(true|false)$/i).transform((v) => v.toLowerCase() === "true");
100
- var numericString = string.regex(/^[0-9]+$/);
101
- var numericOrEmptyString = string.regex(/^[0-9]*$/);
102
- var hexString = string.refine((v) => /^0x[0-9a-f]*$/i.test(v));
36
+ var booleanString = z.string().regex(/^(true|false)$/i).transform((v) => v.toLowerCase() === "true");
37
+ var numericString = z.string().regex(/^[0-9]+$/);
38
+ var numericOrEmptyString = z.string().regex(/^[0-9]*$/);
39
+ var hexString = z.string().refine((v) => /^0x[0-9a-f]*$/i.test(v));
103
40
  var hexStringWithMaxByteSize = (maxByteSize) => hexString.refine((val) => val.length / 2 <= maxByteSize + 1, {
104
41
  message: `String must be less than or equal to ${maxByteSize} bytes`
105
42
  });
106
43
  var DOT_PREFIX = 0;
107
- z.union([string, hexString]).transform((arg) => {
108
- try {
109
- if (arg.startsWith("0x")) {
110
- return ss582.encode({ data: arg, ss58Format: DOT_PREFIX });
111
- }
112
- return ss582.encode({ data: ss582.decode(arg).data, ss58Format: DOT_PREFIX });
113
- } catch {
114
- return null;
115
- }
116
- }).refine(isString, {
117
- message: `address is not a valid polkadot address`
118
- });
119
- hexString.refine(
120
- (address) => ethers.isAddress(address),
121
- (address) => ({ message: `${address} is not a valid Ethereum address` })
122
- );
123
- var chainflipAddress = string.refine(
124
- (address) => address.startsWith("cF") && ss582.decode(address),
44
+ var chainflipAddress = z.string().refine(
45
+ (address) => address.startsWith("cF") && ss58.decode(address),
125
46
  (address) => ({ message: `${address} is not a valid Chainflip address` })
126
47
  );
127
- var solanaAddress = string.refine(isValidSolanaAddress, (address) => ({
48
+ var solanaAddress = z.string().refine(isValidSolanaAddress, (address) => ({
128
49
  message: `${address} is not a valid Solana address`
129
50
  }));
130
- numericString.transform((arg) => BigInt(arg));
131
- var u128 = z.union([number, numericString, hexString]).transform((arg) => BigInt(arg));
51
+ var u128 = z.union([z.number(), numericString, hexString]).transform((arg) => BigInt(arg));
132
52
  var unsignedInteger = z.union([u128, z.number().transform((n) => BigInt(n))]);
133
- var rustEnum = (values) => z.object({ __kind: z.enum(values) }).transform(({ __kind }) => __kind);
134
- rustEnum(enumValues(InternalAssets));
135
- rustEnum(enumValues(Chains));
136
- var chain = z.nativeEnum(Chains);
137
- var asset = z.nativeEnum(Assets);
138
- z.nativeEnum(ChainflipNetworks);
53
+ var chain = z.enum(chainflipChains);
54
+ var asset = z.enum(assetSymbols);
139
55
  var uncheckedAssetAndChain = z.object({
140
56
  asset: z.string(),
141
57
  chain: z.string()
@@ -143,30 +59,6 @@ var uncheckedAssetAndChain = z.object({
143
59
  var assetAndChain = uncheckedAssetAndChain.refine(
144
60
  (value) => isValidAssetAndChain(value)
145
61
  );
146
- z.union([
147
- hexString,
148
- //
149
- string.regex(/^[a-f\d]$/i).transform((value) => `0x${value}`)
150
- ]).transform(
151
- (value) => ss582.encode({ data: value, ss58Format: chainflipSS58Prefix })
152
- );
153
- z.union([
154
- z.object({ __kind: z.literal("Swap"), swapId: u128 }),
155
- z.object({ __kind: z.literal("LiquidityProvision"), lpAccount: hexString }),
156
- z.object({
157
- __kind: z.literal("CcmTransfer"),
158
- principalSwapId: u128.nullable().optional(),
159
- gasSwapId: u128.nullable().optional()
160
- }),
161
- z.object({
162
- __kind: z.literal("NoAction")
163
- }),
164
- z.object({
165
- __kind: z.literal("BoostersCredited"),
166
- prewitnessedDepositId: u128
167
- })
168
- ]);
169
- hexString.transform((value) => base58.encode(hexToBytes(value)));
170
62
  z.object({
171
63
  srcChain: chain,
172
64
  srcAsset: asset,
@@ -242,21 +134,78 @@ var ccmParamsSchema = z.object({
242
134
  }));
243
135
  var affiliateBroker = z.object({
244
136
  account: chainflipAddress,
245
- commissionBps: number
137
+ commissionBps: z.number()
246
138
  }).transform(({ account, commissionBps: bps }) => ({ account, bps }));
247
139
  var dcaParams = z.object({
248
- numberOfChunks: number,
249
- chunkIntervalBlocks: number
140
+ numberOfChunks: z.number(),
141
+ chunkIntervalBlocks: z.number()
250
142
  });
251
143
  z.object({
252
- retryDurationBlocks: number,
144
+ retryDurationBlocks: z.number(),
253
145
  refundAddress: z.string(),
254
146
  minPriceX128: numericString
255
147
  });
148
+ var validatePolkadotAddress = (address) => {
149
+ if (isHex(address)) return address.length === 66;
150
+ try {
151
+ ss58.decode(address);
152
+ return true;
153
+ } catch {
154
+ return false;
155
+ }
156
+ };
157
+ var validateEvmAddress = (address) => ethers.isAddress(address);
158
+ var validateBitcoinMainnetAddress = (address) => bitcoin.isValidAddressForNetwork(address, "mainnet");
159
+ var validateBitcoinTestnetAddress = (address) => bitcoin.isValidAddressForNetwork(address, "testnet");
160
+ var validateBitcoinRegtestAddress = (address) => bitcoin.isValidAddressForNetwork(address, "regtest");
161
+ var validateSolanaAddress = isValidSolanaAddress;
162
+ var validators = {
163
+ mainnet: {
164
+ Bitcoin: validateBitcoinMainnetAddress,
165
+ Ethereum: validateEvmAddress,
166
+ Polkadot: validatePolkadotAddress,
167
+ Arbitrum: validateEvmAddress,
168
+ Solana: validateSolanaAddress,
169
+ Assethub: validatePolkadotAddress
170
+ },
171
+ perseverance: {
172
+ Bitcoin: validateBitcoinTestnetAddress,
173
+ Ethereum: validateEvmAddress,
174
+ Polkadot: validatePolkadotAddress,
175
+ Arbitrum: validateEvmAddress,
176
+ Solana: validateSolanaAddress,
177
+ Assethub: validatePolkadotAddress
178
+ },
179
+ sisyphos: {
180
+ Bitcoin: validateBitcoinTestnetAddress,
181
+ Ethereum: validateEvmAddress,
182
+ Polkadot: validatePolkadotAddress,
183
+ Arbitrum: validateEvmAddress,
184
+ Solana: validateSolanaAddress,
185
+ Assethub: validatePolkadotAddress
186
+ },
187
+ backspin: {
188
+ Bitcoin: validateBitcoinRegtestAddress,
189
+ Ethereum: validateEvmAddress,
190
+ Polkadot: validatePolkadotAddress,
191
+ Arbitrum: validateEvmAddress,
192
+ Solana: validateSolanaAddress,
193
+ Assethub: validatePolkadotAddress
194
+ },
195
+ localnet: {
196
+ Bitcoin: validateBitcoinRegtestAddress,
197
+ Ethereum: validateEvmAddress,
198
+ Polkadot: validatePolkadotAddress,
199
+ Arbitrum: validateEvmAddress,
200
+ Solana: validateSolanaAddress,
201
+ Assethub: validatePolkadotAddress
202
+ }
203
+ };
204
+ var validateAddress = (chain2, address, network) => validators[network][chain2](address);
256
205
 
257
206
  // ../shared/src/broker.ts
258
207
  var transformedFokSchema = z.object({
259
- retryDurationBlocks: number,
208
+ retryDurationBlocks: z.number(),
260
209
  refundAddress: z.string(),
261
210
  minPriceX128: numericString
262
211
  }).transform(({ retryDurationBlocks, refundAddress, minPriceX128 }) => ({
@@ -368,7 +317,7 @@ var getParameterEncodingRequestSchema = (network) => z.object({
368
317
  }
369
318
  return { ...data, extraParams };
370
319
  });
371
- async function requestSwapDepositAddress(request, opts, chainflipNetwork2) {
320
+ async function requestSwapDepositAddress(request, opts, chainflipNetwork) {
372
321
  const client = new HttpClient(opts.url);
373
322
  if (request.srcChain && typeof request.srcAsset === "string") {
374
323
  request = { ...request, srcAsset: { asset: request.srcAsset, chain: request.srcChain } };
@@ -376,7 +325,7 @@ async function requestSwapDepositAddress(request, opts, chainflipNetwork2) {
376
325
  if (request.destChain && typeof request.destAsset === "string") {
377
326
  request = { ...request, destAsset: { asset: request.destAsset, chain: request.destChain } };
378
327
  }
379
- const params = getDepositAddressRequestSchema(chainflipNetwork2).parse(request);
328
+ const params = getDepositAddressRequestSchema(chainflipNetwork).parse(request);
380
329
  const response = await client.sendRequest(
381
330
  "broker_request_swap_deposit_address",
382
331
  params.srcAsset,
@@ -390,13 +339,13 @@ async function requestSwapDepositAddress(request, opts, chainflipNetwork2) {
390
339
  params.dcaParams
391
340
  );
392
341
  if (params.srcAsset.chain === "Polkadot" && isHex(response.address)) {
393
- response.address = ss582.encode({ data: response.address, ss58Format: DOT_PREFIX });
342
+ response.address = ss58.encode({ data: response.address, ss58Format: DOT_PREFIX });
394
343
  }
395
344
  return transformKeysToCamelCase(response);
396
345
  }
397
- async function requestSwapParameterEncoding(request, opts, chainflipNetwork2) {
346
+ async function requestSwapParameterEncoding(request, opts, chainflipNetwork) {
398
347
  const client = new HttpClient(opts.url);
399
- const params = getParameterEncodingRequestSchema(chainflipNetwork2).parse(request);
348
+ const params = getParameterEncodingRequestSchema(chainflipNetwork).parse(request);
400
349
  const response = await client.sendRequest(
401
350
  "broker_request_swap_parameter_encoding",
402
351
  params.srcAsset,
@@ -413,74 +362,25 @@ async function requestSwapParameterEncoding(request, opts, chainflipNetwork2) {
413
362
  }
414
363
 
415
364
  // ../shared/src/dataStructures.ts
416
- var Timer = class {
417
- constructor(value, cb, ms) {
418
- this.value = value;
419
- this.cb = cb;
420
- this.ms = ms;
421
- this.reset(true);
422
- }
423
- timeout;
424
- reset(resetExpiryOnLookup) {
425
- if (resetExpiryOnLookup) {
426
- this.clear();
427
- this.timeout = setTimeout(this.cb, this.ms);
428
- }
429
- return this;
430
- }
431
- getValue(resetExpiryOnLookup) {
432
- return this.reset(resetExpiryOnLookup).value;
433
- }
434
- clear() {
435
- if (this.timeout) clearTimeout(this.timeout);
436
- }
437
- };
438
- var CacheMap = class {
439
- constructor(ttl, resetExpiryOnLookup = true) {
440
- this.ttl = ttl;
441
- this.resetExpiryOnLookup = resetExpiryOnLookup;
442
- }
443
- store = /* @__PURE__ */ new Map();
444
- set(key, value) {
445
- this.delete(key);
446
- const timer = new Timer(value, () => this.store.delete(key), this.ttl);
447
- this.store.set(key, timer);
448
- return this;
449
- }
450
- get(key) {
451
- return this.store.get(key)?.getValue(this.resetExpiryOnLookup);
452
- }
453
- delete(key) {
454
- this.store.get(key)?.clear();
455
- return this.store.delete(key);
456
- }
457
- };
458
- var AsyncCacheMap = class extends CacheMap {
459
- fetch;
460
- constructor({
461
- fetch,
462
- ttl,
463
- resetExpiryOnLookup = true
464
- }) {
465
- super(ttl, resetExpiryOnLookup);
466
- this.fetch = fetch;
467
- }
468
- get(key) {
469
- let promise = super.get(key);
470
- if (!promise) {
471
- promise = this.fetch(key).catch((err) => {
472
- this.delete(key);
473
- throw err;
474
- });
475
- this.set(key, promise);
365
+ var Cache = class {
366
+ constructor(fetchers) {
367
+ this.fetchers = fetchers;
368
+ }
369
+ values = {};
370
+ read(type) {
371
+ const { fetch, ttl } = this.fetchers[type];
372
+ let cached = this.values[type];
373
+ if (!cached || cached.timestamp + ttl < Date.now()) {
374
+ cached = {
375
+ timestamp: Date.now(),
376
+ value: fetch().catch((err) => {
377
+ this.values[type] = void 0;
378
+ throw err;
379
+ })
380
+ };
381
+ this.values[type] = cached;
476
382
  }
477
- return promise;
478
- }
479
- load(key) {
480
- return this.get(key).then(
481
- () => true,
482
- () => false
483
- );
383
+ return cached.value;
484
384
  }
485
385
  };
486
386
  var getPriceX128FromPrice = (price, srcAsset, destAsset) => BigNumber2(price).multipliedBy(new BigNumber2(2).pow(128)).shiftedBy(assetConstants[destAsset].decimals - assetConstants[srcAsset].decimals).toFixed(0);
@@ -514,18 +414,17 @@ var parseFoKParams = (params, quote) => {
514
414
  minPriceX128: getPriceX128FromPrice(minPrice, srcAsset, destAsset)
515
415
  };
516
416
  };
517
-
518
- // ../shared/src/rpc/utils.ts
417
+ var isTestnet = (network) => network !== "mainnet";
519
418
  var MAX_SWAP_AMOUNT = 2n ** 128n - 1n;
520
419
  var validateSwapAmount = (env, asset2, amount) => {
521
- const minimumAmount = readChainAssetValue(env.ingressEgress.minimumDepositAmounts, asset2);
420
+ const minimumAmount = readAssetValue(env.ingressEgress.minimumDepositAmounts, asset2);
522
421
  if (amount < minimumAmount) {
523
422
  return {
524
423
  success: false,
525
424
  reason: `expected amount is below minimum swap amount (${minimumAmount})`
526
425
  };
527
426
  }
528
- const maxAmount = readChainAssetValue(env.swapping.maximumSwapAmounts, asset2) ?? MAX_SWAP_AMOUNT;
427
+ const maxAmount = readAssetValue(env.swapping.maximumSwapAmounts, asset2) ?? MAX_SWAP_AMOUNT;
529
428
  if (maxAmount != null && amount > maxAmount) {
530
429
  return {
531
430
  success: false,
@@ -541,31 +440,43 @@ var getTokenContractAddress = (asset2, network) => {
541
440
  case "Eth":
542
441
  case "ArbEth":
543
442
  case "Sol":
443
+ case "HubDot":
444
+ case "HubUsdc":
445
+ case "HubUsdt":
544
446
  return void 0;
545
447
  default:
546
448
  return ADDRESSES[network][`${toUpperCase(asset2)}_CONTRACT_ADDRESS`];
547
449
  }
548
450
  };
451
+ var assetNames = {
452
+ Eth: "Ether",
453
+ Flip: "FLIP",
454
+ Usdc: "USDC",
455
+ Usdt: "USDT",
456
+ Dot: "Polkadot",
457
+ Btc: "Bitcoin",
458
+ ArbEth: "Arbitrum Ether",
459
+ ArbUsdc: "Arbitrum USDC",
460
+ Sol: "Solana",
461
+ SolUsdc: "Solana USDC",
462
+ HubDot: "Assethub DOT",
463
+ HubUsdc: "Assethub USDC",
464
+ HubUsdt: "Assethub USDT"
465
+ };
549
466
  var getAssetData = (asset2, network, env) => {
550
467
  const assetConstant = assetConstants[asset2];
551
468
  return {
552
469
  chainflipId: asset2,
553
- asset: assetConstant.asset,
470
+ asset: assetConstant.symbol,
554
471
  chain: assetConstant.chain,
555
472
  contractAddress: getTokenContractAddress(asset2, network),
556
473
  decimals: assetConstant.decimals,
557
- name: assetConstant.name,
558
- symbol: assetConstant.asset,
474
+ name: assetNames[asset2],
475
+ symbol: assetConstant.symbol,
559
476
  isMainnet: !isTestnet(network),
560
- minimumSwapAmount: readChainAssetValue(
561
- env.ingressEgress.minimumDepositAmounts,
562
- asset2
563
- ).toString(),
564
- maximumSwapAmount: readChainAssetValue(env.swapping.maximumSwapAmounts, asset2)?.toString() ?? null,
565
- minimumEgressAmount: readChainAssetValue(
566
- env.ingressEgress.minimumEgressAmounts,
567
- asset2
568
- ).toString()
477
+ minimumSwapAmount: readAssetValue(env.ingressEgress.minimumDepositAmounts, asset2).toString(),
478
+ maximumSwapAmount: readAssetValue(env.swapping.maximumSwapAmounts, asset2)?.toString() ?? null,
479
+ minimumEgressAmount: readAssetValue(env.ingressEgress.minimumEgressAmounts, asset2).toString()
569
480
  };
570
481
  };
571
482
 
@@ -576,46 +487,19 @@ var getChainData = (chain2, network, env) => ({
576
487
  evmChainId: getEvmChainId(chain2, network),
577
488
  isMainnet: !isTestnet(network),
578
489
  requiredBlockConfirmations: isNotNullish(env.ingressEgress.witnessSafetyMargins[chain2]) ? Number(env.ingressEgress.witnessSafetyMargins[chain2]) + 1 : void 0,
579
- maxRetryDurationBlocks: env.ingressEgress.maxSwapRetryDurationBlocks[chain2]
490
+ maxRetryDurationBlocks: env.swapping.maxSwapRetryDurationBlocks
580
491
  });
581
492
 
582
493
  // package.json
583
- var version = "1.8.4-beta.0";
494
+ var version = "1.9.0-beta.0";
584
495
 
585
496
  // src/swap/consts.ts
586
497
  var CF_SDK_VERSION_HEADERS = { "X-Chainflip-Sdk-Version": version };
587
498
  var BACKEND_SERVICE_URLS = {
588
- [ChainflipNetworks.backspin]: "https://chainflip-swap-backspin.staging/",
589
- [ChainflipNetworks.sisyphos]: "https://chainflip-swap.staging/",
590
- [ChainflipNetworks.perseverance]: "https://chainflip-swap-perseverance.chainflip.io/",
591
- [ChainflipNetworks.mainnet]: "https://chainflip-swap.chainflip.io/"
592
- };
593
- var getQuote = async (baseUrl, quoteRequest, { signal }) => {
594
- const affiliateCommissionBps = quoteRequest.affiliateBrokers?.reduce((acc, affiliate) => acc + affiliate.commissionBps, 0) ?? 0;
595
- const totalBrokerCommissionBps = (quoteRequest.brokerCommissionBps ?? 0) + affiliateCommissionBps;
596
- const params = {
597
- amount: quoteRequest.amount,
598
- srcChain: quoteRequest.srcChain,
599
- srcAsset: quoteRequest.srcAsset,
600
- destChain: quoteRequest.destChain,
601
- destAsset: quoteRequest.destAsset,
602
- isVaultSwap: String(Boolean(quoteRequest.isVaultSwap)),
603
- ...totalBrokerCommissionBps && {
604
- brokerCommissionBps: String(totalBrokerCommissionBps)
605
- },
606
- ...quoteRequest.ccmParams && {
607
- ccmGasBudget: quoteRequest.ccmParams.gasBudget,
608
- ccmMessageLengthBytes: String(quoteRequest.ccmParams.messageLengthBytes)
609
- },
610
- dcaEnabled: "false"
611
- };
612
- const { data } = await axios.get("/quote", {
613
- baseURL: baseUrl,
614
- params,
615
- signal,
616
- headers: CF_SDK_VERSION_HEADERS
617
- });
618
- return { ...quoteRequest, quote: data };
499
+ backspin: "https://chainflip-swap-backspin.staging/",
500
+ sisyphos: "https://chainflip-swap.staging/",
501
+ perseverance: "https://chainflip-swap-perseverance.chainflip.io/",
502
+ mainnet: "https://chainflip-swap.chainflip.io/"
619
503
  };
620
504
  var getQuoteV2 = async (baseUrl, quoteRequest, { signal }) => {
621
505
  const affiliateCommissionBps = quoteRequest.affiliateBrokers?.reduce((acc, affiliate) => acc + affiliate.commissionBps, 0) ?? 0;
@@ -644,14 +528,6 @@ var getQuoteV2 = async (baseUrl, quoteRequest, { signal }) => {
644
528
  });
645
529
  return { ...quoteRequest, quotes: data };
646
530
  };
647
- var getStatus = async (baseUrl, { id }, { signal }) => {
648
- const { data } = await axios.get(`/swaps/${id}`, {
649
- baseURL: baseUrl,
650
- signal,
651
- headers: CF_SDK_VERSION_HEADERS
652
- });
653
- return data;
654
- };
655
531
  var getStatusV2 = async (baseUrl, { id }, { signal }) => {
656
532
  const { data } = await axios.get(`/v2/swaps/${id}`, {
657
533
  baseURL: baseUrl,
@@ -677,11 +553,10 @@ var SwapSDK = class {
677
553
  options;
678
554
  rpcConfig;
679
555
  trpc;
680
- stateChainEnvironmentCache;
681
- supportedAssets;
556
+ cache;
682
557
  dcaEnabled = false;
683
558
  constructor(options = {}) {
684
- const network = options.network ?? ChainflipNetworks.perseverance;
559
+ const network = options.network ?? "perseverance";
685
560
  this.options = {
686
561
  ...options,
687
562
  network,
@@ -698,55 +573,47 @@ var SwapSDK = class {
698
573
  ]
699
574
  });
700
575
  this.dcaEnabled = options.enabledFeatures?.dca ?? false;
701
- this.stateChainEnvironmentCache = new AsyncCacheMap({
702
- fetch: (_key) => getEnvironment(this.rpcConfig),
703
- ttl: 6e4 * 10,
704
- resetExpiryOnLookup: false
576
+ this.cache = new Cache({
577
+ environment: {
578
+ fetch: () => getEnvironment(this.rpcConfig),
579
+ ttl: 6e4
580
+ },
581
+ networkStatus: {
582
+ fetch: () => this.trpc.networkStatus.query(),
583
+ ttl: 6e4
584
+ }
705
585
  });
706
586
  }
707
- async getChains(sourceChain) {
708
- if (sourceChain && !(sourceChain in Chains))
587
+ async getChains(sourceChain, type = "all") {
588
+ if (sourceChain && !chainflipChains.includes(sourceChain)) {
709
589
  throw new Error(`unsupported source chain "${sourceChain}"`);
590
+ }
710
591
  const [env, supportedAssets] = await Promise.all([
711
592
  this.getStateChainEnvironment(),
712
- this.getSupportedAssets()
593
+ this.getSupportedAssets(type)
713
594
  ]);
714
- const supportedChains = [...new Set(supportedAssets.map((a) => assetConstants[a].chain))];
715
- return supportedChains.map((chain2) => getChainData(chain2, this.options.network, env)).filter((chain2) => chain2.chain !== sourceChain);
595
+ const supportedChains = new Set(supportedAssets.map((a) => assetConstants[a].chain));
596
+ if (sourceChain && !supportedChains.has(sourceChain)) return [];
597
+ return [...supportedChains].map((chain2) => getChainData(chain2, this.options.network, env)).filter((chain2) => chain2.chain !== sourceChain);
716
598
  }
717
599
  async getStateChainEnvironment() {
718
- return this.stateChainEnvironmentCache.get("cf_environment");
600
+ return this.cache.read("environment");
719
601
  }
720
- async getSupportedAssets() {
721
- this.supportedAssets ??= (await getSupportedAssets(this.rpcConfig)).map((asset2) => getInternalAsset(asset2, false)).filter(isNotNullish);
722
- return this.supportedAssets;
602
+ async getSupportedAssets(type) {
603
+ const assets = await this.cache.read("networkStatus");
604
+ return assets.assets[type];
723
605
  }
724
606
  async getBoostPoolsDepth() {
725
607
  return getAllBoostPoolsDepth(this.rpcConfig);
726
608
  }
727
- async getAssets(chain2) {
728
- if (chain2 && !(chain2 in Chains)) throw new Error(`unsupported chain "${chain2}"`);
609
+ async getAssets(chain2, type = "all") {
610
+ if (chain2 && !chainflipChains.includes(chain2)) throw new Error(`unsupported chain "${chain2}"`);
729
611
  const [env, supportedAssets] = await Promise.all([
730
612
  this.getStateChainEnvironment(),
731
- this.getSupportedAssets()
613
+ this.getSupportedAssets(type)
732
614
  ]);
733
615
  return supportedAssets.map((asset2) => getAssetData(asset2, this.options.network, env)).filter((asset2) => !chain2 || asset2.chain === chain2);
734
616
  }
735
- /** @deprecated DEPRECATED(1.7) use getQuoteV2() */
736
- getQuote(quoteRequest, options = {}) {
737
- console.error(
738
- "[@chainflip/sdk] The getQuote method is deprecated and will be removed in the 1.9 release. Use the getQuoteV2 method instead."
739
- );
740
- const submitterBrokerCommissionBps = quoteRequest.brokerCommissionBps ?? this.options.broker?.commissionBps ?? 0;
741
- return getQuote(
742
- this.options.backendUrl,
743
- {
744
- ...quoteRequest,
745
- brokerCommissionBps: submitterBrokerCommissionBps
746
- },
747
- options
748
- );
749
- }
750
617
  getQuoteV2(quoteRequest, options = {}) {
751
618
  const submitterBrokerCommissionBps = quoteRequest.brokerCommissionBps ?? this.options.broker?.commissionBps ?? 0;
752
619
  return getQuoteV2(
@@ -759,83 +626,6 @@ var SwapSDK = class {
759
626
  options
760
627
  );
761
628
  }
762
- /** @deprecated DEPRECATED(1.7) use requestDepositAddressV2() */
763
- async requestDepositAddress(depositAddressRequest) {
764
- console.error(
765
- "[@chainflip/sdk] The requestDepositAddress method is deprecated and will be removed in the 1.9 release. Use the requestDepositAddressV2 method instead."
766
- );
767
- const {
768
- srcChain,
769
- srcAsset,
770
- amount,
771
- destChain,
772
- destAsset,
773
- brokerCommissionBps,
774
- affiliateBrokers
775
- } = depositAddressRequest;
776
- await this.validateSwapAmount({ chain: srcChain, asset: srcAsset }, BigInt(amount));
777
- const fillOrKillParams2 = {
778
- ...depositAddressRequest.fillOrKillParams,
779
- minPriceX128: getPriceX128FromPrice(
780
- depositAddressRequest.fillOrKillParams.minPrice,
781
- getInternalAsset({ chain: srcChain, asset: srcAsset }),
782
- getInternalAsset({ chain: destChain, asset: destAsset })
783
- )
784
- };
785
- let response;
786
- if (this.options.broker) {
787
- const result = await requestSwapDepositAddress(
788
- {
789
- ...depositAddressRequest,
790
- commissionBps: brokerCommissionBps ?? this.options.broker.commissionBps,
791
- affiliates: affiliateBrokers,
792
- fillOrKillParams: fillOrKillParams2
793
- },
794
- { url: this.options.broker.url },
795
- this.options.network
796
- );
797
- response = {
798
- id: `${result.issuedBlock}-${depositAddressRequest.srcChain}-${result.channelId}`,
799
- depositAddress: result.address,
800
- brokerCommissionBps: brokerCommissionBps ?? this.options.broker.commissionBps ?? 0,
801
- srcChainExpiryBlock: result.sourceChainExpiryBlock,
802
- maxBoostFeeBps: depositAddressRequest.maxBoostFeeBps,
803
- channelOpeningFee: result.channelOpeningFee
804
- };
805
- } else {
806
- assert(
807
- !depositAddressRequest.brokerCommissionBps,
808
- "Broker commission is supported only when initializing the SDK with a brokerUrl"
809
- );
810
- assert(
811
- !depositAddressRequest.affiliateBrokers?.length,
812
- "Affiliate brokers are supported only when initializing the SDK with a brokerUrl"
813
- );
814
- assert(fillOrKillParams2, "Fill or kill parameters are required");
815
- response = await this.trpc.openSwapDepositChannel.mutate({
816
- ...depositAddressRequest,
817
- fillOrKillParams: fillOrKillParams2
818
- });
819
- }
820
- return {
821
- ...depositAddressRequest,
822
- depositChannelId: response.id,
823
- depositAddress: response.depositAddress,
824
- brokerCommissionBps: response.brokerCommissionBps,
825
- affiliateBrokers: depositAddressRequest.affiliateBrokers ?? [],
826
- maxBoostFeeBps: Number(response.maxBoostFeeBps) || 0,
827
- depositChannelExpiryBlock: response.srcChainExpiryBlock,
828
- estimatedDepositChannelExpiryTime: response.estimatedExpiryTime,
829
- channelOpeningFee: response.channelOpeningFee
830
- };
831
- }
832
- /** @deprecated DEPRECATED(1.7) use getStatusV2() */
833
- getStatus(swapStatusRequest, options = {}) {
834
- console.error(
835
- "[@chainflip/sdk] The getStatus method is deprecated and will be removed in the 1.9 release. Use the getStatusV2 method instead."
836
- );
837
- return getStatus(this.options.backendUrl, swapStatusRequest, options);
838
- }
839
629
  getStatusV2(swapStatusRequest, options = {}) {
840
630
  return getStatusV2(this.options.backendUrl, swapStatusRequest, options);
841
631
  }
@@ -856,7 +646,7 @@ var SwapSDK = class {
856
646
  const {
857
647
  ingressEgress: { witnessSafetyMargins }
858
648
  } = await this.getStateChainEnvironment();
859
- return Object.keys(Chains).reduce(
649
+ return chainflipChains.reduce(
860
650
  (acc, chain2) => {
861
651
  acc[chain2] = witnessSafetyMargins[chain2] ? Number(witnessSafetyMargins[chain2]) + 1 : null;
862
652
  return acc;
@@ -883,7 +673,7 @@ var SwapSDK = class {
883
673
  return poolsDepth.map((depth) => ({
884
674
  availableAmount: depth.availableAmount,
885
675
  feeTierBps: depth.tier,
886
- ...getAssetAndChain(depth.asset)
676
+ ...internalAssetToRpcAsset[depth.asset]
887
677
  }));
888
678
  }
889
679
  async requestDepositAddressV2({
@@ -993,7 +783,7 @@ var SwapSDK = class {
993
783
  dcaParams: quote.type === "DCA" ? quote.dcaParams : void 0,
994
784
  extraParams,
995
785
  brokerAccount,
996
- brokerCommissionBps,
786
+ commissionBps: brokerCommissionBps,
997
787
  affiliates
998
788
  };
999
789
  if (this.options.broker) {
@@ -1004,14 +794,14 @@ var SwapSDK = class {
1004
794
  return requestSwapParameterEncoding(
1005
795
  {
1006
796
  ...vaultSwapRequest,
1007
- commissionBps: vaultSwapRequest.brokerCommissionBps ?? this.options.broker.commissionBps
797
+ commissionBps: vaultSwapRequest.commissionBps ?? this.options.broker.commissionBps
1008
798
  },
1009
799
  { url: this.options.broker.url },
1010
800
  this.options.network
1011
801
  );
1012
802
  }
1013
803
  assert(
1014
- !vaultSwapRequest.brokerCommissionBps || vaultSwapRequest.brokerAccount,
804
+ !vaultSwapRequest.commissionBps || vaultSwapRequest.brokerAccount,
1015
805
  "Broker commission is supported only when setting a broker account"
1016
806
  );
1017
807
  assert(
@@ -1020,6 +810,15 @@ var SwapSDK = class {
1020
810
  );
1021
811
  return this.trpc.encodeVaultSwapData.mutate(vaultSwapRequest);
1022
812
  }
813
+ async checkBoostEnabled() {
814
+ const { boostDepositsEnabled } = await this.cache.read("networkStatus");
815
+ return boostDepositsEnabled;
816
+ }
1023
817
  };
818
+ var arrayToMap = (array) => Object.fromEntries(array.map((item) => [item, item]));
819
+ var ChainflipNetworks = arrayToMap(chainflipNetworks);
820
+ var InternalAssets = arrayToMap(chainflipAssets);
821
+ var Chains = arrayToMap(chainflipChains);
822
+ var Assets = arrayToMap(assetSymbols);
1024
823
 
1025
- export { SwapSDK };
824
+ export { Assets, InternalAssets as ChainflipIds, ChainflipNetworks, Chains, SwapSDK };