@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.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,24 +38,42 @@ 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(
76
+ var chainflipAddress = zod.z.string().refine(
60
77
  (address) => {
61
78
  if (!address.startsWith("cF")) return false;
62
79
  try {
@@ -66,258 +83,107 @@ var chainflipAddress = z3.z.string().refine(
66
83
  return false;
67
84
  }
68
85
  },
69
- (address) => ({ message: `${address} is not a valid Chainflip address` })
86
+ { error: (issue) => `${issue.input} is not a valid Chainflip address` }
70
87
  );
71
- z3.z.string().refine(solana.isValidSolanaAddress, (address) => ({
72
- message: `${address} is not a valid Solana address`
73
- }));
74
- var tronAddress = z3.z.string().refine(tron.isValidTronAddress, (address) => ({
75
- message: `${address} is not a valid Tron address`
76
- }));
77
- var u128 = z3.z.union([z3.z.number(), numericString, hexString]).transform((arg) => BigInt(arg));
78
- var unsignedInteger = z3.z.union([u128, z3.z.number().transform((n) => BigInt(n))]);
79
- var chain = z3.z.enum(chainflip.chainflipChains);
80
- var asset = z3.z.enum(chainflip.assetSymbols);
81
- var uncheckedAssetAndChain = z3.z.object({
82
- asset: z3.z.string(),
83
- chain: z3.z.string()
88
+ zod.z.string().refine(solana.isValidSolanaAddress, {
89
+ error: (issue) => `${issue.input} is not a valid Solana address`
84
90
  });
85
- var assetAndChain = uncheckedAssetAndChain.refine(
86
- (value) => chainflip.isValidAssetAndChain(value)
87
- );
88
-
89
- // ../shared/src/api/encodeVaultSwapData.ts
90
- var EncodedVaultSwapData = z3.z.discriminatedUnion("chain", [
91
- z3.z.object({
92
- chain: z3.z.literal("Bitcoin"),
93
- nulldataPayload: hexString,
94
- depositAddress: z3.z.string()
95
- }),
96
- z3.z.object({
97
- chain: z3.z.enum(["Ethereum", "Arbitrum", "Bsc"]),
98
- value: z3.z.string(),
99
- to: hexString,
100
- calldata: hexString,
101
- sourceTokenAddress: hexString.optional()
102
- }),
103
- z3.z.object({
104
- chain: z3.z.literal("Tron"),
105
- calldata: hexString,
106
- value: z3.z.string(),
107
- to: tronAddress,
108
- note: hexString,
109
- sourceTokenAddress: tronAddress.optional()
110
- }),
111
- z3.z.object({
112
- chain: z3.z.literal("Solana"),
113
- programId: z3.z.string(),
114
- data: hexString,
115
- accounts: z3.z.array(
116
- z3.z.object({
117
- pubkey: z3.z.string(),
118
- isSigner: z3.z.boolean(),
119
- isWritable: z3.z.boolean()
120
- })
121
- )
122
- })
123
- ]);
124
- var NetworkInfo = z3__default.default.object({
125
- assets: z3__default.default.array(
126
- z3__default.default.object({
127
- asset: z3__default.default.enum(chainflip.chainflipAssets),
128
- vaultSwapDepositsEnabled: z3__default.default.boolean(),
129
- depositChannelDepositsEnabled: z3__default.default.boolean(),
130
- depositChannelCreationEnabled: z3__default.default.boolean(),
131
- egressEnabled: z3__default.default.boolean(),
132
- boostDepositsEnabled: z3__default.default.boolean(),
133
- livePriceProtectionEnabled: z3__default.default.boolean()
134
- })
135
- ),
136
- cfBrokerCommissionBps: z3__default.default.number()
91
+ zod.z.string().refine(tron.isValidTronAddress, {
92
+ error: (issue) => `${issue.input} is not a valid Tron address`
137
93
  });
138
-
139
- // ../shared/src/guards.ts
140
- var isNotNullish = (value) => value !== null && value !== void 0;
141
- function assert(condition, message, Constructor = Error) {
142
- if (condition) return;
143
- const error = new Constructor(message);
144
- if (error.stack) {
145
- error.stack = error.stack.replace(/\n.+/, "\n");
146
- }
147
- throw error;
148
- }
149
-
150
- // ../shared/src/validation/addressValidation.ts
151
- var validatePolkadotAddress = (address) => {
152
- if (string.isHex(address)) return address.length === 66;
153
- try {
154
- ss58__namespace.decode(address);
155
- return true;
156
- } catch {
157
- return false;
158
- }
159
- };
160
- var validateEvmAddress = (address) => ethers__namespace.isAddress(address);
161
- var validateBitcoinMainnetAddress = (address) => bitcoin__namespace.isValidAddressForNetwork(address, "mainnet");
162
- var validateBitcoinTestnetAddress = (address) => bitcoin__namespace.isValidAddressForNetwork(address, "testnet");
163
- var validateBitcoinRegtestAddress = (address) => bitcoin__namespace.isValidAddressForNetwork(address, "regtest");
164
- var validateSolanaAddress = solana.isValidSolanaAddress;
165
- var validateTronAddress = tron.isValidTronAddress;
166
- var validators = {
167
- mainnet: {
168
- Bitcoin: validateBitcoinMainnetAddress,
169
- Ethereum: validateEvmAddress,
170
- Arbitrum: validateEvmAddress,
171
- Solana: validateSolanaAddress,
172
- Assethub: validatePolkadotAddress,
173
- Tron: validateTronAddress,
174
- Bsc: validateEvmAddress
175
- },
176
- perseverance: {
177
- Bitcoin: validateBitcoinTestnetAddress,
178
- Ethereum: validateEvmAddress,
179
- Arbitrum: validateEvmAddress,
180
- Solana: validateSolanaAddress,
181
- Assethub: validatePolkadotAddress,
182
- Tron: validateTronAddress,
183
- Bsc: validateEvmAddress
184
- },
185
- sisyphos: {
186
- Bitcoin: validateBitcoinTestnetAddress,
187
- Ethereum: validateEvmAddress,
188
- Arbitrum: validateEvmAddress,
189
- Solana: validateSolanaAddress,
190
- Assethub: validatePolkadotAddress,
191
- Tron: validateTronAddress,
192
- Bsc: validateEvmAddress
193
- },
194
- backspin: {
195
- Bitcoin: validateBitcoinRegtestAddress,
196
- Ethereum: validateEvmAddress,
197
- Arbitrum: validateEvmAddress,
198
- Solana: validateSolanaAddress,
199
- Assethub: validatePolkadotAddress,
200
- Tron: validateTronAddress,
201
- Bsc: validateEvmAddress
202
- },
203
- localnet: {
204
- Bitcoin: validateBitcoinRegtestAddress,
205
- Ethereum: validateEvmAddress,
206
- Arbitrum: validateEvmAddress,
207
- Solana: validateSolanaAddress,
208
- Assethub: validatePolkadotAddress,
209
- Tron: validateTronAddress,
210
- Bsc: validateEvmAddress
211
- }
212
- };
213
- var validateAddress = (chain2, address, network) => validators[network][chain2](address);
214
-
215
- // ../shared/src/api/openAccountCreationDepositChannel.ts
216
- var getAccountCreationDepositChannelSchema = (network) => z3.z.object({
217
- signatureData: z3.z.object({
218
- Ethereum: z3.z.object({
219
- signature: hexString,
220
- signer: hexString,
221
- sigType: z3.z.literal("Eip712")
222
- }).transform(({ sigType, ...rest }) => ({
223
- sig_type: sigType,
224
- ...rest
225
- }))
226
- }),
227
- transactionMetadata: z3.z.object({
228
- nonce: z3.z.number().gte(0),
229
- expiryBlock: z3.z.number().positive()
230
- }).transform(({ nonce, expiryBlock }) => ({
231
- nonce,
232
- expiry_block: expiryBlock
233
- })),
234
- asset: assetAndChain,
235
- refundAddress: z3.z.string(),
236
- boostFeeBps: z3.z.number().optional().default(0)
237
- }).superRefine(({ asset: asset2, refundAddress }, ctx) => {
238
- if (!validateAddress(asset2.chain, refundAddress, network)) {
239
- ctx.addIssue({
240
- message: `Address "${refundAddress}" is not a valid "${asset2.chain}" address for "${network}"`,
241
- code: z3.z.ZodIssueCode.custom
242
- });
243
- }
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()
244
107
  });
245
- 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({
246
112
  srcChain: chain,
247
113
  srcAsset: asset,
248
114
  destChain: chain,
249
115
  destAsset: asset,
250
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" }),
251
- brokerCommissionBps: numericOrEmptyString.transform((v) => Number(v)).optional(),
252
- ccmGasBudget: z3.z.union([
117
+ brokerCommissionBps: numericOrEmptyString.transform((v) => Number(v)).pipe(u16).optional(),
118
+ ccmGasBudget: zod.z.union([
253
119
  numericString.transform((v) => BigInt(v)).refine((v) => v < 2n ** 128n, { message: "ccm gas budget must be less than 2^128" }),
254
- z3.z.literal("undefined").transform(() => void 0)
120
+ zod.z.literal("undefined").transform(() => void 0)
255
121
  // sdk version 1.8.2 sends undefined string if not set
256
122
  ]).optional(),
257
- ccmMessageLengthBytes: z3.z.union([
258
- numericString.transform((v) => Number(v)),
259
- 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)
260
126
  // sdk version 1.8.2 sends undefined string if not set
261
127
  ]).optional(),
262
- dcaV2Enabled: booleanString.default("false"),
128
+ dcaV2Enabled: booleanString.prefault("false"),
263
129
  isVaultSwap: booleanString.optional(),
264
130
  isOnChain: booleanString.optional(),
265
131
  brokerAccount: chainflipAddress.optional(),
266
132
  brokerIdSs58: chainflipAddress.optional(),
267
- expectedResponseTimeMs: numericString.transform((v) => Number(v)).optional()
133
+ expectedResponseTimeMs: numericString.transform((v) => Number(v)).pipe(u32).optional()
268
134
  }).transform((args, ctx) => {
269
135
  const { srcAsset, destAsset } = chainflip.getInternalAssets(args, false);
270
136
  let hadError = false;
271
137
  if (srcAsset === null) {
272
138
  ctx.addIssue({
273
139
  message: `invalid asset and chain combination: ${JSON.stringify({ asset: args.srcAsset, chain: args.srcChain })}`,
274
- code: z3.z.ZodIssueCode.custom
140
+ code: zod.z.ZodIssueCode.custom
275
141
  });
276
142
  hadError = true;
277
143
  }
278
144
  if (destAsset === null) {
279
145
  ctx.addIssue({
280
146
  message: `invalid asset and chain combination: ${JSON.stringify({ asset: args.destAsset, chain: args.destChain })}`,
281
- code: z3.z.ZodIssueCode.custom
147
+ code: zod.z.ZodIssueCode.custom
282
148
  });
283
149
  hadError = true;
284
150
  }
285
151
  if (args.ccmGasBudget !== void 0 && args.ccmMessageLengthBytes === void 0) {
286
152
  ctx.addIssue({
287
153
  message: `ccmMessageLengthBytes must be set if ccmGasBudget is set`,
288
- code: z3.z.ZodIssueCode.custom
154
+ code: zod.z.ZodIssueCode.custom
289
155
  });
290
156
  hadError = true;
291
157
  }
292
158
  if (args.ccmGasBudget === void 0 && args.ccmMessageLengthBytes !== void 0) {
293
159
  ctx.addIssue({
294
160
  message: `ccmGasBudget must be set if ccmMessageLengthBytes is set`,
295
- code: z3.z.ZodIssueCode.custom
161
+ code: zod.z.ZodIssueCode.custom
296
162
  });
297
163
  hadError = true;
298
164
  }
299
165
  if (args.isOnChain && args.isVaultSwap) {
300
166
  ctx.addIssue({
301
167
  message: "isOnChain and isVaultSwap cannot be set at the same time",
302
- code: z3.z.ZodIssueCode.custom
168
+ code: zod.z.ZodIssueCode.custom
303
169
  });
304
170
  hadError = true;
305
171
  }
306
172
  if (args.isVaultSwap && args.srcChain === "Assethub") {
307
173
  ctx.addIssue({
308
174
  message: "Vault swaps are not supported on Assethub",
309
- code: z3.z.ZodIssueCode.custom
175
+ code: zod.z.ZodIssueCode.custom
310
176
  });
311
177
  hadError = true;
312
178
  }
313
179
  if (args.isOnChain && args.brokerCommissionBps !== void 0 && args.brokerCommissionBps > 0) {
314
180
  ctx.addIssue({
315
181
  message: "isOnChain cannot be set with a non-zero broker commission",
316
- code: z3.z.ZodIssueCode.custom
182
+ code: zod.z.ZodIssueCode.custom
317
183
  });
318
184
  hadError = true;
319
185
  }
320
- if (hadError) return z3.z.NEVER;
186
+ if (hadError) return zod.z.NEVER;
321
187
  const ccmParams = args.ccmGasBudget !== void 0 && args.ccmMessageLengthBytes !== void 0 ? { gasBudget: args.ccmGasBudget, messageLengthBytes: args.ccmMessageLengthBytes } : void 0;
322
188
  return {
323
189
  srcAsset,
@@ -332,8 +198,8 @@ z3.z.object({
332
198
  expectedResponseTimeMs: args.expectedResponseTimeMs
333
199
  };
334
200
  });
335
- var ccmParamsSchema = z3.z.object({
336
- gasBudget: z3.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)),
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)),
337
203
  // https://github.com/chainflip-io/chainflip-backend/blob/415aa9e20ec4046c68892cd34798e5d831c5b83f/state-chain/chains/src/lib.rs#L709
338
204
  message: hexStringWithMaxByteSize(15e3),
339
205
  // https://github.com/chainflip-io/chainflip-backend/blob/415aa9e20ec4046c68892cd34798e5d831c5b83f/state-chain/chains/src/lib.rs#L710
@@ -343,93 +209,97 @@ var ccmParamsSchema = z3.z.object({
343
209
  message,
344
210
  ccmAdditionalData: ccmAdditionalData ?? "0x"
345
211
  }));
346
- var affiliateBroker = z3.z.object({
212
+ var affiliateBroker = zod.z.object({
347
213
  account: chainflipAddress,
348
- commissionBps: z3.z.number()
214
+ commissionBps: u16
349
215
  }).transform(({ account, commissionBps: bps }) => ({ account, bps }));
350
- var dcaParams = z3.z.object({
351
- numberOfChunks: z3.z.number(),
352
- 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
353
219
  });
354
- var fillOrKillParams = z3.z.object({
355
- retryDurationBlocks: z3.z.number(),
356
- refundAddress: z3.z.string(),
220
+ zod.z.object({
221
+ retryDurationBlocks: u32,
222
+ refundAddress: zod.z.string(),
357
223
  minPriceX128: numericString,
358
224
  maxOraclePriceSlippage: basisPoints.nullish().transform((v) => v ?? null),
359
225
  refundCcmMetadata: ccmParamsSchema.nullish().optional().default(null)
360
226
  });
361
227
 
362
- // ../shared/src/api/openSwapDepositChannel.ts
363
- var assets = z3.z.object({
364
- srcAsset: assetAndChain,
365
- destAsset: assetAndChain
366
- });
367
- var amountString = numericString.max(30, { message: "must have at most 30 digits" });
368
- var getOpenSwapDepositChannelSchema = (network) => z3.z.intersection(
369
- assets,
370
- z3.z.object({
371
- destAddress: z3.z.string(),
372
- amount: amountString,
373
- ccmParams: ccmParamsSchema.optional(),
374
- maxBoostFeeBps: z3.z.number().optional(),
375
- srcAddress: z3.z.string().optional(),
376
- fillOrKillParams,
377
- dcaParams: dcaParams.optional(),
378
- quote: z3.z.object({
379
- intermediateAmount: amountString.optional(),
380
- egressAmount: amountString,
381
- estimatedPrice: z3.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" }),
382
- recommendedSlippageTolerancePercent: z3.z.number().optional(),
383
- recommendedLivePriceSlippageTolerancePercent: z3.z.number().optional()
384
- }).optional(),
385
- takeCommission: z3.z.boolean().optional()
386
- })
387
- ).superRefine(({ ...val }, ctx) => {
388
- if (!validateAddress(val.destAsset.chain, val.destAddress, network)) {
389
- ctx.addIssue({
390
- message: `Address "${val.destAddress}" is not a valid "${val.destAsset.chain}" address for "${network}"`,
391
- code: z3.z.ZodIssueCode.custom
392
- });
393
- }
394
- if (!validateAddress(val.srcAsset.chain, val.fillOrKillParams.refundAddress, network)) {
395
- ctx.addIssue({
396
- message: `Address "${val.fillOrKillParams.refundAddress}" is not a valid "${val.srcAsset.chain}" address for "${network}"`,
397
- code: z3.z.ZodIssueCode.custom
398
- });
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");
399
235
  }
400
- }).transform(({ amount, ...rest }) => ({
401
- ...rest,
402
- expectedDepositAmount: amount
403
- }));
404
- var DepositChannelInfo = z3.z.object({
405
- id: z3.z.string(),
406
- depositAddress: z3.z.string(),
407
- brokerCommissionBps: z3.z.number(),
408
- maxBoostFeeBps: z3.z.number(),
409
- issuedBlock: z3.z.number(),
410
- srcChainExpiryBlock: z3.z.string(),
411
- estimatedExpiryTime: z3.z.number().optional(),
412
- channelOpeningFee: z3.z.string()
413
- });
414
-
415
- // ../shared/src/strings.ts
416
- var toCamelCase = (str) => str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
236
+ throw error;
237
+ }
417
238
 
418
- // ../shared/src/objects.ts
419
- var transformKeysToCamelCase = (obj) => {
420
- if (Array.isArray(obj)) {
421
- 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;
422
247
  }
423
- if (obj !== null && typeof obj === "object") {
424
- return Object.fromEntries(
425
- Object.entries(obj).map(([key, value]) => [
426
- toCamelCase(key),
427
- transformKeysToCamelCase(value)
428
- ])
429
- );
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
430
300
  }
431
- return obj;
432
301
  };
302
+ var validateAddress = (chain2, address, network) => Object.hasOwn(validators, network) && Object.hasOwn(validators[network], chain2) && validators[network][chain2](address);
433
303
 
434
304
  // ../shared/src/broker.ts
435
305
  var transformedDcaParamsSchema = dcaParams.transform(
@@ -445,9 +315,9 @@ var transformedCcmParamsSchema = ccmParamsSchema.transform(
445
315
  ccm_additional_data: ccmAdditionalData
446
316
  })
447
317
  );
448
- var transformedFokSchema = z3.z.object({
449
- retryDurationBlocks: z3.z.number(),
450
- refundAddress: z3.z.string(),
318
+ var transformedFokSchema = zod.z.object({
319
+ retryDurationBlocks: u32,
320
+ refundAddress: zod.z.string(),
451
321
  minPriceX128: numericString,
452
322
  maxOraclePriceSlippage: basisPoints.nullish().transform((v) => v ?? null),
453
323
  refundCcmMetadata: transformedCcmParamsSchema.nullable().optional().default(null)
@@ -466,67 +336,67 @@ var transformedFokSchema = z3.z.object({
466
336
  refund_ccm_metadata: refundCcmMetadata
467
337
  })
468
338
  );
469
- var getDepositAddressRequestSchema = (network) => z3.z.object({
339
+ var getDepositAddressRequestSchema = (network) => zod.z.object({
470
340
  srcAsset: assetAndChain,
471
341
  destAsset: assetAndChain,
472
- destAddress: z3.z.string(),
473
- commissionBps: z3.z.number().optional().default(0),
342
+ destAddress: zod.z.string(),
343
+ commissionBps: u16.optional().default(0),
474
344
  ccmParams: transformedCcmParamsSchema.optional(),
475
- maxBoostFeeBps: z3.z.number().optional(),
476
- affiliates: z3.z.array(affiliateBroker).optional(),
345
+ maxBoostFeeBps: u16.optional(),
346
+ affiliates: zod.z.array(affiliateBroker).optional(),
477
347
  fillOrKillParams: transformedFokSchema,
478
348
  dcaParams: transformedDcaParamsSchema.optional()
479
349
  }).superRefine((val, ctx) => {
480
350
  if (!validateAddress(val.destAsset.chain, val.destAddress, network)) {
481
351
  ctx.addIssue({
482
352
  message: `Address "${val.destAddress}" is not a valid "${val.destAsset.chain}" address for "${network}"`,
483
- code: z3.z.ZodIssueCode.custom
353
+ code: zod.z.ZodIssueCode.custom
484
354
  });
485
355
  }
486
356
  if (!validateAddress(val.srcAsset.chain, val.fillOrKillParams.refund_address, network)) {
487
357
  ctx.addIssue({
488
358
  message: `Address "${val.fillOrKillParams.refund_address}" is not a valid "${val.srcAsset.chain}" address for "${network}"`,
489
- code: z3.z.ZodIssueCode.custom
359
+ code: zod.z.ZodIssueCode.custom
490
360
  });
491
361
  }
492
362
  });
493
- var getVaultSwapParameterEncodingRequestSchema = (network) => z3.z.object({
363
+ var getVaultSwapParameterEncodingRequestSchema = (network) => zod.z.object({
494
364
  srcAsset: assetAndChain,
495
- srcAddress: z3.z.string().optional(),
365
+ srcAddress: zod.z.string().optional(),
496
366
  destAsset: assetAndChain,
497
- destAddress: z3.z.string(),
367
+ destAddress: zod.z.string(),
498
368
  amount: unsignedInteger,
499
- commissionBps: z3.z.number().optional().default(0),
369
+ commissionBps: u16.optional().default(0),
500
370
  ccmParams: transformedCcmParamsSchema.optional(),
501
- maxBoostFeeBps: z3.z.number().optional(),
502
- affiliates: z3.z.array(affiliateBroker).optional(),
371
+ maxBoostFeeBps: u16.optional(),
372
+ affiliates: zod.z.array(affiliateBroker).optional(),
503
373
  fillOrKillParams: transformedFokSchema,
504
374
  dcaParams: transformedDcaParamsSchema.optional(),
505
- extraParams: z3.z.object({ seed: hexString.optional() }).optional(),
375
+ extraParams: zod.z.object({ seed: hexString.optional() }).optional(),
506
376
  brokerAccount: chainflipAddress.optional()
507
377
  }).superRefine((val, ctx) => {
508
378
  if (val.srcAddress && !validateAddress(val.srcAsset.chain, val.srcAddress, network)) {
509
379
  ctx.addIssue({
510
380
  message: `Address "${val.srcAddress}" is not a valid "${val.srcAsset.chain}" address for "${network}"`,
511
- code: z3.z.ZodIssueCode.custom
381
+ code: zod.z.ZodIssueCode.custom
512
382
  });
513
383
  }
514
384
  if (!validateAddress(val.destAsset.chain, val.destAddress, network)) {
515
385
  ctx.addIssue({
516
386
  message: `Address "${val.destAddress}" is not a valid "${val.destAsset.chain}" address for "${network}"`,
517
- code: z3.z.ZodIssueCode.custom
387
+ code: zod.z.ZodIssueCode.custom
518
388
  });
519
389
  }
520
390
  if (!validateAddress(val.srcAsset.chain, val.fillOrKillParams.refund_address, network)) {
521
391
  ctx.addIssue({
522
392
  message: `Address "${val.fillOrKillParams.refund_address}" is not a valid "${val.srcAsset.chain}" address for "${network}"`,
523
- code: z3.z.ZodIssueCode.custom
393
+ code: zod.z.ZodIssueCode.custom
524
394
  });
525
395
  }
526
396
  if (val.extraParams?.seed && val.extraParams.seed.length !== 66) {
527
- 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 });
528
398
  }
529
- }).transform((data) => {
399
+ }).transform((data, ctx) => {
530
400
  let extraParams;
531
401
  if (data.srcAsset.chain === "Bitcoin") {
532
402
  const minOutputAmount = BigNumber2__default.default(data.amount.toString()).multipliedBy(tickMath.priceX128ToPrice(data.fillOrKillParams.min_price)).toFixed(0);
@@ -543,7 +413,13 @@ var getVaultSwapParameterEncodingRequestSchema = (network) => z3.z.object({
543
413
  refund_parameters: data.fillOrKillParams
544
414
  };
545
415
  } else if (data.srcAsset.chain === "Solana") {
546
- 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
+ }
547
423
  extraParams = {
548
424
  chain: "Solana",
549
425
  from: data.srcAddress,
@@ -552,7 +428,11 @@ var getVaultSwapParameterEncodingRequestSchema = (network) => z3.z.object({
552
428
  refund_parameters: data.fillOrKillParams
553
429
  };
554
430
  } else {
555
- 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;
556
436
  }
557
437
  return { ...data, extraParams };
558
438
  });
@@ -606,16 +486,16 @@ async function requestSwapParameterEncoding(request, opts, chainflipNetwork) {
606
486
  );
607
487
  return transformKeysToCamelCase(response);
608
488
  }
609
- var getParameterEncodingRequestSchema = (network) => z3.z.object({
489
+ var getParameterEncodingRequestSchema = (network) => zod.z.object({
610
490
  srcAsset: assetAndChain,
611
- srcAddress: z3.z.string().optional(),
491
+ srcAddress: zod.z.string().optional(),
612
492
  destAsset: assetAndChain,
613
- destAddress: z3.z.string(),
493
+ destAddress: zod.z.string(),
614
494
  amount: unsignedInteger,
615
- commissionBps: z3.z.number().optional().default(0),
495
+ commissionBps: u16.optional().default(0),
616
496
  ccmParams: transformedCcmParamsSchema.optional(),
617
- maxBoostFeeBps: z3.z.number().optional(),
618
- affiliates: z3.z.array(affiliateBroker).optional(),
497
+ maxBoostFeeBps: u16.optional(),
498
+ affiliates: zod.z.array(affiliateBroker).optional(),
619
499
  fillOrKillParams: transformedFokSchema,
620
500
  dcaParams: transformedDcaParamsSchema.optional(),
621
501
  brokerAccount: chainflipAddress.optional()
@@ -623,19 +503,19 @@ var getParameterEncodingRequestSchema = (network) => z3.z.object({
623
503
  if (val.srcAddress && !validateAddress(val.srcAsset.chain, val.srcAddress, network)) {
624
504
  ctx.addIssue({
625
505
  message: `Address "${val.srcAddress}" is not a valid "${val.srcAsset.chain}" address for "${network}"`,
626
- code: z3.z.ZodIssueCode.custom
506
+ code: zod.z.ZodIssueCode.custom
627
507
  });
628
508
  }
629
509
  if (!validateAddress(val.destAsset.chain, val.destAddress, network)) {
630
510
  ctx.addIssue({
631
511
  message: `Address "${val.destAddress}" is not a valid "${val.destAsset.chain}" address for "${network}"`,
632
- code: z3.z.ZodIssueCode.custom
512
+ code: zod.z.ZodIssueCode.custom
633
513
  });
634
514
  }
635
515
  if (!validateAddress(val.srcAsset.chain, val.fillOrKillParams.refund_address, network)) {
636
516
  ctx.addIssue({
637
517
  message: `Address "${val.fillOrKillParams.refund_address}" is not a valid "${val.srcAsset.chain}" address for "${network}"`,
638
- code: z3.z.ZodIssueCode.custom
518
+ code: zod.z.ZodIssueCode.custom
639
519
  });
640
520
  }
641
521
  }).transform(({ ...rest }) => rest);
@@ -657,56 +537,6 @@ async function requestCfParametersEncoding(request, opts, network) {
657
537
  return response;
658
538
  }
659
539
 
660
- // ../shared/src/api/contract.ts
661
- var c = core.initContract();
662
- var createApiContract = (network) => c.router(
663
- {
664
- networkInfo: {
665
- method: "GET",
666
- path: "/networkInfo",
667
- responses: {
668
- 200: NetworkInfo
669
- },
670
- summary: "Get information about the Chainflip network"
671
- },
672
- encodeCfParameters: {
673
- method: "POST",
674
- path: "/encodeCfParameters",
675
- body: getParameterEncodingRequestSchema(network),
676
- responses: {
677
- 200: hexString
678
- }
679
- },
680
- encodeVaultSwapData: {
681
- method: "POST",
682
- path: "/encodeVaultSwapData",
683
- body: getVaultSwapParameterEncodingRequestSchema(network),
684
- responses: {
685
- 200: EncodedVaultSwapData
686
- }
687
- },
688
- openSwapDepositChannel: {
689
- method: "POST",
690
- path: "/openSwapDepositChannel",
691
- body: getOpenSwapDepositChannelSchema(network),
692
- responses: {
693
- 201: DepositChannelInfo
694
- }
695
- },
696
- openAccountCreationDepositChannel: {
697
- method: "POST",
698
- path: "/openAccountCreationDepositChannel",
699
- body: getAccountCreationDepositChannelSchema(network),
700
- responses: {
701
- 201: DepositChannelInfo
702
- }
703
- }
704
- },
705
- {
706
- pathPrefix: "/api"
707
- }
708
- );
709
-
710
540
  // ../shared/src/consts.ts
711
541
  var ETHEREUM_EVM_CHAIN_ID = {
712
542
  backspin: 10997,
@@ -833,12 +663,12 @@ var MultiCache = class {
833
663
  }
834
664
  values = {};
835
665
  read(type) {
836
- const { fetch, ttl } = this.fetchers[type];
666
+ const { fetch: fetch2, ttl } = this.fetchers[type];
837
667
  let cached = this.values[type];
838
668
  if (!cached || cached.timestamp + ttl < Date.now()) {
839
669
  cached = {
840
670
  timestamp: Date.now(),
841
- value: fetch().catch((err) => {
671
+ value: fetch2().catch((err) => {
842
672
  this.values[type] = void 0;
843
673
  throw err;
844
674
  })
@@ -1009,7 +839,7 @@ var getChainData = (chain2, network, env) => ({
1009
839
 
1010
840
  // package.json
1011
841
  var package_default = {
1012
- version: "2.3.2"};
842
+ version: "2.3.3"};
1013
843
 
1014
844
  // src/swap/consts.ts
1015
845
  var CF_SDK_VERSION_HEADERS = { "X-Chainflip-Sdk-Version": package_default.version };
@@ -1057,6 +887,59 @@ var getStatusV2 = async (baseUrl, { id }, { signal }) => {
1057
887
  });
1058
888
  return data;
1059
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
+ };
1060
943
 
1061
944
  // src/swap/sdk.ts
1062
945
  var assertQuoteValid = (quote) => {
@@ -1073,7 +956,6 @@ var assertQuoteValid = (quote) => {
1073
956
  var SwapSDK = class {
1074
957
  options;
1075
958
  rpcConfig;
1076
- apiClient;
1077
959
  cache;
1078
960
  dcaV2Enabled = false;
1079
961
  constructor(options = {}) {
@@ -1084,12 +966,6 @@ var SwapSDK = class {
1084
966
  backendUrl: options.backendUrl ?? BACKEND_SERVICE_URLS[network]
1085
967
  };
1086
968
  this.rpcConfig = options.rpcUrl ? { rpcUrl: options.rpcUrl } : { network };
1087
- this.apiClient = core.initClient(createApiContract(this.options.network), {
1088
- // remove trailing slashes. this bug has been fixed in `@ts-rest/core`
1089
- // but it hasn't been released yet
1090
- baseUrl: this.options.backendUrl.replace(/\/+$/, ""),
1091
- baseHeaders: CF_SDK_VERSION_HEADERS
1092
- });
1093
969
  this.dcaV2Enabled = options.enabledFeatures?.dcaV2 ?? false;
1094
970
  this.cache = new MultiCache({
1095
971
  environment: {
@@ -1097,11 +973,7 @@ var SwapSDK = class {
1097
973
  ttl: 6e4
1098
974
  },
1099
975
  networkInfo: {
1100
- fetch: async () => {
1101
- const res = await this.apiClient.networkInfo();
1102
- assert(res.status === 200, "Failed to fetch network info");
1103
- return res.body;
1104
- },
976
+ fetch: () => getNetworkInfo(this.options.backendUrl),
1105
977
  ttl: 6e4
1106
978
  }
1107
979
  });
@@ -1122,8 +994,8 @@ var SwapSDK = class {
1122
994
  return this.cache.read("environment");
1123
995
  }
1124
996
  async getSupportedAssets(type) {
1125
- const assets2 = await this.cache.read("networkInfo");
1126
- 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) => {
1127
999
  switch (type) {
1128
1000
  case "all":
1129
1001
  return true;
@@ -1305,15 +1177,11 @@ var SwapSDK = class {
1305
1177
  !affiliates?.length,
1306
1178
  "Affiliate brokers are supported only when initializing the SDK with a brokerUrl"
1307
1179
  );
1308
- const res = await this.apiClient.openSwapDepositChannel({
1309
- body: {
1310
- ...depositAddressRequest,
1311
- quote,
1312
- takeCommission: this.shouldTakeCommission()
1313
- }
1180
+ response = await openSwapDepositChannel(this.options.backendUrl, {
1181
+ ...depositAddressRequest,
1182
+ quote,
1183
+ takeCommission: this.shouldTakeCommission()
1314
1184
  });
1315
- assert(res.status === 201, "Failed to open swap deposit channel");
1316
- response = res.body;
1317
1185
  }
1318
1186
  return {
1319
1187
  ...depositAddressRequest,
@@ -1386,18 +1254,15 @@ var SwapSDK = class {
1386
1254
  !vaultSwapRequest.affiliates?.length || vaultSwapRequest.brokerAccount,
1387
1255
  "Affiliate brokers are supported only when setting a broker account"
1388
1256
  );
1389
- const res = await this.apiClient.encodeVaultSwapData({ body: vaultSwapRequest });
1390
- if (res.status !== 200) {
1391
- throw new Error("Failed to encode vault swap data", { cause: res });
1392
- }
1393
- switch (res.body.chain) {
1257
+ const body = await encodeVaultSwapData(this.options.backendUrl, vaultSwapRequest);
1258
+ switch (body.chain) {
1394
1259
  case "Arbitrum":
1395
1260
  case "Ethereum":
1396
1261
  case "Tron":
1397
1262
  case "Bsc":
1398
- return { ...res.body, value: BigInt(res.body.value) };
1263
+ return { ...body, value: BigInt(body.value) };
1399
1264
  default:
1400
- return res.body;
1265
+ return body;
1401
1266
  }
1402
1267
  }
1403
1268
  async encodeCfParameters({
@@ -1449,32 +1314,23 @@ var SwapSDK = class {
1449
1314
  !requestParams.affiliates?.length || brokerAccount,
1450
1315
  "Affiliate brokers are supported only when setting a broker account"
1451
1316
  );
1452
- const res = await this.apiClient.encodeCfParameters({
1453
- body: { ...requestParams, brokerAccount }
1317
+ return encodeCfParameters(this.options.backendUrl, {
1318
+ ...requestParams,
1319
+ brokerAccount
1454
1320
  });
1455
- if (res.status !== 200) {
1456
- throw new Error("Failed to encode cf parameters", { cause: res });
1457
- }
1458
- return res.body;
1459
1321
  }
1460
1322
  async checkBoostEnabled() {
1461
- const { assets: assets2 } = await this.cache.read("networkInfo");
1462
- 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;
1463
1325
  }
1464
1326
  async requestAccountCreationDepositAddress(asset2, refundAddress, signatureData, transactionMetadata, boostFeeBps = 0) {
1465
- const res = await this.apiClient.openAccountCreationDepositChannel({
1466
- body: {
1467
- asset: chainflip.internalAssetToRpcAsset[asset2],
1468
- refundAddress,
1469
- signatureData,
1470
- transactionMetadata,
1471
- boostFeeBps
1472
- }
1327
+ return openAccountCreationDepositChannel(this.options.backendUrl, {
1328
+ asset: chainflip.internalAssetToRpcAsset[asset2],
1329
+ refundAddress,
1330
+ signatureData,
1331
+ transactionMetadata,
1332
+ boostFeeBps
1473
1333
  });
1474
- if (res.status !== 201) {
1475
- throw new Error("Failed to request account creation deposit channel", { cause: res });
1476
- }
1477
- return res.body;
1478
1334
  }
1479
1335
  };
1480
1336
  var arrayToMap = (array) => Object.fromEntries(array.map((item) => [item, item]));