@chainflip/sdk 2.3.1 → 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]*$/);
@@ -29,17 +46,31 @@ var hexStringWithMaxByteSize = (maxByteSize) => hexString.refine((val) => val.le
29
46
  var basisPoints = z.number().int({ message: "must be in basis points" });
30
47
  var DOT_PREFIX = 0;
31
48
  var chainflipAddress = z.string().refine(
32
- (address) => address.startsWith("cF") && ss58.decode(address),
33
- (address) => ({ message: `${address} is not a valid Chainflip address` })
49
+ (address) => {
50
+ if (!address.startsWith("cF")) return false;
51
+ try {
52
+ ss58.decode(address);
53
+ return true;
54
+ } catch {
55
+ return false;
56
+ }
57
+ },
58
+ { error: (issue) => `${issue.input} is not a valid Chainflip address` }
34
59
  );
35
- z.string().refine(isValidSolanaAddress, (address) => ({
36
- message: `${address} is not a valid Solana address`
37
- }));
38
- var tronAddress = z.string().refine(isValidTronAddress, (address) => ({
39
- message: `${address} is not a valid Tron address`
40
- }));
41
- var u128 = z.union([z.number(), numericString, hexString]).transform((arg) => BigInt(arg));
42
- 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;
43
74
  var chain = z.enum(chainflipChains);
44
75
  var asset = z.enum(assetSymbols);
45
76
  var uncheckedAssetAndChain = z.object({
@@ -47,175 +78,31 @@ var uncheckedAssetAndChain = z.object({
47
78
  chain: z.string()
48
79
  });
49
80
  var assetAndChain = uncheckedAssetAndChain.refine(
50
- (value) => isValidAssetAndChain(value)
81
+ (value) => chain.safeParse(value.chain).success && asset.safeParse(value.asset).success && isValidAssetAndChain(value)
51
82
  );
52
-
53
- // ../shared/src/api/encodeVaultSwapData.ts
54
- var EncodedVaultSwapData = z.discriminatedUnion("chain", [
55
- z.object({
56
- chain: z.literal("Bitcoin"),
57
- nulldataPayload: hexString,
58
- depositAddress: z.string()
59
- }),
60
- z.object({
61
- chain: z.enum(["Ethereum", "Arbitrum", "Bsc"]),
62
- value: z.string(),
63
- to: hexString,
64
- calldata: hexString,
65
- sourceTokenAddress: hexString.optional()
66
- }),
67
- z.object({
68
- chain: z.literal("Tron"),
69
- calldata: hexString,
70
- value: z.string(),
71
- to: tronAddress,
72
- note: hexString,
73
- sourceTokenAddress: tronAddress.optional()
74
- }),
75
- z.object({
76
- chain: z.literal("Solana"),
77
- programId: z.string(),
78
- data: hexString,
79
- accounts: z.array(
80
- z.object({
81
- pubkey: z.string(),
82
- isSigner: z.boolean(),
83
- isWritable: z.boolean()
84
- })
85
- )
86
- })
87
- ]);
88
- var NetworkInfo = z3.object({
89
- assets: z3.array(
90
- z3.object({
91
- asset: z3.enum(chainflipAssets),
92
- vaultSwapDepositsEnabled: z3.boolean(),
93
- depositChannelDepositsEnabled: z3.boolean(),
94
- depositChannelCreationEnabled: z3.boolean(),
95
- egressEnabled: z3.boolean(),
96
- boostDepositsEnabled: z3.boolean(),
97
- livePriceProtectionEnabled: z3.boolean()
98
- })
99
- ),
100
- cfBrokerCommissionBps: z3.number()
101
- });
102
- var validatePolkadotAddress = (address) => {
103
- if (isHex(address)) return address.length === 66;
104
- try {
105
- ss58.decode(address);
106
- return true;
107
- } catch {
108
- return false;
109
- }
110
- };
111
- var validateEvmAddress = (address) => ethers.isAddress(address);
112
- var validateBitcoinMainnetAddress = (address) => bitcoin.isValidAddressForNetwork(address, "mainnet");
113
- var validateBitcoinTestnetAddress = (address) => bitcoin.isValidAddressForNetwork(address, "testnet");
114
- var validateBitcoinRegtestAddress = (address) => bitcoin.isValidAddressForNetwork(address, "regtest");
115
- var validateSolanaAddress = isValidSolanaAddress;
116
- var validateTronAddress = isValidTronAddress;
117
- var validators = {
118
- mainnet: {
119
- Bitcoin: validateBitcoinMainnetAddress,
120
- Ethereum: validateEvmAddress,
121
- Arbitrum: validateEvmAddress,
122
- Solana: validateSolanaAddress,
123
- Assethub: validatePolkadotAddress,
124
- Tron: validateTronAddress,
125
- Bsc: validateEvmAddress
126
- },
127
- perseverance: {
128
- Bitcoin: validateBitcoinTestnetAddress,
129
- Ethereum: validateEvmAddress,
130
- Arbitrum: validateEvmAddress,
131
- Solana: validateSolanaAddress,
132
- Assethub: validatePolkadotAddress,
133
- Tron: validateTronAddress,
134
- Bsc: validateEvmAddress
135
- },
136
- sisyphos: {
137
- Bitcoin: validateBitcoinTestnetAddress,
138
- Ethereum: validateEvmAddress,
139
- Arbitrum: validateEvmAddress,
140
- Solana: validateSolanaAddress,
141
- Assethub: validatePolkadotAddress,
142
- Tron: validateTronAddress,
143
- Bsc: validateEvmAddress
144
- },
145
- backspin: {
146
- Bitcoin: validateBitcoinRegtestAddress,
147
- Ethereum: validateEvmAddress,
148
- Arbitrum: validateEvmAddress,
149
- Solana: validateSolanaAddress,
150
- Assethub: validatePolkadotAddress,
151
- Tron: validateTronAddress,
152
- Bsc: validateEvmAddress
153
- },
154
- localnet: {
155
- Bitcoin: validateBitcoinRegtestAddress,
156
- Ethereum: validateEvmAddress,
157
- Arbitrum: validateEvmAddress,
158
- Solana: validateSolanaAddress,
159
- Assethub: validatePolkadotAddress,
160
- Tron: validateTronAddress,
161
- Bsc: validateEvmAddress
162
- }
163
- };
164
- var validateAddress = (chain2, address, network) => validators[network][chain2](address);
165
-
166
- // ../shared/src/api/openAccountCreationDepositChannel.ts
167
- var getAccountCreationDepositChannelSchema = (network) => z.object({
168
- signatureData: z.object({
169
- Ethereum: z.object({
170
- signature: hexString,
171
- signer: hexString,
172
- sigType: z.literal("Eip712")
173
- }).transform(({ sigType, ...rest }) => ({
174
- sig_type: sigType,
175
- ...rest
176
- }))
177
- }),
178
- transactionMetadata: z.object({
179
- nonce: z.number().gte(0),
180
- expiryBlock: z.number().positive()
181
- }).transform(({ nonce, expiryBlock }) => ({
182
- nonce,
183
- expiry_block: expiryBlock
184
- })),
185
- asset: assetAndChain,
186
- refundAddress: z.string(),
187
- boostFeeBps: z.number().optional().default(0)
188
- }).superRefine(({ asset: asset2, refundAddress }, ctx) => {
189
- if (!validateAddress(asset2.chain, refundAddress, network)) {
190
- ctx.addIssue({
191
- message: `Address "${refundAddress}" is not a valid "${asset2.chain}" address for "${network}"`,
192
- code: z.ZodIssueCode.custom
193
- });
194
- }
195
- });
196
83
  z.object({
197
84
  srcChain: chain,
198
85
  srcAsset: asset,
199
86
  destChain: chain,
200
87
  destAsset: asset,
201
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" }),
202
- brokerCommissionBps: numericOrEmptyString.transform((v) => Number(v)).optional(),
89
+ brokerCommissionBps: numericOrEmptyString.transform((v) => Number(v)).pipe(u16).optional(),
203
90
  ccmGasBudget: z.union([
204
- numericString.transform((v) => BigInt(v)),
91
+ numericString.transform((v) => BigInt(v)).refine((v) => v < 2n ** 128n, { message: "ccm gas budget must be less than 2^128" }),
205
92
  z.literal("undefined").transform(() => void 0)
206
93
  // sdk version 1.8.2 sends undefined string if not set
207
94
  ]).optional(),
208
95
  ccmMessageLengthBytes: z.union([
209
- numericString.transform((v) => Number(v)),
96
+ numericString.transform((v) => Number(v)).pipe(u32),
210
97
  z.literal("undefined").transform(() => void 0)
211
98
  // sdk version 1.8.2 sends undefined string if not set
212
99
  ]).optional(),
213
- dcaV2Enabled: booleanString.default("false"),
100
+ dcaV2Enabled: booleanString.prefault("false"),
214
101
  isVaultSwap: booleanString.optional(),
215
102
  isOnChain: booleanString.optional(),
216
103
  brokerAccount: chainflipAddress.optional(),
217
104
  brokerIdSs58: chainflipAddress.optional(),
218
- expectedResponseTimeMs: numericString.transform((v) => Number(v)).optional()
105
+ expectedResponseTimeMs: numericString.transform((v) => Number(v)).pipe(u32).optional()
219
106
  }).transform((args, ctx) => {
220
107
  const { srcAsset, destAsset } = getInternalAssets(args, false);
221
108
  let hadError = false;
@@ -284,7 +171,7 @@ z.object({
284
171
  };
285
172
  });
286
173
  var ccmParamsSchema = z.object({
287
- gasBudget: z.union([numericString, hexString]).transform((n) => hexEncodeNumber(BigInt(n))),
174
+ gasBudget: z.union([numericString, hexString]).transform((n) => BigInt(n)).refine((n) => n < 2n ** 128n, { message: "ccm gas budget must be less than 2^128" }).transform((n) => hexEncodeNumber(n)),
288
175
  // https://github.com/chainflip-io/chainflip-backend/blob/415aa9e20ec4046c68892cd34798e5d831c5b83f/state-chain/chains/src/lib.rs#L709
289
176
  message: hexStringWithMaxByteSize(15e3),
290
177
  // https://github.com/chainflip-io/chainflip-backend/blob/415aa9e20ec4046c68892cd34798e5d831c5b83f/state-chain/chains/src/lib.rs#L710
@@ -296,90 +183,82 @@ var ccmParamsSchema = z.object({
296
183
  }));
297
184
  var affiliateBroker = z.object({
298
185
  account: chainflipAddress,
299
- commissionBps: z.number()
186
+ commissionBps: u16
300
187
  }).transform(({ account, commissionBps: bps }) => ({ account, bps }));
301
188
  var dcaParams = z.object({
302
- numberOfChunks: z.number(),
303
- chunkIntervalBlocks: z.number()
189
+ numberOfChunks: u32.min(1, { message: "number of chunks must be greater than 0" }),
190
+ chunkIntervalBlocks: u32
304
191
  });
305
- var fillOrKillParams = z.object({
306
- retryDurationBlocks: z.number(),
192
+ z.object({
193
+ retryDurationBlocks: u32,
307
194
  refundAddress: z.string(),
308
195
  minPriceX128: numericString,
309
196
  maxOraclePriceSlippage: basisPoints.nullish().transform((v) => v ?? null),
310
197
  refundCcmMetadata: ccmParamsSchema.nullish().optional().default(null)
311
198
  });
312
-
313
- // ../shared/src/api/openSwapDepositChannel.ts
314
- var assets = z.object({
315
- srcAsset: assetAndChain,
316
- destAsset: assetAndChain
317
- });
318
- var getOpenSwapDepositChannelSchema = (network) => z.intersection(
319
- assets,
320
- z.object({
321
- destAddress: z.string(),
322
- amount: numericString,
323
- ccmParams: ccmParamsSchema.optional(),
324
- maxBoostFeeBps: z.number().optional(),
325
- srcAddress: z.string().optional(),
326
- fillOrKillParams,
327
- dcaParams: dcaParams.optional(),
328
- quote: z.object({
329
- intermediateAmount: z.string().optional(),
330
- egressAmount: z.string(),
331
- estimatedPrice: z.string(),
332
- recommendedSlippageTolerancePercent: z.number().optional(),
333
- recommendedLivePriceSlippageTolerancePercent: z.number().optional()
334
- }).optional(),
335
- takeCommission: z.boolean().optional()
336
- })
337
- ).superRefine(({ ...val }, ctx) => {
338
- if (!validateAddress(val.destAsset.chain, val.destAddress, network)) {
339
- ctx.addIssue({
340
- message: `Address "${val.destAddress}" is not a valid "${val.destAsset.chain}" address for "${network}"`,
341
- code: z.ZodIssueCode.custom
342
- });
343
- }
344
- if (!validateAddress(val.srcAsset.chain, val.fillOrKillParams.refundAddress, network)) {
345
- ctx.addIssue({
346
- message: `Address "${val.fillOrKillParams.refundAddress}" is not a valid "${val.srcAsset.chain}" address for "${network}"`,
347
- code: z.ZodIssueCode.custom
348
- });
349
- }
350
- }).transform(({ amount, ...rest }) => ({
351
- ...rest,
352
- expectedDepositAmount: amount
353
- }));
354
- var DepositChannelInfo = z.object({
355
- id: z.string(),
356
- depositAddress: z.string(),
357
- brokerCommissionBps: z.number(),
358
- maxBoostFeeBps: z.number(),
359
- issuedBlock: z.number(),
360
- srcChainExpiryBlock: z.string(),
361
- estimatedExpiryTime: z.number().optional(),
362
- channelOpeningFee: z.string()
363
- });
364
-
365
- // ../shared/src/strings.ts
366
- var toCamelCase = (str) => str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
367
-
368
- // ../shared/src/objects.ts
369
- var transformKeysToCamelCase = (obj) => {
370
- if (Array.isArray(obj)) {
371
- 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;
372
206
  }
373
- if (obj !== null && typeof obj === "object") {
374
- return Object.fromEntries(
375
- Object.entries(obj).map(([key, value]) => [
376
- toCamelCase(key),
377
- transformKeysToCamelCase(value)
378
- ])
379
- );
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
380
259
  }
381
- return obj;
382
260
  };
261
+ var validateAddress = (chain2, address, network) => Object.hasOwn(validators, network) && Object.hasOwn(validators[network], chain2) && validators[network][chain2](address);
383
262
 
384
263
  // ../shared/src/broker.ts
385
264
  var transformedDcaParamsSchema = dcaParams.transform(
@@ -396,7 +275,7 @@ var transformedCcmParamsSchema = ccmParamsSchema.transform(
396
275
  })
397
276
  );
398
277
  var transformedFokSchema = z.object({
399
- retryDurationBlocks: z.number(),
278
+ retryDurationBlocks: u32,
400
279
  refundAddress: z.string(),
401
280
  minPriceX128: numericString,
402
281
  maxOraclePriceSlippage: basisPoints.nullish().transform((v) => v ?? null),
@@ -420,9 +299,9 @@ var getDepositAddressRequestSchema = (network) => z.object({
420
299
  srcAsset: assetAndChain,
421
300
  destAsset: assetAndChain,
422
301
  destAddress: z.string(),
423
- commissionBps: z.number().optional().default(0),
302
+ commissionBps: u16.optional().default(0),
424
303
  ccmParams: transformedCcmParamsSchema.optional(),
425
- maxBoostFeeBps: z.number().optional(),
304
+ maxBoostFeeBps: u16.optional(),
426
305
  affiliates: z.array(affiliateBroker).optional(),
427
306
  fillOrKillParams: transformedFokSchema,
428
307
  dcaParams: transformedDcaParamsSchema.optional()
@@ -446,9 +325,9 @@ var getVaultSwapParameterEncodingRequestSchema = (network) => z.object({
446
325
  destAsset: assetAndChain,
447
326
  destAddress: z.string(),
448
327
  amount: unsignedInteger,
449
- commissionBps: z.number().optional().default(0),
328
+ commissionBps: u16.optional().default(0),
450
329
  ccmParams: transformedCcmParamsSchema.optional(),
451
- maxBoostFeeBps: z.number().optional(),
330
+ maxBoostFeeBps: u16.optional(),
452
331
  affiliates: z.array(affiliateBroker).optional(),
453
332
  fillOrKillParams: transformedFokSchema,
454
333
  dcaParams: transformedDcaParamsSchema.optional(),
@@ -476,7 +355,7 @@ var getVaultSwapParameterEncodingRequestSchema = (network) => z.object({
476
355
  if (val.extraParams?.seed && val.extraParams.seed.length !== 66) {
477
356
  ctx.addIssue({ message: "Seed must be 32 bytes", code: z.ZodIssueCode.custom });
478
357
  }
479
- }).transform((data) => {
358
+ }).transform((data, ctx) => {
480
359
  let extraParams;
481
360
  if (data.srcAsset.chain === "Bitcoin") {
482
361
  const minOutputAmount = BigNumber2(data.amount.toString()).multipliedBy(priceX128ToPrice(data.fillOrKillParams.min_price)).toFixed(0);
@@ -493,7 +372,13 @@ var getVaultSwapParameterEncodingRequestSchema = (network) => z.object({
493
372
  refund_parameters: data.fillOrKillParams
494
373
  };
495
374
  } else if (data.srcAsset.chain === "Solana") {
496
- 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
+ }
497
382
  extraParams = {
498
383
  chain: "Solana",
499
384
  from: data.srcAddress,
@@ -502,7 +387,11 @@ var getVaultSwapParameterEncodingRequestSchema = (network) => z.object({
502
387
  refund_parameters: data.fillOrKillParams
503
388
  };
504
389
  } else {
505
- 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;
506
395
  }
507
396
  return { ...data, extraParams };
508
397
  });
@@ -562,9 +451,9 @@ var getParameterEncodingRequestSchema = (network) => z.object({
562
451
  destAsset: assetAndChain,
563
452
  destAddress: z.string(),
564
453
  amount: unsignedInteger,
565
- commissionBps: z.number().optional().default(0),
454
+ commissionBps: u16.optional().default(0),
566
455
  ccmParams: transformedCcmParamsSchema.optional(),
567
- maxBoostFeeBps: z.number().optional(),
456
+ maxBoostFeeBps: u16.optional(),
568
457
  affiliates: z.array(affiliateBroker).optional(),
569
458
  fillOrKillParams: transformedFokSchema,
570
459
  dcaParams: transformedDcaParamsSchema.optional(),
@@ -606,68 +495,18 @@ async function requestCfParametersEncoding(request, opts, network) {
606
495
  );
607
496
  return response;
608
497
  }
609
-
610
- // ../shared/src/api/contract.ts
611
- var c = initContract();
612
- var createApiContract = (network) => c.router(
613
- {
614
- networkInfo: {
615
- method: "GET",
616
- path: "/networkInfo",
617
- responses: {
618
- 200: NetworkInfo
619
- },
620
- summary: "Get information about the Chainflip network"
621
- },
622
- encodeCfParameters: {
623
- method: "POST",
624
- path: "/encodeCfParameters",
625
- body: getParameterEncodingRequestSchema(network),
626
- responses: {
627
- 200: hexString
628
- }
629
- },
630
- encodeVaultSwapData: {
631
- method: "POST",
632
- path: "/encodeVaultSwapData",
633
- body: getVaultSwapParameterEncodingRequestSchema(network),
634
- responses: {
635
- 200: EncodedVaultSwapData
636
- }
637
- },
638
- openSwapDepositChannel: {
639
- method: "POST",
640
- path: "/openSwapDepositChannel",
641
- body: getOpenSwapDepositChannelSchema(network),
642
- responses: {
643
- 201: DepositChannelInfo
644
- }
645
- },
646
- openAccountCreationDepositChannel: {
647
- method: "POST",
648
- path: "/openAccountCreationDepositChannel",
649
- body: getAccountCreationDepositChannelSchema(network),
650
- responses: {
651
- 201: DepositChannelInfo
652
- }
653
- }
654
- },
655
- {
656
- pathPrefix: "/api"
657
- }
658
- );
659
498
  var MultiCache = class {
660
499
  constructor(fetchers) {
661
500
  this.fetchers = fetchers;
662
501
  }
663
502
  values = {};
664
503
  read(type) {
665
- const { fetch, ttl } = this.fetchers[type];
504
+ const { fetch: fetch2, ttl } = this.fetchers[type];
666
505
  let cached = this.values[type];
667
506
  if (!cached || cached.timestamp + ttl < Date.now()) {
668
507
  cached = {
669
508
  timestamp: Date.now(),
670
- value: fetch().catch((err) => {
509
+ value: fetch2().catch((err) => {
671
510
  this.values[type] = void 0;
672
511
  throw err;
673
512
  })
@@ -815,7 +654,7 @@ var getChainData = (chain2, network, env) => ({
815
654
 
816
655
  // package.json
817
656
  var package_default = {
818
- version: "2.3.1"};
657
+ version: "2.3.3"};
819
658
 
820
659
  // src/swap/consts.ts
821
660
  var CF_SDK_VERSION_HEADERS = { "X-Chainflip-Sdk-Version": package_default.version };
@@ -863,6 +702,59 @@ var getStatusV2 = async (baseUrl, { id }, { signal }) => {
863
702
  });
864
703
  return data;
865
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
+ };
866
758
 
867
759
  // src/swap/sdk.ts
868
760
  var assertQuoteValid = (quote) => {
@@ -879,7 +771,6 @@ var assertQuoteValid = (quote) => {
879
771
  var SwapSDK = class {
880
772
  options;
881
773
  rpcConfig;
882
- apiClient;
883
774
  cache;
884
775
  dcaV2Enabled = false;
885
776
  constructor(options = {}) {
@@ -890,12 +781,6 @@ var SwapSDK = class {
890
781
  backendUrl: options.backendUrl ?? BACKEND_SERVICE_URLS[network]
891
782
  };
892
783
  this.rpcConfig = options.rpcUrl ? { rpcUrl: options.rpcUrl } : { network };
893
- this.apiClient = initClient(createApiContract(this.options.network), {
894
- // remove trailing slashes. this bug has been fixed in `@ts-rest/core`
895
- // but it hasn't been released yet
896
- baseUrl: this.options.backendUrl.replace(/\/+$/, ""),
897
- baseHeaders: CF_SDK_VERSION_HEADERS
898
- });
899
784
  this.dcaV2Enabled = options.enabledFeatures?.dcaV2 ?? false;
900
785
  this.cache = new MultiCache({
901
786
  environment: {
@@ -903,11 +788,7 @@ var SwapSDK = class {
903
788
  ttl: 6e4
904
789
  },
905
790
  networkInfo: {
906
- fetch: async () => {
907
- const res = await this.apiClient.networkInfo();
908
- assert(res.status === 200, "Failed to fetch network info");
909
- return res.body;
910
- },
791
+ fetch: () => getNetworkInfo(this.options.backendUrl),
911
792
  ttl: 6e4
912
793
  }
913
794
  });
@@ -928,8 +809,8 @@ var SwapSDK = class {
928
809
  return this.cache.read("environment");
929
810
  }
930
811
  async getSupportedAssets(type) {
931
- const assets2 = await this.cache.read("networkInfo");
932
- 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) => {
933
814
  switch (type) {
934
815
  case "all":
935
816
  return true;
@@ -1111,15 +992,11 @@ var SwapSDK = class {
1111
992
  !affiliates?.length,
1112
993
  "Affiliate brokers are supported only when initializing the SDK with a brokerUrl"
1113
994
  );
1114
- const res = await this.apiClient.openSwapDepositChannel({
1115
- body: {
1116
- ...depositAddressRequest,
1117
- quote,
1118
- takeCommission: this.shouldTakeCommission()
1119
- }
995
+ response = await openSwapDepositChannel(this.options.backendUrl, {
996
+ ...depositAddressRequest,
997
+ quote,
998
+ takeCommission: this.shouldTakeCommission()
1120
999
  });
1121
- assert(res.status === 201, "Failed to open swap deposit channel");
1122
- response = res.body;
1123
1000
  }
1124
1001
  return {
1125
1002
  ...depositAddressRequest,
@@ -1192,18 +1069,15 @@ var SwapSDK = class {
1192
1069
  !vaultSwapRequest.affiliates?.length || vaultSwapRequest.brokerAccount,
1193
1070
  "Affiliate brokers are supported only when setting a broker account"
1194
1071
  );
1195
- const res = await this.apiClient.encodeVaultSwapData({ body: vaultSwapRequest });
1196
- if (res.status !== 200) {
1197
- throw new Error("Failed to encode vault swap data", { cause: res });
1198
- }
1199
- switch (res.body.chain) {
1072
+ const body = await encodeVaultSwapData(this.options.backendUrl, vaultSwapRequest);
1073
+ switch (body.chain) {
1200
1074
  case "Arbitrum":
1201
1075
  case "Ethereum":
1202
1076
  case "Tron":
1203
1077
  case "Bsc":
1204
- return { ...res.body, value: BigInt(res.body.value) };
1078
+ return { ...body, value: BigInt(body.value) };
1205
1079
  default:
1206
- return res.body;
1080
+ return body;
1207
1081
  }
1208
1082
  }
1209
1083
  async encodeCfParameters({
@@ -1255,32 +1129,23 @@ var SwapSDK = class {
1255
1129
  !requestParams.affiliates?.length || brokerAccount,
1256
1130
  "Affiliate brokers are supported only when setting a broker account"
1257
1131
  );
1258
- const res = await this.apiClient.encodeCfParameters({
1259
- body: { ...requestParams, brokerAccount }
1132
+ return encodeCfParameters(this.options.backendUrl, {
1133
+ ...requestParams,
1134
+ brokerAccount
1260
1135
  });
1261
- if (res.status !== 200) {
1262
- throw new Error("Failed to encode cf parameters", { cause: res });
1263
- }
1264
- return res.body;
1265
1136
  }
1266
1137
  async checkBoostEnabled() {
1267
- const { assets: assets2 } = await this.cache.read("networkInfo");
1268
- 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;
1269
1140
  }
1270
1141
  async requestAccountCreationDepositAddress(asset2, refundAddress, signatureData, transactionMetadata, boostFeeBps = 0) {
1271
- const res = await this.apiClient.openAccountCreationDepositChannel({
1272
- body: {
1273
- asset: internalAssetToRpcAsset[asset2],
1274
- refundAddress,
1275
- signatureData,
1276
- transactionMetadata,
1277
- boostFeeBps
1278
- }
1142
+ return openAccountCreationDepositChannel(this.options.backendUrl, {
1143
+ asset: internalAssetToRpcAsset[asset2],
1144
+ refundAddress,
1145
+ signatureData,
1146
+ transactionMetadata,
1147
+ boostFeeBps
1279
1148
  });
1280
- if (res.status !== 201) {
1281
- throw new Error("Failed to request account creation deposit channel", { cause: res });
1282
- }
1283
- return res.body;
1284
1149
  }
1285
1150
  };
1286
1151
  var arrayToMap = (array) => Object.fromEntries(array.map((item) => [item, item]));