@chainflip/sdk 2.3.2 → 2.3.3

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.js CHANGED
@@ -1,24 +1,41 @@
1
- import { getEnvironment, assert, getEvmChainId, getAllSupplyPoolsDepth, getAllBoostPoolsDepth, SUPPLY_POOL_BOOST_FEE_BPS, isNotNullish, ADDRESSES } from './chunk-6KPGKVRC.js';
1
+ import { getEnvironment, getEvmChainId, getAllSupplyPoolsDepth, getAllBoostPoolsDepth, SUPPLY_POOL_BOOST_FEE_BPS, assert, isNotNullish, ADDRESSES } from './chunk-6KPGKVRC.js';
2
2
  import { unreachable } from '@chainflip/utils/assertion';
3
- import { chainflipChains, assetSymbols, isValidAssetAndChain, chainflipAssets, getInternalAssets, assetConstants, isChainflipAsset, internalAssetToRpcAsset, getInternalAsset, chainflipNetworks, readAssetValue, anyAssetConstants } from '@chainflip/utils/chainflip';
3
+ import { chainflipChains, assetSymbols, isValidAssetAndChain, getInternalAssets, assetConstants, isChainflipAsset, internalAssetToRpcAsset, getInternalAsset, chainflipNetworks, chainflipAssets, readAssetValue, anyAssetConstants } from '@chainflip/utils/chainflip';
4
4
  export { getInternalAsset as getChainflipId } from '@chainflip/utils/chainflip';
5
5
  import { calculateTotalEffectiveBorrowableAmount, ppmToBps } from '@chainflip/utils/lending';
6
- import { initContract, initClient } from '@ts-rest/core';
7
- import z3, { z } from 'zod';
8
- import { isValidSolanaAddress } from '@chainflip/solana';
9
- import * as ss58 from '@chainflip/utils/ss58';
10
- import { isValidTronAddress } from '@chainflip/utils/tron';
11
- import * as bitcoin from '@chainflip/bitcoin';
12
- import { toUpperCase, isHex } from '@chainflip/utils/string';
13
- import * as ethers from 'ethers';
14
- import { hexEncodeNumber } from '@chainflip/utils/number';
15
6
  import { HttpClient } from '@chainflip/rpc';
16
7
  import { bytesToHex } from '@chainflip/utils/bytes';
8
+ import * as ss58 from '@chainflip/utils/ss58';
9
+ import { toUpperCase, isHex } from '@chainflip/utils/string';
17
10
  import { priceX128ToPrice } from '@chainflip/utils/tickMath';
18
11
  import BigNumber2 from 'bignumber.js';
12
+ import { z } from 'zod';
13
+ import { isValidSolanaAddress } from '@chainflip/solana';
14
+ import { isValidTronAddress } from '@chainflip/utils/tron';
15
+ import { hexEncodeNumber } from '@chainflip/utils/number';
16
+ import * as bitcoin from '@chainflip/bitcoin';
17
+ import * as ethers from 'ethers';
19
18
  import { CHAINFLIP_BLOCK_TIME_SECONDS } from '@chainflip/utils/consts';
20
19
  import axios from 'axios';
21
20
 
21
+ // ../shared/src/strings.ts
22
+ var toCamelCase = (str) => str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
23
+
24
+ // ../shared/src/objects.ts
25
+ var transformKeysToCamelCase = (obj) => {
26
+ if (Array.isArray(obj)) {
27
+ return obj.map(transformKeysToCamelCase);
28
+ }
29
+ if (obj !== null && typeof obj === "object") {
30
+ return Object.fromEntries(
31
+ Object.entries(obj).map(([key, value]) => [
32
+ toCamelCase(key),
33
+ transformKeysToCamelCase(value)
34
+ ])
35
+ );
36
+ }
37
+ return obj;
38
+ };
22
39
  var booleanString = z.string().regex(/^(true|false)$/i).transform((v) => v.toLowerCase() === "true");
23
40
  var numericString = z.string().regex(/^[0-9]+$/);
24
41
  var numericOrEmptyString = z.string().regex(/^[0-9]*$/);
@@ -38,16 +55,22 @@ var chainflipAddress = z.string().refine(
38
55
  return false;
39
56
  }
40
57
  },
41
- (address) => ({ message: `${address} is not a valid Chainflip address` })
58
+ { error: (issue) => `${issue.input} is not a valid Chainflip address` }
42
59
  );
43
- z.string().refine(isValidSolanaAddress, (address) => ({
44
- message: `${address} is not a valid Solana address`
45
- }));
46
- var tronAddress = z.string().refine(isValidTronAddress, (address) => ({
47
- message: `${address} is not a valid Tron address`
48
- }));
49
- var u128 = z.union([z.number(), numericString, hexString]).transform((arg) => BigInt(arg));
50
- var unsignedInteger = z.union([u128, z.number().transform((n) => BigInt(n))]);
60
+ z.string().refine(isValidSolanaAddress, {
61
+ error: (issue) => `${issue.input} is not a valid Solana address`
62
+ });
63
+ z.string().refine(isValidTronAddress, {
64
+ error: (issue) => `${issue.input} is not a valid Tron address`
65
+ });
66
+ var u16 = z.number().int().nonnegative().max(65535);
67
+ var u32 = z.number().int().nonnegative().max(4294967295);
68
+ var u128 = z.union([
69
+ z.number().int().nonnegative().safe(),
70
+ numericString,
71
+ hexString.refine((v) => v.length > 2, { message: "hex string must not be empty" })
72
+ ]).transform((arg) => BigInt(arg)).refine((n) => n < 2n ** 128n, { message: "must be less than 2^128" });
73
+ var unsignedInteger = u128;
51
74
  var chain = z.enum(chainflipChains);
52
75
  var asset = z.enum(assetSymbols);
53
76
  var uncheckedAssetAndChain = z.object({
@@ -55,175 +78,31 @@ var uncheckedAssetAndChain = z.object({
55
78
  chain: z.string()
56
79
  });
57
80
  var assetAndChain = uncheckedAssetAndChain.refine(
58
- (value) => isValidAssetAndChain(value)
81
+ (value) => chain.safeParse(value.chain).success && asset.safeParse(value.asset).success && isValidAssetAndChain(value)
59
82
  );
60
-
61
- // ../shared/src/api/encodeVaultSwapData.ts
62
- var EncodedVaultSwapData = z.discriminatedUnion("chain", [
63
- z.object({
64
- chain: z.literal("Bitcoin"),
65
- nulldataPayload: hexString,
66
- depositAddress: z.string()
67
- }),
68
- z.object({
69
- chain: z.enum(["Ethereum", "Arbitrum", "Bsc"]),
70
- value: z.string(),
71
- to: hexString,
72
- calldata: hexString,
73
- sourceTokenAddress: hexString.optional()
74
- }),
75
- z.object({
76
- chain: z.literal("Tron"),
77
- calldata: hexString,
78
- value: z.string(),
79
- to: tronAddress,
80
- note: hexString,
81
- sourceTokenAddress: tronAddress.optional()
82
- }),
83
- z.object({
84
- chain: z.literal("Solana"),
85
- programId: z.string(),
86
- data: hexString,
87
- accounts: z.array(
88
- z.object({
89
- pubkey: z.string(),
90
- isSigner: z.boolean(),
91
- isWritable: z.boolean()
92
- })
93
- )
94
- })
95
- ]);
96
- var NetworkInfo = z3.object({
97
- assets: z3.array(
98
- z3.object({
99
- asset: z3.enum(chainflipAssets),
100
- vaultSwapDepositsEnabled: z3.boolean(),
101
- depositChannelDepositsEnabled: z3.boolean(),
102
- depositChannelCreationEnabled: z3.boolean(),
103
- egressEnabled: z3.boolean(),
104
- boostDepositsEnabled: z3.boolean(),
105
- livePriceProtectionEnabled: z3.boolean()
106
- })
107
- ),
108
- cfBrokerCommissionBps: z3.number()
109
- });
110
- var validatePolkadotAddress = (address) => {
111
- if (isHex(address)) return address.length === 66;
112
- try {
113
- ss58.decode(address);
114
- return true;
115
- } catch {
116
- return false;
117
- }
118
- };
119
- var validateEvmAddress = (address) => ethers.isAddress(address);
120
- var validateBitcoinMainnetAddress = (address) => bitcoin.isValidAddressForNetwork(address, "mainnet");
121
- var validateBitcoinTestnetAddress = (address) => bitcoin.isValidAddressForNetwork(address, "testnet");
122
- var validateBitcoinRegtestAddress = (address) => bitcoin.isValidAddressForNetwork(address, "regtest");
123
- var validateSolanaAddress = isValidSolanaAddress;
124
- var validateTronAddress = isValidTronAddress;
125
- var validators = {
126
- mainnet: {
127
- Bitcoin: validateBitcoinMainnetAddress,
128
- Ethereum: validateEvmAddress,
129
- Arbitrum: validateEvmAddress,
130
- Solana: validateSolanaAddress,
131
- Assethub: validatePolkadotAddress,
132
- Tron: validateTronAddress,
133
- Bsc: validateEvmAddress
134
- },
135
- perseverance: {
136
- Bitcoin: validateBitcoinTestnetAddress,
137
- Ethereum: validateEvmAddress,
138
- Arbitrum: validateEvmAddress,
139
- Solana: validateSolanaAddress,
140
- Assethub: validatePolkadotAddress,
141
- Tron: validateTronAddress,
142
- Bsc: validateEvmAddress
143
- },
144
- sisyphos: {
145
- Bitcoin: validateBitcoinTestnetAddress,
146
- Ethereum: validateEvmAddress,
147
- Arbitrum: validateEvmAddress,
148
- Solana: validateSolanaAddress,
149
- Assethub: validatePolkadotAddress,
150
- Tron: validateTronAddress,
151
- Bsc: validateEvmAddress
152
- },
153
- backspin: {
154
- Bitcoin: validateBitcoinRegtestAddress,
155
- Ethereum: validateEvmAddress,
156
- Arbitrum: validateEvmAddress,
157
- Solana: validateSolanaAddress,
158
- Assethub: validatePolkadotAddress,
159
- Tron: validateTronAddress,
160
- Bsc: validateEvmAddress
161
- },
162
- localnet: {
163
- Bitcoin: validateBitcoinRegtestAddress,
164
- Ethereum: validateEvmAddress,
165
- Arbitrum: validateEvmAddress,
166
- Solana: validateSolanaAddress,
167
- Assethub: validatePolkadotAddress,
168
- Tron: validateTronAddress,
169
- Bsc: validateEvmAddress
170
- }
171
- };
172
- var validateAddress = (chain2, address, network) => validators[network][chain2](address);
173
-
174
- // ../shared/src/api/openAccountCreationDepositChannel.ts
175
- var getAccountCreationDepositChannelSchema = (network) => z.object({
176
- signatureData: z.object({
177
- Ethereum: z.object({
178
- signature: hexString,
179
- signer: hexString,
180
- sigType: z.literal("Eip712")
181
- }).transform(({ sigType, ...rest }) => ({
182
- sig_type: sigType,
183
- ...rest
184
- }))
185
- }),
186
- transactionMetadata: z.object({
187
- nonce: z.number().gte(0),
188
- expiryBlock: z.number().positive()
189
- }).transform(({ nonce, expiryBlock }) => ({
190
- nonce,
191
- expiry_block: expiryBlock
192
- })),
193
- asset: assetAndChain,
194
- refundAddress: z.string(),
195
- boostFeeBps: z.number().optional().default(0)
196
- }).superRefine(({ asset: asset2, refundAddress }, ctx) => {
197
- if (!validateAddress(asset2.chain, refundAddress, network)) {
198
- ctx.addIssue({
199
- message: `Address "${refundAddress}" is not a valid "${asset2.chain}" address for "${network}"`,
200
- code: z.ZodIssueCode.custom
201
- });
202
- }
203
- });
204
83
  z.object({
205
84
  srcChain: chain,
206
85
  srcAsset: asset,
207
86
  destChain: chain,
208
87
  destAsset: asset,
209
88
  amount: numericString.transform((v) => BigInt(v)).refine((v) => v > 0n, { message: "swap input amount must be greater than 0" }).refine((v) => v < 2n ** 128n, { message: "swap input amount must be less than 2^128" }),
210
- brokerCommissionBps: numericOrEmptyString.transform((v) => Number(v)).optional(),
89
+ brokerCommissionBps: numericOrEmptyString.transform((v) => Number(v)).pipe(u16).optional(),
211
90
  ccmGasBudget: z.union([
212
91
  numericString.transform((v) => BigInt(v)).refine((v) => v < 2n ** 128n, { message: "ccm gas budget must be less than 2^128" }),
213
92
  z.literal("undefined").transform(() => void 0)
214
93
  // sdk version 1.8.2 sends undefined string if not set
215
94
  ]).optional(),
216
95
  ccmMessageLengthBytes: z.union([
217
- numericString.transform((v) => Number(v)),
96
+ numericString.transform((v) => Number(v)).pipe(u32),
218
97
  z.literal("undefined").transform(() => void 0)
219
98
  // sdk version 1.8.2 sends undefined string if not set
220
99
  ]).optional(),
221
- dcaV2Enabled: booleanString.default("false"),
100
+ dcaV2Enabled: booleanString.prefault("false"),
222
101
  isVaultSwap: booleanString.optional(),
223
102
  isOnChain: booleanString.optional(),
224
103
  brokerAccount: chainflipAddress.optional(),
225
104
  brokerIdSs58: chainflipAddress.optional(),
226
- expectedResponseTimeMs: numericString.transform((v) => Number(v)).optional()
105
+ expectedResponseTimeMs: numericString.transform((v) => Number(v)).pipe(u32).optional()
227
106
  }).transform((args, ctx) => {
228
107
  const { srcAsset, destAsset } = getInternalAssets(args, false);
229
108
  let hadError = false;
@@ -304,91 +183,82 @@ var ccmParamsSchema = z.object({
304
183
  }));
305
184
  var affiliateBroker = z.object({
306
185
  account: chainflipAddress,
307
- commissionBps: z.number()
186
+ commissionBps: u16
308
187
  }).transform(({ account, commissionBps: bps }) => ({ account, bps }));
309
188
  var dcaParams = z.object({
310
- numberOfChunks: z.number(),
311
- chunkIntervalBlocks: z.number()
189
+ numberOfChunks: u32.min(1, { message: "number of chunks must be greater than 0" }),
190
+ chunkIntervalBlocks: u32
312
191
  });
313
- var fillOrKillParams = z.object({
314
- retryDurationBlocks: z.number(),
192
+ z.object({
193
+ retryDurationBlocks: u32,
315
194
  refundAddress: z.string(),
316
195
  minPriceX128: numericString,
317
196
  maxOraclePriceSlippage: basisPoints.nullish().transform((v) => v ?? null),
318
197
  refundCcmMetadata: ccmParamsSchema.nullish().optional().default(null)
319
198
  });
320
-
321
- // ../shared/src/api/openSwapDepositChannel.ts
322
- var assets = z.object({
323
- srcAsset: assetAndChain,
324
- destAsset: assetAndChain
325
- });
326
- var amountString = numericString.max(30, { message: "must have at most 30 digits" });
327
- var getOpenSwapDepositChannelSchema = (network) => z.intersection(
328
- assets,
329
- z.object({
330
- destAddress: z.string(),
331
- amount: amountString,
332
- ccmParams: ccmParamsSchema.optional(),
333
- maxBoostFeeBps: z.number().optional(),
334
- srcAddress: z.string().optional(),
335
- fillOrKillParams,
336
- dcaParams: dcaParams.optional(),
337
- quote: z.object({
338
- intermediateAmount: amountString.optional(),
339
- egressAmount: amountString,
340
- estimatedPrice: z.string().regex(/^[0-9]+(\.[0-9]+)?(e[+-]?[0-9]+)?$/i, { message: "must be a decimal number" }).refine((v) => Number(v) < 1e35, { message: "must be less than 10^35" }),
341
- recommendedSlippageTolerancePercent: z.number().optional(),
342
- recommendedLivePriceSlippageTolerancePercent: z.number().optional()
343
- }).optional(),
344
- takeCommission: z.boolean().optional()
345
- })
346
- ).superRefine(({ ...val }, ctx) => {
347
- if (!validateAddress(val.destAsset.chain, val.destAddress, network)) {
348
- ctx.addIssue({
349
- message: `Address "${val.destAddress}" is not a valid "${val.destAsset.chain}" address for "${network}"`,
350
- code: z.ZodIssueCode.custom
351
- });
352
- }
353
- if (!validateAddress(val.srcAsset.chain, val.fillOrKillParams.refundAddress, network)) {
354
- ctx.addIssue({
355
- message: `Address "${val.fillOrKillParams.refundAddress}" is not a valid "${val.srcAsset.chain}" address for "${network}"`,
356
- code: z.ZodIssueCode.custom
357
- });
358
- }
359
- }).transform(({ amount, ...rest }) => ({
360
- ...rest,
361
- expectedDepositAmount: amount
362
- }));
363
- var DepositChannelInfo = z.object({
364
- id: z.string(),
365
- depositAddress: z.string(),
366
- brokerCommissionBps: z.number(),
367
- maxBoostFeeBps: z.number(),
368
- issuedBlock: z.number(),
369
- srcChainExpiryBlock: z.string(),
370
- estimatedExpiryTime: z.number().optional(),
371
- channelOpeningFee: z.string()
372
- });
373
-
374
- // ../shared/src/strings.ts
375
- var toCamelCase = (str) => str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
376
-
377
- // ../shared/src/objects.ts
378
- var transformKeysToCamelCase = (obj) => {
379
- if (Array.isArray(obj)) {
380
- return obj.map(transformKeysToCamelCase);
199
+ var validatePolkadotAddress = (address) => {
200
+ if (isHex(address)) return address.length === 66;
201
+ try {
202
+ ss58.decode(address);
203
+ return true;
204
+ } catch {
205
+ return false;
381
206
  }
382
- if (obj !== null && typeof obj === "object") {
383
- return Object.fromEntries(
384
- Object.entries(obj).map(([key, value]) => [
385
- toCamelCase(key),
386
- transformKeysToCamelCase(value)
387
- ])
388
- );
207
+ };
208
+ var validateEvmAddress = (address) => ethers.isAddress(address);
209
+ var validateBitcoinMainnetAddress = (address) => bitcoin.isValidAddressForNetwork(address, "mainnet");
210
+ var validateBitcoinTestnetAddress = (address) => bitcoin.isValidAddressForNetwork(address, "testnet");
211
+ var validateBitcoinRegtestAddress = (address) => bitcoin.isValidAddressForNetwork(address, "regtest");
212
+ var validateSolanaAddress = isValidSolanaAddress;
213
+ var validateTronAddress = isValidTronAddress;
214
+ var validators = {
215
+ mainnet: {
216
+ Bitcoin: validateBitcoinMainnetAddress,
217
+ Ethereum: validateEvmAddress,
218
+ Arbitrum: validateEvmAddress,
219
+ Solana: validateSolanaAddress,
220
+ Assethub: validatePolkadotAddress,
221
+ Tron: validateTronAddress,
222
+ Bsc: validateEvmAddress
223
+ },
224
+ perseverance: {
225
+ Bitcoin: validateBitcoinTestnetAddress,
226
+ Ethereum: validateEvmAddress,
227
+ Arbitrum: validateEvmAddress,
228
+ Solana: validateSolanaAddress,
229
+ Assethub: validatePolkadotAddress,
230
+ Tron: validateTronAddress,
231
+ Bsc: validateEvmAddress
232
+ },
233
+ sisyphos: {
234
+ Bitcoin: validateBitcoinTestnetAddress,
235
+ Ethereum: validateEvmAddress,
236
+ Arbitrum: validateEvmAddress,
237
+ Solana: validateSolanaAddress,
238
+ Assethub: validatePolkadotAddress,
239
+ Tron: validateTronAddress,
240
+ Bsc: validateEvmAddress
241
+ },
242
+ backspin: {
243
+ Bitcoin: validateBitcoinRegtestAddress,
244
+ Ethereum: validateEvmAddress,
245
+ Arbitrum: validateEvmAddress,
246
+ Solana: validateSolanaAddress,
247
+ Assethub: validatePolkadotAddress,
248
+ Tron: validateTronAddress,
249
+ Bsc: validateEvmAddress
250
+ },
251
+ localnet: {
252
+ Bitcoin: validateBitcoinRegtestAddress,
253
+ Ethereum: validateEvmAddress,
254
+ Arbitrum: validateEvmAddress,
255
+ Solana: validateSolanaAddress,
256
+ Assethub: validatePolkadotAddress,
257
+ Tron: validateTronAddress,
258
+ Bsc: validateEvmAddress
389
259
  }
390
- return obj;
391
260
  };
261
+ var validateAddress = (chain2, address, network) => Object.hasOwn(validators, network) && Object.hasOwn(validators[network], chain2) && validators[network][chain2](address);
392
262
 
393
263
  // ../shared/src/broker.ts
394
264
  var transformedDcaParamsSchema = dcaParams.transform(
@@ -405,7 +275,7 @@ var transformedCcmParamsSchema = ccmParamsSchema.transform(
405
275
  })
406
276
  );
407
277
  var transformedFokSchema = z.object({
408
- retryDurationBlocks: z.number(),
278
+ retryDurationBlocks: u32,
409
279
  refundAddress: z.string(),
410
280
  minPriceX128: numericString,
411
281
  maxOraclePriceSlippage: basisPoints.nullish().transform((v) => v ?? null),
@@ -429,9 +299,9 @@ var getDepositAddressRequestSchema = (network) => z.object({
429
299
  srcAsset: assetAndChain,
430
300
  destAsset: assetAndChain,
431
301
  destAddress: z.string(),
432
- commissionBps: z.number().optional().default(0),
302
+ commissionBps: u16.optional().default(0),
433
303
  ccmParams: transformedCcmParamsSchema.optional(),
434
- maxBoostFeeBps: z.number().optional(),
304
+ maxBoostFeeBps: u16.optional(),
435
305
  affiliates: z.array(affiliateBroker).optional(),
436
306
  fillOrKillParams: transformedFokSchema,
437
307
  dcaParams: transformedDcaParamsSchema.optional()
@@ -455,9 +325,9 @@ var getVaultSwapParameterEncodingRequestSchema = (network) => z.object({
455
325
  destAsset: assetAndChain,
456
326
  destAddress: z.string(),
457
327
  amount: unsignedInteger,
458
- commissionBps: z.number().optional().default(0),
328
+ commissionBps: u16.optional().default(0),
459
329
  ccmParams: transformedCcmParamsSchema.optional(),
460
- maxBoostFeeBps: z.number().optional(),
330
+ maxBoostFeeBps: u16.optional(),
461
331
  affiliates: z.array(affiliateBroker).optional(),
462
332
  fillOrKillParams: transformedFokSchema,
463
333
  dcaParams: transformedDcaParamsSchema.optional(),
@@ -485,7 +355,7 @@ var getVaultSwapParameterEncodingRequestSchema = (network) => z.object({
485
355
  if (val.extraParams?.seed && val.extraParams.seed.length !== 66) {
486
356
  ctx.addIssue({ message: "Seed must be 32 bytes", code: z.ZodIssueCode.custom });
487
357
  }
488
- }).transform((data) => {
358
+ }).transform((data, ctx) => {
489
359
  let extraParams;
490
360
  if (data.srcAsset.chain === "Bitcoin") {
491
361
  const minOutputAmount = BigNumber2(data.amount.toString()).multipliedBy(priceX128ToPrice(data.fillOrKillParams.min_price)).toFixed(0);
@@ -502,7 +372,13 @@ var getVaultSwapParameterEncodingRequestSchema = (network) => z.object({
502
372
  refund_parameters: data.fillOrKillParams
503
373
  };
504
374
  } else if (data.srcAsset.chain === "Solana") {
505
- assert(data.srcAddress, "srcAddress is required for Solana");
375
+ if (!data.srcAddress) {
376
+ ctx.addIssue({
377
+ message: "srcAddress is required for Solana",
378
+ code: z.ZodIssueCode.custom
379
+ });
380
+ return z.NEVER;
381
+ }
506
382
  extraParams = {
507
383
  chain: "Solana",
508
384
  from: data.srcAddress,
@@ -511,7 +387,11 @@ var getVaultSwapParameterEncodingRequestSchema = (network) => z.object({
511
387
  refund_parameters: data.fillOrKillParams
512
388
  };
513
389
  } else {
514
- throw new Error(`parameter encoding is not supported for ${data.srcAsset.chain}`);
390
+ ctx.addIssue({
391
+ message: `parameter encoding is not supported for ${data.srcAsset.chain}`,
392
+ code: z.ZodIssueCode.custom
393
+ });
394
+ return z.NEVER;
515
395
  }
516
396
  return { ...data, extraParams };
517
397
  });
@@ -571,9 +451,9 @@ var getParameterEncodingRequestSchema = (network) => z.object({
571
451
  destAsset: assetAndChain,
572
452
  destAddress: z.string(),
573
453
  amount: unsignedInteger,
574
- commissionBps: z.number().optional().default(0),
454
+ commissionBps: u16.optional().default(0),
575
455
  ccmParams: transformedCcmParamsSchema.optional(),
576
- maxBoostFeeBps: z.number().optional(),
456
+ maxBoostFeeBps: u16.optional(),
577
457
  affiliates: z.array(affiliateBroker).optional(),
578
458
  fillOrKillParams: transformedFokSchema,
579
459
  dcaParams: transformedDcaParamsSchema.optional(),
@@ -615,68 +495,18 @@ async function requestCfParametersEncoding(request, opts, network) {
615
495
  );
616
496
  return response;
617
497
  }
618
-
619
- // ../shared/src/api/contract.ts
620
- var c = initContract();
621
- var createApiContract = (network) => c.router(
622
- {
623
- networkInfo: {
624
- method: "GET",
625
- path: "/networkInfo",
626
- responses: {
627
- 200: NetworkInfo
628
- },
629
- summary: "Get information about the Chainflip network"
630
- },
631
- encodeCfParameters: {
632
- method: "POST",
633
- path: "/encodeCfParameters",
634
- body: getParameterEncodingRequestSchema(network),
635
- responses: {
636
- 200: hexString
637
- }
638
- },
639
- encodeVaultSwapData: {
640
- method: "POST",
641
- path: "/encodeVaultSwapData",
642
- body: getVaultSwapParameterEncodingRequestSchema(network),
643
- responses: {
644
- 200: EncodedVaultSwapData
645
- }
646
- },
647
- openSwapDepositChannel: {
648
- method: "POST",
649
- path: "/openSwapDepositChannel",
650
- body: getOpenSwapDepositChannelSchema(network),
651
- responses: {
652
- 201: DepositChannelInfo
653
- }
654
- },
655
- openAccountCreationDepositChannel: {
656
- method: "POST",
657
- path: "/openAccountCreationDepositChannel",
658
- body: getAccountCreationDepositChannelSchema(network),
659
- responses: {
660
- 201: DepositChannelInfo
661
- }
662
- }
663
- },
664
- {
665
- pathPrefix: "/api"
666
- }
667
- );
668
498
  var MultiCache = class {
669
499
  constructor(fetchers) {
670
500
  this.fetchers = fetchers;
671
501
  }
672
502
  values = {};
673
503
  read(type) {
674
- const { fetch, ttl } = this.fetchers[type];
504
+ const { fetch: fetch2, ttl } = this.fetchers[type];
675
505
  let cached = this.values[type];
676
506
  if (!cached || cached.timestamp + ttl < Date.now()) {
677
507
  cached = {
678
508
  timestamp: Date.now(),
679
- value: fetch().catch((err) => {
509
+ value: fetch2().catch((err) => {
680
510
  this.values[type] = void 0;
681
511
  throw err;
682
512
  })
@@ -824,7 +654,7 @@ var getChainData = (chain2, network, env) => ({
824
654
 
825
655
  // package.json
826
656
  var package_default = {
827
- version: "2.3.2"};
657
+ version: "2.3.3"};
828
658
 
829
659
  // src/swap/consts.ts
830
660
  var CF_SDK_VERSION_HEADERS = { "X-Chainflip-Sdk-Version": package_default.version };
@@ -872,6 +702,59 @@ var getStatusV2 = async (baseUrl, { id }, { signal }) => {
872
702
  });
873
703
  return data;
874
704
  };
705
+ var lowercaseKeys = (headers) => Object.fromEntries(Object.entries(headers).map(([key, value]) => [key.toLowerCase(), value]));
706
+ var backendRequest = async (baseUrl, method, path, body) => {
707
+ const headers = lowercaseKeys(CF_SDK_VERSION_HEADERS);
708
+ let serializedBody;
709
+ if (method !== "GET" && body != null) {
710
+ headers["content-type"] = "application/json";
711
+ serializedBody = JSON.stringify(body);
712
+ }
713
+ const res = await fetch(`${baseUrl.replace(/\/+$/, "")}${path}`, {
714
+ method,
715
+ headers,
716
+ body: serializedBody
717
+ });
718
+ const contentType = res.headers.get("content-type") ?? "";
719
+ if (contentType.includes("application/") && contentType.includes("json")) {
720
+ return { status: res.status, body: await res.json(), headers: res.headers };
721
+ }
722
+ if (contentType.includes("text/")) {
723
+ return { status: res.status, body: await res.text(), headers: res.headers };
724
+ }
725
+ return { status: res.status, body: await res.blob(), headers: res.headers };
726
+ };
727
+ var getNetworkInfo = async (baseUrl) => {
728
+ const res = await backendRequest(baseUrl, "GET", "/api/networkInfo");
729
+ assert(res.status === 200, "Failed to fetch network info");
730
+ return res.body;
731
+ };
732
+ var openSwapDepositChannel = async (baseUrl, body) => {
733
+ const res = await backendRequest(baseUrl, "POST", "/api/openSwapDepositChannel", body);
734
+ assert(res.status === 201, "Failed to open swap deposit channel");
735
+ return res.body;
736
+ };
737
+ var encodeVaultSwapData = async (baseUrl, body) => {
738
+ const res = await backendRequest(baseUrl, "POST", "/api/encodeVaultSwapData", body);
739
+ if (res.status !== 200) {
740
+ throw new Error("Failed to encode vault swap data", { cause: res });
741
+ }
742
+ return res.body;
743
+ };
744
+ var encodeCfParameters = async (baseUrl, body) => {
745
+ const res = await backendRequest(baseUrl, "POST", "/api/encodeCfParameters", body);
746
+ if (res.status !== 200) {
747
+ throw new Error("Failed to encode cf parameters", { cause: res });
748
+ }
749
+ return res.body;
750
+ };
751
+ var openAccountCreationDepositChannel = async (baseUrl, body) => {
752
+ const res = await backendRequest(baseUrl, "POST", "/api/openAccountCreationDepositChannel", body);
753
+ if (res.status !== 201) {
754
+ throw new Error("Failed to request account creation deposit channel", { cause: res });
755
+ }
756
+ return res.body;
757
+ };
875
758
 
876
759
  // src/swap/sdk.ts
877
760
  var assertQuoteValid = (quote) => {
@@ -888,7 +771,6 @@ var assertQuoteValid = (quote) => {
888
771
  var SwapSDK = class {
889
772
  options;
890
773
  rpcConfig;
891
- apiClient;
892
774
  cache;
893
775
  dcaV2Enabled = false;
894
776
  constructor(options = {}) {
@@ -899,12 +781,6 @@ var SwapSDK = class {
899
781
  backendUrl: options.backendUrl ?? BACKEND_SERVICE_URLS[network]
900
782
  };
901
783
  this.rpcConfig = options.rpcUrl ? { rpcUrl: options.rpcUrl } : { network };
902
- this.apiClient = initClient(createApiContract(this.options.network), {
903
- // remove trailing slashes. this bug has been fixed in `@ts-rest/core`
904
- // but it hasn't been released yet
905
- baseUrl: this.options.backendUrl.replace(/\/+$/, ""),
906
- baseHeaders: CF_SDK_VERSION_HEADERS
907
- });
908
784
  this.dcaV2Enabled = options.enabledFeatures?.dcaV2 ?? false;
909
785
  this.cache = new MultiCache({
910
786
  environment: {
@@ -912,11 +788,7 @@ var SwapSDK = class {
912
788
  ttl: 6e4
913
789
  },
914
790
  networkInfo: {
915
- fetch: async () => {
916
- const res = await this.apiClient.networkInfo();
917
- assert(res.status === 200, "Failed to fetch network info");
918
- return res.body;
919
- },
791
+ fetch: () => getNetworkInfo(this.options.backendUrl),
920
792
  ttl: 6e4
921
793
  }
922
794
  });
@@ -937,8 +809,8 @@ var SwapSDK = class {
937
809
  return this.cache.read("environment");
938
810
  }
939
811
  async getSupportedAssets(type) {
940
- const assets2 = await this.cache.read("networkInfo");
941
- return assets2.assets.filter((a) => isChainflipAsset(a.asset)).filter((a) => {
812
+ const assets = await this.cache.read("networkInfo");
813
+ return assets.assets.filter((a) => isChainflipAsset(a.asset)).filter((a) => {
942
814
  switch (type) {
943
815
  case "all":
944
816
  return true;
@@ -1120,15 +992,11 @@ var SwapSDK = class {
1120
992
  !affiliates?.length,
1121
993
  "Affiliate brokers are supported only when initializing the SDK with a brokerUrl"
1122
994
  );
1123
- const res = await this.apiClient.openSwapDepositChannel({
1124
- body: {
1125
- ...depositAddressRequest,
1126
- quote,
1127
- takeCommission: this.shouldTakeCommission()
1128
- }
995
+ response = await openSwapDepositChannel(this.options.backendUrl, {
996
+ ...depositAddressRequest,
997
+ quote,
998
+ takeCommission: this.shouldTakeCommission()
1129
999
  });
1130
- assert(res.status === 201, "Failed to open swap deposit channel");
1131
- response = res.body;
1132
1000
  }
1133
1001
  return {
1134
1002
  ...depositAddressRequest,
@@ -1201,18 +1069,15 @@ var SwapSDK = class {
1201
1069
  !vaultSwapRequest.affiliates?.length || vaultSwapRequest.brokerAccount,
1202
1070
  "Affiliate brokers are supported only when setting a broker account"
1203
1071
  );
1204
- const res = await this.apiClient.encodeVaultSwapData({ body: vaultSwapRequest });
1205
- if (res.status !== 200) {
1206
- throw new Error("Failed to encode vault swap data", { cause: res });
1207
- }
1208
- switch (res.body.chain) {
1072
+ const body = await encodeVaultSwapData(this.options.backendUrl, vaultSwapRequest);
1073
+ switch (body.chain) {
1209
1074
  case "Arbitrum":
1210
1075
  case "Ethereum":
1211
1076
  case "Tron":
1212
1077
  case "Bsc":
1213
- return { ...res.body, value: BigInt(res.body.value) };
1078
+ return { ...body, value: BigInt(body.value) };
1214
1079
  default:
1215
- return res.body;
1080
+ return body;
1216
1081
  }
1217
1082
  }
1218
1083
  async encodeCfParameters({
@@ -1264,32 +1129,23 @@ var SwapSDK = class {
1264
1129
  !requestParams.affiliates?.length || brokerAccount,
1265
1130
  "Affiliate brokers are supported only when setting a broker account"
1266
1131
  );
1267
- const res = await this.apiClient.encodeCfParameters({
1268
- body: { ...requestParams, brokerAccount }
1132
+ return encodeCfParameters(this.options.backendUrl, {
1133
+ ...requestParams,
1134
+ brokerAccount
1269
1135
  });
1270
- if (res.status !== 200) {
1271
- throw new Error("Failed to encode cf parameters", { cause: res });
1272
- }
1273
- return res.body;
1274
1136
  }
1275
1137
  async checkBoostEnabled() {
1276
- const { assets: assets2 } = await this.cache.read("networkInfo");
1277
- return assets2.find((a) => a.asset === "Btc")?.boostDepositsEnabled ?? true;
1138
+ const { assets } = await this.cache.read("networkInfo");
1139
+ return assets.find((a) => a.asset === "Btc")?.boostDepositsEnabled ?? true;
1278
1140
  }
1279
1141
  async requestAccountCreationDepositAddress(asset2, refundAddress, signatureData, transactionMetadata, boostFeeBps = 0) {
1280
- const res = await this.apiClient.openAccountCreationDepositChannel({
1281
- body: {
1282
- asset: internalAssetToRpcAsset[asset2],
1283
- refundAddress,
1284
- signatureData,
1285
- transactionMetadata,
1286
- boostFeeBps
1287
- }
1142
+ return openAccountCreationDepositChannel(this.options.backendUrl, {
1143
+ asset: internalAssetToRpcAsset[asset2],
1144
+ refundAddress,
1145
+ signatureData,
1146
+ transactionMetadata,
1147
+ boostFeeBps
1288
1148
  });
1289
- if (res.status !== 201) {
1290
- throw new Error("Failed to request account creation deposit channel", { cause: res });
1291
- }
1292
- return res.body;
1293
1149
  }
1294
1150
  };
1295
1151
  var arrayToMap = (array) => Object.fromEntries(array.map((item) => [item, item]));