@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.cjs CHANGED
@@ -3,19 +3,18 @@
3
3
  var assertion = require('@chainflip/utils/assertion');
4
4
  var chainflip = require('@chainflip/utils/chainflip');
5
5
  var lending = require('@chainflip/utils/lending');
6
- var core = require('@ts-rest/core');
7
- var z3 = require('zod');
8
- var solana = require('@chainflip/solana');
9
- var ss58 = require('@chainflip/utils/ss58');
10
- var tron = require('@chainflip/utils/tron');
11
- var bitcoin = require('@chainflip/bitcoin');
12
- var string = require('@chainflip/utils/string');
13
- var ethers = require('ethers');
14
- var number = require('@chainflip/utils/number');
15
6
  var rpc = require('@chainflip/rpc');
16
7
  var bytes = require('@chainflip/utils/bytes');
8
+ var ss58 = require('@chainflip/utils/ss58');
9
+ var string = require('@chainflip/utils/string');
17
10
  var tickMath = require('@chainflip/utils/tickMath');
18
11
  var BigNumber2 = require('bignumber.js');
12
+ var zod = require('zod');
13
+ var solana = require('@chainflip/solana');
14
+ var tron = require('@chainflip/utils/tron');
15
+ var number = require('@chainflip/utils/number');
16
+ var bitcoin = require('@chainflip/bitcoin');
17
+ var ethers = require('ethers');
19
18
  var consts = require('@chainflip/utils/consts');
20
19
  var axios = require('axios');
21
20
 
@@ -39,277 +38,152 @@ function _interopNamespace(e) {
39
38
  return Object.freeze(n);
40
39
  }
41
40
 
42
- var z3__default = /*#__PURE__*/_interopDefault(z3);
43
41
  var ss58__namespace = /*#__PURE__*/_interopNamespace(ss58);
42
+ var BigNumber2__default = /*#__PURE__*/_interopDefault(BigNumber2);
44
43
  var bitcoin__namespace = /*#__PURE__*/_interopNamespace(bitcoin);
45
44
  var ethers__namespace = /*#__PURE__*/_interopNamespace(ethers);
46
- var BigNumber2__default = /*#__PURE__*/_interopDefault(BigNumber2);
47
45
  var axios__default = /*#__PURE__*/_interopDefault(axios);
48
46
 
49
47
  // src/swap/sdk.ts
50
- var booleanString = z3.z.string().regex(/^(true|false)$/i).transform((v) => v.toLowerCase() === "true");
51
- var numericString = z3.z.string().regex(/^[0-9]+$/);
52
- var numericOrEmptyString = z3.z.string().regex(/^[0-9]*$/);
53
- var hexString = z3.z.string().refine((v) => /^0x[0-9a-f]*$/i.test(v));
48
+
49
+ // ../shared/src/strings.ts
50
+ var toCamelCase = (str) => str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
51
+
52
+ // ../shared/src/objects.ts
53
+ var transformKeysToCamelCase = (obj) => {
54
+ if (Array.isArray(obj)) {
55
+ return obj.map(transformKeysToCamelCase);
56
+ }
57
+ if (obj !== null && typeof obj === "object") {
58
+ return Object.fromEntries(
59
+ Object.entries(obj).map(([key, value]) => [
60
+ toCamelCase(key),
61
+ transformKeysToCamelCase(value)
62
+ ])
63
+ );
64
+ }
65
+ return obj;
66
+ };
67
+ var booleanString = zod.z.string().regex(/^(true|false)$/i).transform((v) => v.toLowerCase() === "true");
68
+ var numericString = zod.z.string().regex(/^[0-9]+$/);
69
+ var numericOrEmptyString = zod.z.string().regex(/^[0-9]*$/);
70
+ var hexString = zod.z.string().refine((v) => /^0x[0-9a-f]*$/i.test(v));
54
71
  var hexStringWithMaxByteSize = (maxByteSize) => hexString.refine((val) => val.length / 2 <= maxByteSize + 1, {
55
72
  message: `String must be less than or equal to ${maxByteSize} bytes`
56
73
  });
57
- var basisPoints = z3.z.number().int({ message: "must be in basis points" });
74
+ var basisPoints = zod.z.number().int({ message: "must be in basis points" });
58
75
  var DOT_PREFIX = 0;
59
- var chainflipAddress = z3.z.string().refine(
60
- (address) => address.startsWith("cF") && ss58__namespace.decode(address),
61
- (address) => ({ message: `${address} is not a valid Chainflip address` })
76
+ var chainflipAddress = zod.z.string().refine(
77
+ (address) => {
78
+ if (!address.startsWith("cF")) return false;
79
+ try {
80
+ ss58__namespace.decode(address);
81
+ return true;
82
+ } catch {
83
+ return false;
84
+ }
85
+ },
86
+ { error: (issue) => `${issue.input} is not a valid Chainflip address` }
62
87
  );
63
- z3.z.string().refine(solana.isValidSolanaAddress, (address) => ({
64
- message: `${address} is not a valid Solana address`
65
- }));
66
- var tronAddress = z3.z.string().refine(tron.isValidTronAddress, (address) => ({
67
- message: `${address} is not a valid Tron address`
68
- }));
69
- var u128 = z3.z.union([z3.z.number(), numericString, hexString]).transform((arg) => BigInt(arg));
70
- var unsignedInteger = z3.z.union([u128, z3.z.number().transform((n) => BigInt(n))]);
71
- var chain = z3.z.enum(chainflip.chainflipChains);
72
- var asset = z3.z.enum(chainflip.assetSymbols);
73
- var uncheckedAssetAndChain = z3.z.object({
74
- asset: z3.z.string(),
75
- chain: z3.z.string()
88
+ zod.z.string().refine(solana.isValidSolanaAddress, {
89
+ error: (issue) => `${issue.input} is not a valid Solana address`
76
90
  });
77
- var assetAndChain = uncheckedAssetAndChain.refine(
78
- (value) => chainflip.isValidAssetAndChain(value)
79
- );
80
-
81
- // ../shared/src/api/encodeVaultSwapData.ts
82
- var EncodedVaultSwapData = z3.z.discriminatedUnion("chain", [
83
- z3.z.object({
84
- chain: z3.z.literal("Bitcoin"),
85
- nulldataPayload: hexString,
86
- depositAddress: z3.z.string()
87
- }),
88
- z3.z.object({
89
- chain: z3.z.enum(["Ethereum", "Arbitrum", "Bsc"]),
90
- value: z3.z.string(),
91
- to: hexString,
92
- calldata: hexString,
93
- sourceTokenAddress: hexString.optional()
94
- }),
95
- z3.z.object({
96
- chain: z3.z.literal("Tron"),
97
- calldata: hexString,
98
- value: z3.z.string(),
99
- to: tronAddress,
100
- note: hexString,
101
- sourceTokenAddress: tronAddress.optional()
102
- }),
103
- z3.z.object({
104
- chain: z3.z.literal("Solana"),
105
- programId: z3.z.string(),
106
- data: hexString,
107
- accounts: z3.z.array(
108
- z3.z.object({
109
- pubkey: z3.z.string(),
110
- isSigner: z3.z.boolean(),
111
- isWritable: z3.z.boolean()
112
- })
113
- )
114
- })
115
- ]);
116
- var NetworkInfo = z3__default.default.object({
117
- assets: z3__default.default.array(
118
- z3__default.default.object({
119
- asset: z3__default.default.enum(chainflip.chainflipAssets),
120
- vaultSwapDepositsEnabled: z3__default.default.boolean(),
121
- depositChannelDepositsEnabled: z3__default.default.boolean(),
122
- depositChannelCreationEnabled: z3__default.default.boolean(),
123
- egressEnabled: z3__default.default.boolean(),
124
- boostDepositsEnabled: z3__default.default.boolean(),
125
- livePriceProtectionEnabled: z3__default.default.boolean()
126
- })
127
- ),
128
- cfBrokerCommissionBps: z3__default.default.number()
91
+ zod.z.string().refine(tron.isValidTronAddress, {
92
+ error: (issue) => `${issue.input} is not a valid Tron address`
129
93
  });
130
-
131
- // ../shared/src/guards.ts
132
- var isNotNullish = (value) => value !== null && value !== void 0;
133
- function assert(condition, message, Constructor = Error) {
134
- if (condition) return;
135
- const error = new Constructor(message);
136
- if (error.stack) {
137
- error.stack = error.stack.replace(/\n.+/, "\n");
138
- }
139
- throw error;
140
- }
141
-
142
- // ../shared/src/validation/addressValidation.ts
143
- var validatePolkadotAddress = (address) => {
144
- if (string.isHex(address)) return address.length === 66;
145
- try {
146
- ss58__namespace.decode(address);
147
- return true;
148
- } catch {
149
- return false;
150
- }
151
- };
152
- var validateEvmAddress = (address) => ethers__namespace.isAddress(address);
153
- var validateBitcoinMainnetAddress = (address) => bitcoin__namespace.isValidAddressForNetwork(address, "mainnet");
154
- var validateBitcoinTestnetAddress = (address) => bitcoin__namespace.isValidAddressForNetwork(address, "testnet");
155
- var validateBitcoinRegtestAddress = (address) => bitcoin__namespace.isValidAddressForNetwork(address, "regtest");
156
- var validateSolanaAddress = solana.isValidSolanaAddress;
157
- var validateTronAddress = tron.isValidTronAddress;
158
- var validators = {
159
- mainnet: {
160
- Bitcoin: validateBitcoinMainnetAddress,
161
- Ethereum: validateEvmAddress,
162
- Arbitrum: validateEvmAddress,
163
- Solana: validateSolanaAddress,
164
- Assethub: validatePolkadotAddress,
165
- Tron: validateTronAddress,
166
- Bsc: validateEvmAddress
167
- },
168
- perseverance: {
169
- Bitcoin: validateBitcoinTestnetAddress,
170
- Ethereum: validateEvmAddress,
171
- Arbitrum: validateEvmAddress,
172
- Solana: validateSolanaAddress,
173
- Assethub: validatePolkadotAddress,
174
- Tron: validateTronAddress,
175
- Bsc: validateEvmAddress
176
- },
177
- sisyphos: {
178
- Bitcoin: validateBitcoinTestnetAddress,
179
- Ethereum: validateEvmAddress,
180
- Arbitrum: validateEvmAddress,
181
- Solana: validateSolanaAddress,
182
- Assethub: validatePolkadotAddress,
183
- Tron: validateTronAddress,
184
- Bsc: validateEvmAddress
185
- },
186
- backspin: {
187
- Bitcoin: validateBitcoinRegtestAddress,
188
- Ethereum: validateEvmAddress,
189
- Arbitrum: validateEvmAddress,
190
- Solana: validateSolanaAddress,
191
- Assethub: validatePolkadotAddress,
192
- Tron: validateTronAddress,
193
- Bsc: validateEvmAddress
194
- },
195
- localnet: {
196
- Bitcoin: validateBitcoinRegtestAddress,
197
- Ethereum: validateEvmAddress,
198
- Arbitrum: validateEvmAddress,
199
- Solana: validateSolanaAddress,
200
- Assethub: validatePolkadotAddress,
201
- Tron: validateTronAddress,
202
- Bsc: validateEvmAddress
203
- }
204
- };
205
- var validateAddress = (chain2, address, network) => validators[network][chain2](address);
206
-
207
- // ../shared/src/api/openAccountCreationDepositChannel.ts
208
- var getAccountCreationDepositChannelSchema = (network) => z3.z.object({
209
- signatureData: z3.z.object({
210
- Ethereum: z3.z.object({
211
- signature: hexString,
212
- signer: hexString,
213
- sigType: z3.z.literal("Eip712")
214
- }).transform(({ sigType, ...rest }) => ({
215
- sig_type: sigType,
216
- ...rest
217
- }))
218
- }),
219
- transactionMetadata: z3.z.object({
220
- nonce: z3.z.number().gte(0),
221
- expiryBlock: z3.z.number().positive()
222
- }).transform(({ nonce, expiryBlock }) => ({
223
- nonce,
224
- expiry_block: expiryBlock
225
- })),
226
- asset: assetAndChain,
227
- refundAddress: z3.z.string(),
228
- boostFeeBps: z3.z.number().optional().default(0)
229
- }).superRefine(({ asset: asset2, refundAddress }, ctx) => {
230
- if (!validateAddress(asset2.chain, refundAddress, network)) {
231
- ctx.addIssue({
232
- message: `Address "${refundAddress}" is not a valid "${asset2.chain}" address for "${network}"`,
233
- code: z3.z.ZodIssueCode.custom
234
- });
235
- }
94
+ var u16 = zod.z.number().int().nonnegative().max(65535);
95
+ var u32 = zod.z.number().int().nonnegative().max(4294967295);
96
+ var u128 = zod.z.union([
97
+ zod.z.number().int().nonnegative().safe(),
98
+ numericString,
99
+ hexString.refine((v) => v.length > 2, { message: "hex string must not be empty" })
100
+ ]).transform((arg) => BigInt(arg)).refine((n) => n < 2n ** 128n, { message: "must be less than 2^128" });
101
+ var unsignedInteger = u128;
102
+ var chain = zod.z.enum(chainflip.chainflipChains);
103
+ var asset = zod.z.enum(chainflip.assetSymbols);
104
+ var uncheckedAssetAndChain = zod.z.object({
105
+ asset: zod.z.string(),
106
+ chain: zod.z.string()
236
107
  });
237
- z3.z.object({
108
+ var assetAndChain = uncheckedAssetAndChain.refine(
109
+ (value) => chain.safeParse(value.chain).success && asset.safeParse(value.asset).success && chainflip.isValidAssetAndChain(value)
110
+ );
111
+ zod.z.object({
238
112
  srcChain: chain,
239
113
  srcAsset: asset,
240
114
  destChain: chain,
241
115
  destAsset: asset,
242
116
  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" }),
243
- brokerCommissionBps: numericOrEmptyString.transform((v) => Number(v)).optional(),
244
- ccmGasBudget: z3.z.union([
245
- numericString.transform((v) => BigInt(v)),
246
- z3.z.literal("undefined").transform(() => void 0)
117
+ brokerCommissionBps: numericOrEmptyString.transform((v) => Number(v)).pipe(u16).optional(),
118
+ ccmGasBudget: zod.z.union([
119
+ numericString.transform((v) => BigInt(v)).refine((v) => v < 2n ** 128n, { message: "ccm gas budget must be less than 2^128" }),
120
+ zod.z.literal("undefined").transform(() => void 0)
247
121
  // sdk version 1.8.2 sends undefined string if not set
248
122
  ]).optional(),
249
- ccmMessageLengthBytes: z3.z.union([
250
- numericString.transform((v) => Number(v)),
251
- z3.z.literal("undefined").transform(() => void 0)
123
+ ccmMessageLengthBytes: zod.z.union([
124
+ numericString.transform((v) => Number(v)).pipe(u32),
125
+ zod.z.literal("undefined").transform(() => void 0)
252
126
  // sdk version 1.8.2 sends undefined string if not set
253
127
  ]).optional(),
254
- dcaV2Enabled: booleanString.default("false"),
128
+ dcaV2Enabled: booleanString.prefault("false"),
255
129
  isVaultSwap: booleanString.optional(),
256
130
  isOnChain: booleanString.optional(),
257
131
  brokerAccount: chainflipAddress.optional(),
258
132
  brokerIdSs58: chainflipAddress.optional(),
259
- expectedResponseTimeMs: numericString.transform((v) => Number(v)).optional()
133
+ expectedResponseTimeMs: numericString.transform((v) => Number(v)).pipe(u32).optional()
260
134
  }).transform((args, ctx) => {
261
135
  const { srcAsset, destAsset } = chainflip.getInternalAssets(args, false);
262
136
  let hadError = false;
263
137
  if (srcAsset === null) {
264
138
  ctx.addIssue({
265
139
  message: `invalid asset and chain combination: ${JSON.stringify({ asset: args.srcAsset, chain: args.srcChain })}`,
266
- code: z3.z.ZodIssueCode.custom
140
+ code: zod.z.ZodIssueCode.custom
267
141
  });
268
142
  hadError = true;
269
143
  }
270
144
  if (destAsset === null) {
271
145
  ctx.addIssue({
272
146
  message: `invalid asset and chain combination: ${JSON.stringify({ asset: args.destAsset, chain: args.destChain })}`,
273
- code: z3.z.ZodIssueCode.custom
147
+ code: zod.z.ZodIssueCode.custom
274
148
  });
275
149
  hadError = true;
276
150
  }
277
151
  if (args.ccmGasBudget !== void 0 && args.ccmMessageLengthBytes === void 0) {
278
152
  ctx.addIssue({
279
153
  message: `ccmMessageLengthBytes must be set if ccmGasBudget is set`,
280
- code: z3.z.ZodIssueCode.custom
154
+ code: zod.z.ZodIssueCode.custom
281
155
  });
282
156
  hadError = true;
283
157
  }
284
158
  if (args.ccmGasBudget === void 0 && args.ccmMessageLengthBytes !== void 0) {
285
159
  ctx.addIssue({
286
160
  message: `ccmGasBudget must be set if ccmMessageLengthBytes is set`,
287
- code: z3.z.ZodIssueCode.custom
161
+ code: zod.z.ZodIssueCode.custom
288
162
  });
289
163
  hadError = true;
290
164
  }
291
165
  if (args.isOnChain && args.isVaultSwap) {
292
166
  ctx.addIssue({
293
167
  message: "isOnChain and isVaultSwap cannot be set at the same time",
294
- code: z3.z.ZodIssueCode.custom
168
+ code: zod.z.ZodIssueCode.custom
295
169
  });
296
170
  hadError = true;
297
171
  }
298
172
  if (args.isVaultSwap && args.srcChain === "Assethub") {
299
173
  ctx.addIssue({
300
174
  message: "Vault swaps are not supported on Assethub",
301
- code: z3.z.ZodIssueCode.custom
175
+ code: zod.z.ZodIssueCode.custom
302
176
  });
303
177
  hadError = true;
304
178
  }
305
179
  if (args.isOnChain && args.brokerCommissionBps !== void 0 && args.brokerCommissionBps > 0) {
306
180
  ctx.addIssue({
307
181
  message: "isOnChain cannot be set with a non-zero broker commission",
308
- code: z3.z.ZodIssueCode.custom
182
+ code: zod.z.ZodIssueCode.custom
309
183
  });
310
184
  hadError = true;
311
185
  }
312
- if (hadError) return z3.z.NEVER;
186
+ if (hadError) return zod.z.NEVER;
313
187
  const ccmParams = args.ccmGasBudget !== void 0 && args.ccmMessageLengthBytes !== void 0 ? { gasBudget: args.ccmGasBudget, messageLengthBytes: args.ccmMessageLengthBytes } : void 0;
314
188
  return {
315
189
  srcAsset,
@@ -324,8 +198,8 @@ z3.z.object({
324
198
  expectedResponseTimeMs: args.expectedResponseTimeMs
325
199
  };
326
200
  });
327
- var ccmParamsSchema = z3.z.object({
328
- gasBudget: z3.z.union([numericString, hexString]).transform((n) => number.hexEncodeNumber(BigInt(n))),
201
+ var ccmParamsSchema = zod.z.object({
202
+ gasBudget: zod.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) => number.hexEncodeNumber(n)),
329
203
  // https://github.com/chainflip-io/chainflip-backend/blob/415aa9e20ec4046c68892cd34798e5d831c5b83f/state-chain/chains/src/lib.rs#L709
330
204
  message: hexStringWithMaxByteSize(15e3),
331
205
  // https://github.com/chainflip-io/chainflip-backend/blob/415aa9e20ec4046c68892cd34798e5d831c5b83f/state-chain/chains/src/lib.rs#L710
@@ -335,92 +209,97 @@ var ccmParamsSchema = z3.z.object({
335
209
  message,
336
210
  ccmAdditionalData: ccmAdditionalData ?? "0x"
337
211
  }));
338
- var affiliateBroker = z3.z.object({
212
+ var affiliateBroker = zod.z.object({
339
213
  account: chainflipAddress,
340
- commissionBps: z3.z.number()
214
+ commissionBps: u16
341
215
  }).transform(({ account, commissionBps: bps }) => ({ account, bps }));
342
- var dcaParams = z3.z.object({
343
- numberOfChunks: z3.z.number(),
344
- chunkIntervalBlocks: z3.z.number()
216
+ var dcaParams = zod.z.object({
217
+ numberOfChunks: u32.min(1, { message: "number of chunks must be greater than 0" }),
218
+ chunkIntervalBlocks: u32
345
219
  });
346
- var fillOrKillParams = z3.z.object({
347
- retryDurationBlocks: z3.z.number(),
348
- refundAddress: z3.z.string(),
220
+ zod.z.object({
221
+ retryDurationBlocks: u32,
222
+ refundAddress: zod.z.string(),
349
223
  minPriceX128: numericString,
350
224
  maxOraclePriceSlippage: basisPoints.nullish().transform((v) => v ?? null),
351
225
  refundCcmMetadata: ccmParamsSchema.nullish().optional().default(null)
352
226
  });
353
227
 
354
- // ../shared/src/api/openSwapDepositChannel.ts
355
- var assets = z3.z.object({
356
- srcAsset: assetAndChain,
357
- destAsset: assetAndChain
358
- });
359
- var getOpenSwapDepositChannelSchema = (network) => z3.z.intersection(
360
- assets,
361
- z3.z.object({
362
- destAddress: z3.z.string(),
363
- amount: numericString,
364
- ccmParams: ccmParamsSchema.optional(),
365
- maxBoostFeeBps: z3.z.number().optional(),
366
- srcAddress: z3.z.string().optional(),
367
- fillOrKillParams,
368
- dcaParams: dcaParams.optional(),
369
- quote: z3.z.object({
370
- intermediateAmount: z3.z.string().optional(),
371
- egressAmount: z3.z.string(),
372
- estimatedPrice: z3.z.string(),
373
- recommendedSlippageTolerancePercent: z3.z.number().optional(),
374
- recommendedLivePriceSlippageTolerancePercent: z3.z.number().optional()
375
- }).optional(),
376
- takeCommission: z3.z.boolean().optional()
377
- })
378
- ).superRefine(({ ...val }, ctx) => {
379
- if (!validateAddress(val.destAsset.chain, val.destAddress, network)) {
380
- ctx.addIssue({
381
- message: `Address "${val.destAddress}" is not a valid "${val.destAsset.chain}" address for "${network}"`,
382
- code: z3.z.ZodIssueCode.custom
383
- });
384
- }
385
- if (!validateAddress(val.srcAsset.chain, val.fillOrKillParams.refundAddress, network)) {
386
- ctx.addIssue({
387
- message: `Address "${val.fillOrKillParams.refundAddress}" is not a valid "${val.srcAsset.chain}" address for "${network}"`,
388
- code: z3.z.ZodIssueCode.custom
389
- });
228
+ // ../shared/src/guards.ts
229
+ var isNotNullish = (value) => value !== null && value !== void 0;
230
+ function assert(condition, message, Constructor = Error) {
231
+ if (condition) return;
232
+ const error = new Constructor(message);
233
+ if (error.stack) {
234
+ error.stack = error.stack.replace(/\n.+/, "\n");
390
235
  }
391
- }).transform(({ amount, ...rest }) => ({
392
- ...rest,
393
- expectedDepositAmount: amount
394
- }));
395
- var DepositChannelInfo = z3.z.object({
396
- id: z3.z.string(),
397
- depositAddress: z3.z.string(),
398
- brokerCommissionBps: z3.z.number(),
399
- maxBoostFeeBps: z3.z.number(),
400
- issuedBlock: z3.z.number(),
401
- srcChainExpiryBlock: z3.z.string(),
402
- estimatedExpiryTime: z3.z.number().optional(),
403
- channelOpeningFee: z3.z.string()
404
- });
405
-
406
- // ../shared/src/strings.ts
407
- var toCamelCase = (str) => str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
236
+ throw error;
237
+ }
408
238
 
409
- // ../shared/src/objects.ts
410
- var transformKeysToCamelCase = (obj) => {
411
- if (Array.isArray(obj)) {
412
- return obj.map(transformKeysToCamelCase);
239
+ // ../shared/src/validation/addressValidation.ts
240
+ var validatePolkadotAddress = (address) => {
241
+ if (string.isHex(address)) return address.length === 66;
242
+ try {
243
+ ss58__namespace.decode(address);
244
+ return true;
245
+ } catch {
246
+ return false;
413
247
  }
414
- if (obj !== null && typeof obj === "object") {
415
- return Object.fromEntries(
416
- Object.entries(obj).map(([key, value]) => [
417
- toCamelCase(key),
418
- transformKeysToCamelCase(value)
419
- ])
420
- );
248
+ };
249
+ var validateEvmAddress = (address) => ethers__namespace.isAddress(address);
250
+ var validateBitcoinMainnetAddress = (address) => bitcoin__namespace.isValidAddressForNetwork(address, "mainnet");
251
+ var validateBitcoinTestnetAddress = (address) => bitcoin__namespace.isValidAddressForNetwork(address, "testnet");
252
+ var validateBitcoinRegtestAddress = (address) => bitcoin__namespace.isValidAddressForNetwork(address, "regtest");
253
+ var validateSolanaAddress = solana.isValidSolanaAddress;
254
+ var validateTronAddress = tron.isValidTronAddress;
255
+ var validators = {
256
+ mainnet: {
257
+ Bitcoin: validateBitcoinMainnetAddress,
258
+ Ethereum: validateEvmAddress,
259
+ Arbitrum: validateEvmAddress,
260
+ Solana: validateSolanaAddress,
261
+ Assethub: validatePolkadotAddress,
262
+ Tron: validateTronAddress,
263
+ Bsc: validateEvmAddress
264
+ },
265
+ perseverance: {
266
+ Bitcoin: validateBitcoinTestnetAddress,
267
+ Ethereum: validateEvmAddress,
268
+ Arbitrum: validateEvmAddress,
269
+ Solana: validateSolanaAddress,
270
+ Assethub: validatePolkadotAddress,
271
+ Tron: validateTronAddress,
272
+ Bsc: validateEvmAddress
273
+ },
274
+ sisyphos: {
275
+ Bitcoin: validateBitcoinTestnetAddress,
276
+ Ethereum: validateEvmAddress,
277
+ Arbitrum: validateEvmAddress,
278
+ Solana: validateSolanaAddress,
279
+ Assethub: validatePolkadotAddress,
280
+ Tron: validateTronAddress,
281
+ Bsc: validateEvmAddress
282
+ },
283
+ backspin: {
284
+ Bitcoin: validateBitcoinRegtestAddress,
285
+ Ethereum: validateEvmAddress,
286
+ Arbitrum: validateEvmAddress,
287
+ Solana: validateSolanaAddress,
288
+ Assethub: validatePolkadotAddress,
289
+ Tron: validateTronAddress,
290
+ Bsc: validateEvmAddress
291
+ },
292
+ localnet: {
293
+ Bitcoin: validateBitcoinRegtestAddress,
294
+ Ethereum: validateEvmAddress,
295
+ Arbitrum: validateEvmAddress,
296
+ Solana: validateSolanaAddress,
297
+ Assethub: validatePolkadotAddress,
298
+ Tron: validateTronAddress,
299
+ Bsc: validateEvmAddress
421
300
  }
422
- return obj;
423
301
  };
302
+ var validateAddress = (chain2, address, network) => Object.hasOwn(validators, network) && Object.hasOwn(validators[network], chain2) && validators[network][chain2](address);
424
303
 
425
304
  // ../shared/src/broker.ts
426
305
  var transformedDcaParamsSchema = dcaParams.transform(
@@ -436,9 +315,9 @@ var transformedCcmParamsSchema = ccmParamsSchema.transform(
436
315
  ccm_additional_data: ccmAdditionalData
437
316
  })
438
317
  );
439
- var transformedFokSchema = z3.z.object({
440
- retryDurationBlocks: z3.z.number(),
441
- refundAddress: z3.z.string(),
318
+ var transformedFokSchema = zod.z.object({
319
+ retryDurationBlocks: u32,
320
+ refundAddress: zod.z.string(),
442
321
  minPriceX128: numericString,
443
322
  maxOraclePriceSlippage: basisPoints.nullish().transform((v) => v ?? null),
444
323
  refundCcmMetadata: transformedCcmParamsSchema.nullable().optional().default(null)
@@ -457,67 +336,67 @@ var transformedFokSchema = z3.z.object({
457
336
  refund_ccm_metadata: refundCcmMetadata
458
337
  })
459
338
  );
460
- var getDepositAddressRequestSchema = (network) => z3.z.object({
339
+ var getDepositAddressRequestSchema = (network) => zod.z.object({
461
340
  srcAsset: assetAndChain,
462
341
  destAsset: assetAndChain,
463
- destAddress: z3.z.string(),
464
- commissionBps: z3.z.number().optional().default(0),
342
+ destAddress: zod.z.string(),
343
+ commissionBps: u16.optional().default(0),
465
344
  ccmParams: transformedCcmParamsSchema.optional(),
466
- maxBoostFeeBps: z3.z.number().optional(),
467
- affiliates: z3.z.array(affiliateBroker).optional(),
345
+ maxBoostFeeBps: u16.optional(),
346
+ affiliates: zod.z.array(affiliateBroker).optional(),
468
347
  fillOrKillParams: transformedFokSchema,
469
348
  dcaParams: transformedDcaParamsSchema.optional()
470
349
  }).superRefine((val, ctx) => {
471
350
  if (!validateAddress(val.destAsset.chain, val.destAddress, network)) {
472
351
  ctx.addIssue({
473
352
  message: `Address "${val.destAddress}" is not a valid "${val.destAsset.chain}" address for "${network}"`,
474
- code: z3.z.ZodIssueCode.custom
353
+ code: zod.z.ZodIssueCode.custom
475
354
  });
476
355
  }
477
356
  if (!validateAddress(val.srcAsset.chain, val.fillOrKillParams.refund_address, network)) {
478
357
  ctx.addIssue({
479
358
  message: `Address "${val.fillOrKillParams.refund_address}" is not a valid "${val.srcAsset.chain}" address for "${network}"`,
480
- code: z3.z.ZodIssueCode.custom
359
+ code: zod.z.ZodIssueCode.custom
481
360
  });
482
361
  }
483
362
  });
484
- var getVaultSwapParameterEncodingRequestSchema = (network) => z3.z.object({
363
+ var getVaultSwapParameterEncodingRequestSchema = (network) => zod.z.object({
485
364
  srcAsset: assetAndChain,
486
- srcAddress: z3.z.string().optional(),
365
+ srcAddress: zod.z.string().optional(),
487
366
  destAsset: assetAndChain,
488
- destAddress: z3.z.string(),
367
+ destAddress: zod.z.string(),
489
368
  amount: unsignedInteger,
490
- commissionBps: z3.z.number().optional().default(0),
369
+ commissionBps: u16.optional().default(0),
491
370
  ccmParams: transformedCcmParamsSchema.optional(),
492
- maxBoostFeeBps: z3.z.number().optional(),
493
- affiliates: z3.z.array(affiliateBroker).optional(),
371
+ maxBoostFeeBps: u16.optional(),
372
+ affiliates: zod.z.array(affiliateBroker).optional(),
494
373
  fillOrKillParams: transformedFokSchema,
495
374
  dcaParams: transformedDcaParamsSchema.optional(),
496
- extraParams: z3.z.object({ seed: hexString.optional() }).optional(),
375
+ extraParams: zod.z.object({ seed: hexString.optional() }).optional(),
497
376
  brokerAccount: chainflipAddress.optional()
498
377
  }).superRefine((val, ctx) => {
499
378
  if (val.srcAddress && !validateAddress(val.srcAsset.chain, val.srcAddress, network)) {
500
379
  ctx.addIssue({
501
380
  message: `Address "${val.srcAddress}" is not a valid "${val.srcAsset.chain}" address for "${network}"`,
502
- code: z3.z.ZodIssueCode.custom
381
+ code: zod.z.ZodIssueCode.custom
503
382
  });
504
383
  }
505
384
  if (!validateAddress(val.destAsset.chain, val.destAddress, network)) {
506
385
  ctx.addIssue({
507
386
  message: `Address "${val.destAddress}" is not a valid "${val.destAsset.chain}" address for "${network}"`,
508
- code: z3.z.ZodIssueCode.custom
387
+ code: zod.z.ZodIssueCode.custom
509
388
  });
510
389
  }
511
390
  if (!validateAddress(val.srcAsset.chain, val.fillOrKillParams.refund_address, network)) {
512
391
  ctx.addIssue({
513
392
  message: `Address "${val.fillOrKillParams.refund_address}" is not a valid "${val.srcAsset.chain}" address for "${network}"`,
514
- code: z3.z.ZodIssueCode.custom
393
+ code: zod.z.ZodIssueCode.custom
515
394
  });
516
395
  }
517
396
  if (val.extraParams?.seed && val.extraParams.seed.length !== 66) {
518
- ctx.addIssue({ message: "Seed must be 32 bytes", code: z3.z.ZodIssueCode.custom });
397
+ ctx.addIssue({ message: "Seed must be 32 bytes", code: zod.z.ZodIssueCode.custom });
519
398
  }
520
- }).transform((data) => {
399
+ }).transform((data, ctx) => {
521
400
  let extraParams;
522
401
  if (data.srcAsset.chain === "Bitcoin") {
523
402
  const minOutputAmount = BigNumber2__default.default(data.amount.toString()).multipliedBy(tickMath.priceX128ToPrice(data.fillOrKillParams.min_price)).toFixed(0);
@@ -534,7 +413,13 @@ var getVaultSwapParameterEncodingRequestSchema = (network) => z3.z.object({
534
413
  refund_parameters: data.fillOrKillParams
535
414
  };
536
415
  } else if (data.srcAsset.chain === "Solana") {
537
- assert(data.srcAddress, "srcAddress is required for Solana");
416
+ if (!data.srcAddress) {
417
+ ctx.addIssue({
418
+ message: "srcAddress is required for Solana",
419
+ code: zod.z.ZodIssueCode.custom
420
+ });
421
+ return zod.z.NEVER;
422
+ }
538
423
  extraParams = {
539
424
  chain: "Solana",
540
425
  from: data.srcAddress,
@@ -543,7 +428,11 @@ var getVaultSwapParameterEncodingRequestSchema = (network) => z3.z.object({
543
428
  refund_parameters: data.fillOrKillParams
544
429
  };
545
430
  } else {
546
- throw new Error(`parameter encoding is not supported for ${data.srcAsset.chain}`);
431
+ ctx.addIssue({
432
+ message: `parameter encoding is not supported for ${data.srcAsset.chain}`,
433
+ code: zod.z.ZodIssueCode.custom
434
+ });
435
+ return zod.z.NEVER;
547
436
  }
548
437
  return { ...data, extraParams };
549
438
  });
@@ -597,16 +486,16 @@ async function requestSwapParameterEncoding(request, opts, chainflipNetwork) {
597
486
  );
598
487
  return transformKeysToCamelCase(response);
599
488
  }
600
- var getParameterEncodingRequestSchema = (network) => z3.z.object({
489
+ var getParameterEncodingRequestSchema = (network) => zod.z.object({
601
490
  srcAsset: assetAndChain,
602
- srcAddress: z3.z.string().optional(),
491
+ srcAddress: zod.z.string().optional(),
603
492
  destAsset: assetAndChain,
604
- destAddress: z3.z.string(),
493
+ destAddress: zod.z.string(),
605
494
  amount: unsignedInteger,
606
- commissionBps: z3.z.number().optional().default(0),
495
+ commissionBps: u16.optional().default(0),
607
496
  ccmParams: transformedCcmParamsSchema.optional(),
608
- maxBoostFeeBps: z3.z.number().optional(),
609
- affiliates: z3.z.array(affiliateBroker).optional(),
497
+ maxBoostFeeBps: u16.optional(),
498
+ affiliates: zod.z.array(affiliateBroker).optional(),
610
499
  fillOrKillParams: transformedFokSchema,
611
500
  dcaParams: transformedDcaParamsSchema.optional(),
612
501
  brokerAccount: chainflipAddress.optional()
@@ -614,19 +503,19 @@ var getParameterEncodingRequestSchema = (network) => z3.z.object({
614
503
  if (val.srcAddress && !validateAddress(val.srcAsset.chain, val.srcAddress, network)) {
615
504
  ctx.addIssue({
616
505
  message: `Address "${val.srcAddress}" is not a valid "${val.srcAsset.chain}" address for "${network}"`,
617
- code: z3.z.ZodIssueCode.custom
506
+ code: zod.z.ZodIssueCode.custom
618
507
  });
619
508
  }
620
509
  if (!validateAddress(val.destAsset.chain, val.destAddress, network)) {
621
510
  ctx.addIssue({
622
511
  message: `Address "${val.destAddress}" is not a valid "${val.destAsset.chain}" address for "${network}"`,
623
- code: z3.z.ZodIssueCode.custom
512
+ code: zod.z.ZodIssueCode.custom
624
513
  });
625
514
  }
626
515
  if (!validateAddress(val.srcAsset.chain, val.fillOrKillParams.refund_address, network)) {
627
516
  ctx.addIssue({
628
517
  message: `Address "${val.fillOrKillParams.refund_address}" is not a valid "${val.srcAsset.chain}" address for "${network}"`,
629
- code: z3.z.ZodIssueCode.custom
518
+ code: zod.z.ZodIssueCode.custom
630
519
  });
631
520
  }
632
521
  }).transform(({ ...rest }) => rest);
@@ -648,56 +537,6 @@ async function requestCfParametersEncoding(request, opts, network) {
648
537
  return response;
649
538
  }
650
539
 
651
- // ../shared/src/api/contract.ts
652
- var c = core.initContract();
653
- var createApiContract = (network) => c.router(
654
- {
655
- networkInfo: {
656
- method: "GET",
657
- path: "/networkInfo",
658
- responses: {
659
- 200: NetworkInfo
660
- },
661
- summary: "Get information about the Chainflip network"
662
- },
663
- encodeCfParameters: {
664
- method: "POST",
665
- path: "/encodeCfParameters",
666
- body: getParameterEncodingRequestSchema(network),
667
- responses: {
668
- 200: hexString
669
- }
670
- },
671
- encodeVaultSwapData: {
672
- method: "POST",
673
- path: "/encodeVaultSwapData",
674
- body: getVaultSwapParameterEncodingRequestSchema(network),
675
- responses: {
676
- 200: EncodedVaultSwapData
677
- }
678
- },
679
- openSwapDepositChannel: {
680
- method: "POST",
681
- path: "/openSwapDepositChannel",
682
- body: getOpenSwapDepositChannelSchema(network),
683
- responses: {
684
- 201: DepositChannelInfo
685
- }
686
- },
687
- openAccountCreationDepositChannel: {
688
- method: "POST",
689
- path: "/openAccountCreationDepositChannel",
690
- body: getAccountCreationDepositChannelSchema(network),
691
- responses: {
692
- 201: DepositChannelInfo
693
- }
694
- }
695
- },
696
- {
697
- pathPrefix: "/api"
698
- }
699
- );
700
-
701
540
  // ../shared/src/consts.ts
702
541
  var ETHEREUM_EVM_CHAIN_ID = {
703
542
  backspin: 10997,
@@ -824,12 +663,12 @@ var MultiCache = class {
824
663
  }
825
664
  values = {};
826
665
  read(type) {
827
- const { fetch, ttl } = this.fetchers[type];
666
+ const { fetch: fetch2, ttl } = this.fetchers[type];
828
667
  let cached = this.values[type];
829
668
  if (!cached || cached.timestamp + ttl < Date.now()) {
830
669
  cached = {
831
670
  timestamp: Date.now(),
832
- value: fetch().catch((err) => {
671
+ value: fetch2().catch((err) => {
833
672
  this.values[type] = void 0;
834
673
  throw err;
835
674
  })
@@ -1000,7 +839,7 @@ var getChainData = (chain2, network, env) => ({
1000
839
 
1001
840
  // package.json
1002
841
  var package_default = {
1003
- version: "2.3.1"};
842
+ version: "2.3.3"};
1004
843
 
1005
844
  // src/swap/consts.ts
1006
845
  var CF_SDK_VERSION_HEADERS = { "X-Chainflip-Sdk-Version": package_default.version };
@@ -1048,6 +887,59 @@ var getStatusV2 = async (baseUrl, { id }, { signal }) => {
1048
887
  });
1049
888
  return data;
1050
889
  };
890
+ var lowercaseKeys = (headers) => Object.fromEntries(Object.entries(headers).map(([key, value]) => [key.toLowerCase(), value]));
891
+ var backendRequest = async (baseUrl, method, path, body) => {
892
+ const headers = lowercaseKeys(CF_SDK_VERSION_HEADERS);
893
+ let serializedBody;
894
+ if (method !== "GET" && body != null) {
895
+ headers["content-type"] = "application/json";
896
+ serializedBody = JSON.stringify(body);
897
+ }
898
+ const res = await fetch(`${baseUrl.replace(/\/+$/, "")}${path}`, {
899
+ method,
900
+ headers,
901
+ body: serializedBody
902
+ });
903
+ const contentType = res.headers.get("content-type") ?? "";
904
+ if (contentType.includes("application/") && contentType.includes("json")) {
905
+ return { status: res.status, body: await res.json(), headers: res.headers };
906
+ }
907
+ if (contentType.includes("text/")) {
908
+ return { status: res.status, body: await res.text(), headers: res.headers };
909
+ }
910
+ return { status: res.status, body: await res.blob(), headers: res.headers };
911
+ };
912
+ var getNetworkInfo = async (baseUrl) => {
913
+ const res = await backendRequest(baseUrl, "GET", "/api/networkInfo");
914
+ assert(res.status === 200, "Failed to fetch network info");
915
+ return res.body;
916
+ };
917
+ var openSwapDepositChannel = async (baseUrl, body) => {
918
+ const res = await backendRequest(baseUrl, "POST", "/api/openSwapDepositChannel", body);
919
+ assert(res.status === 201, "Failed to open swap deposit channel");
920
+ return res.body;
921
+ };
922
+ var encodeVaultSwapData = async (baseUrl, body) => {
923
+ const res = await backendRequest(baseUrl, "POST", "/api/encodeVaultSwapData", body);
924
+ if (res.status !== 200) {
925
+ throw new Error("Failed to encode vault swap data", { cause: res });
926
+ }
927
+ return res.body;
928
+ };
929
+ var encodeCfParameters = async (baseUrl, body) => {
930
+ const res = await backendRequest(baseUrl, "POST", "/api/encodeCfParameters", body);
931
+ if (res.status !== 200) {
932
+ throw new Error("Failed to encode cf parameters", { cause: res });
933
+ }
934
+ return res.body;
935
+ };
936
+ var openAccountCreationDepositChannel = async (baseUrl, body) => {
937
+ const res = await backendRequest(baseUrl, "POST", "/api/openAccountCreationDepositChannel", body);
938
+ if (res.status !== 201) {
939
+ throw new Error("Failed to request account creation deposit channel", { cause: res });
940
+ }
941
+ return res.body;
942
+ };
1051
943
 
1052
944
  // src/swap/sdk.ts
1053
945
  var assertQuoteValid = (quote) => {
@@ -1064,7 +956,6 @@ var assertQuoteValid = (quote) => {
1064
956
  var SwapSDK = class {
1065
957
  options;
1066
958
  rpcConfig;
1067
- apiClient;
1068
959
  cache;
1069
960
  dcaV2Enabled = false;
1070
961
  constructor(options = {}) {
@@ -1075,12 +966,6 @@ var SwapSDK = class {
1075
966
  backendUrl: options.backendUrl ?? BACKEND_SERVICE_URLS[network]
1076
967
  };
1077
968
  this.rpcConfig = options.rpcUrl ? { rpcUrl: options.rpcUrl } : { network };
1078
- this.apiClient = core.initClient(createApiContract(this.options.network), {
1079
- // remove trailing slashes. this bug has been fixed in `@ts-rest/core`
1080
- // but it hasn't been released yet
1081
- baseUrl: this.options.backendUrl.replace(/\/+$/, ""),
1082
- baseHeaders: CF_SDK_VERSION_HEADERS
1083
- });
1084
969
  this.dcaV2Enabled = options.enabledFeatures?.dcaV2 ?? false;
1085
970
  this.cache = new MultiCache({
1086
971
  environment: {
@@ -1088,11 +973,7 @@ var SwapSDK = class {
1088
973
  ttl: 6e4
1089
974
  },
1090
975
  networkInfo: {
1091
- fetch: async () => {
1092
- const res = await this.apiClient.networkInfo();
1093
- assert(res.status === 200, "Failed to fetch network info");
1094
- return res.body;
1095
- },
976
+ fetch: () => getNetworkInfo(this.options.backendUrl),
1096
977
  ttl: 6e4
1097
978
  }
1098
979
  });
@@ -1113,8 +994,8 @@ var SwapSDK = class {
1113
994
  return this.cache.read("environment");
1114
995
  }
1115
996
  async getSupportedAssets(type) {
1116
- const assets2 = await this.cache.read("networkInfo");
1117
- return assets2.assets.filter((a) => chainflip.isChainflipAsset(a.asset)).filter((a) => {
997
+ const assets = await this.cache.read("networkInfo");
998
+ return assets.assets.filter((a) => chainflip.isChainflipAsset(a.asset)).filter((a) => {
1118
999
  switch (type) {
1119
1000
  case "all":
1120
1001
  return true;
@@ -1296,15 +1177,11 @@ var SwapSDK = class {
1296
1177
  !affiliates?.length,
1297
1178
  "Affiliate brokers are supported only when initializing the SDK with a brokerUrl"
1298
1179
  );
1299
- const res = await this.apiClient.openSwapDepositChannel({
1300
- body: {
1301
- ...depositAddressRequest,
1302
- quote,
1303
- takeCommission: this.shouldTakeCommission()
1304
- }
1180
+ response = await openSwapDepositChannel(this.options.backendUrl, {
1181
+ ...depositAddressRequest,
1182
+ quote,
1183
+ takeCommission: this.shouldTakeCommission()
1305
1184
  });
1306
- assert(res.status === 201, "Failed to open swap deposit channel");
1307
- response = res.body;
1308
1185
  }
1309
1186
  return {
1310
1187
  ...depositAddressRequest,
@@ -1377,18 +1254,15 @@ var SwapSDK = class {
1377
1254
  !vaultSwapRequest.affiliates?.length || vaultSwapRequest.brokerAccount,
1378
1255
  "Affiliate brokers are supported only when setting a broker account"
1379
1256
  );
1380
- const res = await this.apiClient.encodeVaultSwapData({ body: vaultSwapRequest });
1381
- if (res.status !== 200) {
1382
- throw new Error("Failed to encode vault swap data", { cause: res });
1383
- }
1384
- switch (res.body.chain) {
1257
+ const body = await encodeVaultSwapData(this.options.backendUrl, vaultSwapRequest);
1258
+ switch (body.chain) {
1385
1259
  case "Arbitrum":
1386
1260
  case "Ethereum":
1387
1261
  case "Tron":
1388
1262
  case "Bsc":
1389
- return { ...res.body, value: BigInt(res.body.value) };
1263
+ return { ...body, value: BigInt(body.value) };
1390
1264
  default:
1391
- return res.body;
1265
+ return body;
1392
1266
  }
1393
1267
  }
1394
1268
  async encodeCfParameters({
@@ -1440,32 +1314,23 @@ var SwapSDK = class {
1440
1314
  !requestParams.affiliates?.length || brokerAccount,
1441
1315
  "Affiliate brokers are supported only when setting a broker account"
1442
1316
  );
1443
- const res = await this.apiClient.encodeCfParameters({
1444
- body: { ...requestParams, brokerAccount }
1317
+ return encodeCfParameters(this.options.backendUrl, {
1318
+ ...requestParams,
1319
+ brokerAccount
1445
1320
  });
1446
- if (res.status !== 200) {
1447
- throw new Error("Failed to encode cf parameters", { cause: res });
1448
- }
1449
- return res.body;
1450
1321
  }
1451
1322
  async checkBoostEnabled() {
1452
- const { assets: assets2 } = await this.cache.read("networkInfo");
1453
- return assets2.find((a) => a.asset === "Btc")?.boostDepositsEnabled ?? true;
1323
+ const { assets } = await this.cache.read("networkInfo");
1324
+ return assets.find((a) => a.asset === "Btc")?.boostDepositsEnabled ?? true;
1454
1325
  }
1455
1326
  async requestAccountCreationDepositAddress(asset2, refundAddress, signatureData, transactionMetadata, boostFeeBps = 0) {
1456
- const res = await this.apiClient.openAccountCreationDepositChannel({
1457
- body: {
1458
- asset: chainflip.internalAssetToRpcAsset[asset2],
1459
- refundAddress,
1460
- signatureData,
1461
- transactionMetadata,
1462
- boostFeeBps
1463
- }
1327
+ return openAccountCreationDepositChannel(this.options.backendUrl, {
1328
+ asset: chainflip.internalAssetToRpcAsset[asset2],
1329
+ refundAddress,
1330
+ signatureData,
1331
+ transactionMetadata,
1332
+ boostFeeBps
1464
1333
  });
1465
- if (res.status !== 201) {
1466
- throw new Error("Failed to request account creation deposit channel", { cause: res });
1467
- }
1468
- return res.body;
1469
1334
  }
1470
1335
  };
1471
1336
  var arrayToMap = (array) => Object.fromEntries(array.map((item) => [item, item]));