@chainflip/sdk 1.9.4 → 1.10.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/funding.d.cts +11 -0
- package/dist/funding.d.ts +11 -0
- package/dist/funding.js +1 -1
- package/dist/swap.cjs +459 -97
- package/dist/swap.d.cts +46 -265
- package/dist/swap.d.ts +46 -265
- package/dist/swap.js +405 -43
- package/package.json +8 -9
- /package/dist/{chunk-6IYYRTHK.js → chunk-Q64VYHIA.js} +0 -0
package/dist/swap.cjs
CHANGED
|
@@ -1,16 +1,15 @@
|
|
|
1
1
|
'use strict';
|
|
2
2
|
|
|
3
|
+
var assertion = require('@chainflip/utils/assertion');
|
|
3
4
|
var chainflip = require('@chainflip/utils/chainflip');
|
|
4
|
-
var
|
|
5
|
-
var
|
|
5
|
+
var core = require('@ts-rest/core');
|
|
6
|
+
var z6 = require('zod');
|
|
6
7
|
var rpc = require('@chainflip/rpc');
|
|
7
|
-
var assertion = require('@chainflip/utils/assertion');
|
|
8
8
|
var bytes = require('@chainflip/utils/bytes');
|
|
9
9
|
var ss58 = require('@chainflip/utils/ss58');
|
|
10
10
|
var string = require('@chainflip/utils/string');
|
|
11
11
|
var tickMath = require('@chainflip/utils/tickMath');
|
|
12
|
-
var
|
|
13
|
-
var zod = require('zod');
|
|
12
|
+
var BigNumber3 = require('bignumber.js');
|
|
14
13
|
var solana = require('@chainflip/solana');
|
|
15
14
|
var number = require('@chainflip/utils/number');
|
|
16
15
|
var bitcoin = require('@chainflip/bitcoin');
|
|
@@ -37,9 +36,9 @@ function _interopNamespace(e) {
|
|
|
37
36
|
return Object.freeze(n);
|
|
38
37
|
}
|
|
39
38
|
|
|
40
|
-
var
|
|
39
|
+
var z6__default = /*#__PURE__*/_interopDefault(z6);
|
|
41
40
|
var ss58__namespace = /*#__PURE__*/_interopNamespace(ss58);
|
|
42
|
-
var
|
|
41
|
+
var BigNumber3__default = /*#__PURE__*/_interopDefault(BigNumber3);
|
|
43
42
|
var bitcoin__namespace = /*#__PURE__*/_interopNamespace(bitcoin);
|
|
44
43
|
var ethers__namespace = /*#__PURE__*/_interopNamespace(ethers);
|
|
45
44
|
var axios__default = /*#__PURE__*/_interopDefault(axios);
|
|
@@ -75,47 +74,47 @@ var transformKeysToCamelCase = (obj) => {
|
|
|
75
74
|
}
|
|
76
75
|
return obj;
|
|
77
76
|
};
|
|
78
|
-
var booleanString =
|
|
79
|
-
var numericString =
|
|
80
|
-
var numericOrEmptyString =
|
|
81
|
-
var hexString =
|
|
77
|
+
var booleanString = z6.z.string().regex(/^(true|false)$/i).transform((v) => v.toLowerCase() === "true");
|
|
78
|
+
var numericString = z6.z.string().regex(/^[0-9]+$/);
|
|
79
|
+
var numericOrEmptyString = z6.z.string().regex(/^[0-9]*$/);
|
|
80
|
+
var hexString = z6.z.string().refine((v) => /^0x[0-9a-f]*$/i.test(v));
|
|
82
81
|
var hexStringWithMaxByteSize = (maxByteSize) => hexString.refine((val) => val.length / 2 <= maxByteSize + 1, {
|
|
83
82
|
message: `String must be less than or equal to ${maxByteSize} bytes`
|
|
84
83
|
});
|
|
85
84
|
var DOT_PREFIX = 0;
|
|
86
|
-
var chainflipAddress =
|
|
85
|
+
var chainflipAddress = z6.z.string().refine(
|
|
87
86
|
(address) => address.startsWith("cF") && ss58__namespace.decode(address),
|
|
88
87
|
(address) => ({ message: `${address} is not a valid Chainflip address` })
|
|
89
88
|
);
|
|
90
|
-
|
|
89
|
+
z6.z.string().refine(solana.isValidSolanaAddress, (address) => ({
|
|
91
90
|
message: `${address} is not a valid Solana address`
|
|
92
91
|
}));
|
|
93
|
-
var u128 =
|
|
94
|
-
var unsignedInteger =
|
|
95
|
-
var chain =
|
|
96
|
-
var asset =
|
|
97
|
-
var uncheckedAssetAndChain =
|
|
98
|
-
asset:
|
|
99
|
-
chain:
|
|
92
|
+
var u128 = z6.z.union([z6.z.number(), numericString, hexString]).transform((arg) => BigInt(arg));
|
|
93
|
+
var unsignedInteger = z6.z.union([u128, z6.z.number().transform((n) => BigInt(n))]);
|
|
94
|
+
var chain = z6.z.enum(chainflip.chainflipChains);
|
|
95
|
+
var asset = z6.z.enum(chainflip.assetSymbols);
|
|
96
|
+
var uncheckedAssetAndChain = z6.z.object({
|
|
97
|
+
asset: z6.z.string(),
|
|
98
|
+
chain: z6.z.string()
|
|
100
99
|
});
|
|
101
100
|
var assetAndChain = uncheckedAssetAndChain.refine(
|
|
102
101
|
(value) => chainflip.isValidAssetAndChain(value)
|
|
103
102
|
);
|
|
104
|
-
|
|
103
|
+
z6.z.object({
|
|
105
104
|
srcChain: chain,
|
|
106
105
|
srcAsset: asset,
|
|
107
106
|
destChain: chain,
|
|
108
107
|
destAsset: asset,
|
|
109
108
|
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" }),
|
|
110
109
|
brokerCommissionBps: numericOrEmptyString.transform((v) => Number(v)).optional(),
|
|
111
|
-
ccmGasBudget:
|
|
110
|
+
ccmGasBudget: z6.z.union([
|
|
112
111
|
numericString.transform((v) => BigInt(v)),
|
|
113
|
-
|
|
112
|
+
z6.z.literal("undefined").transform(() => void 0)
|
|
114
113
|
// sdk version 1.8.2 sends undefined string if not set
|
|
115
114
|
]).optional(),
|
|
116
|
-
ccmMessageLengthBytes:
|
|
115
|
+
ccmMessageLengthBytes: z6.z.union([
|
|
117
116
|
numericString.transform((v) => Number(v)),
|
|
118
|
-
|
|
117
|
+
z6.z.literal("undefined").transform(() => void 0)
|
|
119
118
|
// sdk version 1.8.2 sends undefined string if not set
|
|
120
119
|
]).optional(),
|
|
121
120
|
dcaEnabled: booleanString.default("false"),
|
|
@@ -127,46 +126,46 @@ zod.z.object({
|
|
|
127
126
|
if (srcAsset === null) {
|
|
128
127
|
ctx.addIssue({
|
|
129
128
|
message: `invalid asset and chain combination: ${JSON.stringify({ asset: args.srcAsset, chain: args.srcChain })}`,
|
|
130
|
-
code:
|
|
129
|
+
code: z6.z.ZodIssueCode.custom
|
|
131
130
|
});
|
|
132
131
|
hadError = true;
|
|
133
132
|
}
|
|
134
133
|
if (destAsset === null) {
|
|
135
134
|
ctx.addIssue({
|
|
136
135
|
message: `invalid asset and chain combination: ${JSON.stringify({ asset: args.destAsset, chain: args.destChain })}`,
|
|
137
|
-
code:
|
|
136
|
+
code: z6.z.ZodIssueCode.custom
|
|
138
137
|
});
|
|
139
138
|
hadError = true;
|
|
140
139
|
}
|
|
141
140
|
if (args.ccmGasBudget !== void 0 && args.ccmMessageLengthBytes === void 0) {
|
|
142
141
|
ctx.addIssue({
|
|
143
142
|
message: `ccmMessageLengthBytes must be set if ccmGasBudget is set`,
|
|
144
|
-
code:
|
|
143
|
+
code: z6.z.ZodIssueCode.custom
|
|
145
144
|
});
|
|
146
145
|
hadError = true;
|
|
147
146
|
}
|
|
148
147
|
if (args.ccmGasBudget === void 0 && args.ccmMessageLengthBytes !== void 0) {
|
|
149
148
|
ctx.addIssue({
|
|
150
149
|
message: `ccmGasBudget must be set if ccmMessageLengthBytes is set`,
|
|
151
|
-
code:
|
|
150
|
+
code: z6.z.ZodIssueCode.custom
|
|
152
151
|
});
|
|
153
152
|
hadError = true;
|
|
154
153
|
}
|
|
155
|
-
if (args.isOnChain
|
|
154
|
+
if (args.isOnChain && args.isVaultSwap) {
|
|
156
155
|
ctx.addIssue({
|
|
157
156
|
message: "isOnChain and isVaultSwap cannot be set at the same time",
|
|
158
|
-
code:
|
|
157
|
+
code: z6.z.ZodIssueCode.custom
|
|
159
158
|
});
|
|
160
159
|
hadError = true;
|
|
161
160
|
}
|
|
162
|
-
if (args.isOnChain
|
|
161
|
+
if (args.isOnChain && args.brokerCommissionBps !== void 0 && args.brokerCommissionBps > 0) {
|
|
163
162
|
ctx.addIssue({
|
|
164
163
|
message: "isOnChain cannot be set with a non-zero broker commission",
|
|
165
|
-
code:
|
|
164
|
+
code: z6.z.ZodIssueCode.custom
|
|
166
165
|
});
|
|
167
166
|
hadError = true;
|
|
168
167
|
}
|
|
169
|
-
if (hadError) return
|
|
168
|
+
if (hadError) return z6.z.NEVER;
|
|
170
169
|
const ccmParams = args.ccmGasBudget !== void 0 && args.ccmMessageLengthBytes !== void 0 ? { gasBudget: args.ccmGasBudget, messageLengthBytes: args.ccmMessageLengthBytes } : void 0;
|
|
171
170
|
return {
|
|
172
171
|
srcAsset,
|
|
@@ -179,30 +178,30 @@ zod.z.object({
|
|
|
179
178
|
isOnChain: args.isOnChain
|
|
180
179
|
};
|
|
181
180
|
});
|
|
182
|
-
var ccmParamsSchema =
|
|
183
|
-
gasBudget:
|
|
181
|
+
var ccmParamsSchema = z6.z.object({
|
|
182
|
+
gasBudget: z6.z.union([numericString, hexString]).transform((n) => number.hexEncodeNumber(BigInt(n))),
|
|
184
183
|
// https://github.com/chainflip-io/chainflip-backend/blob/415aa9e20ec4046c68892cd34798e5d831c5b83f/state-chain/chains/src/lib.rs#L709
|
|
185
184
|
message: hexStringWithMaxByteSize(15e3),
|
|
186
185
|
// https://github.com/chainflip-io/chainflip-backend/blob/415aa9e20ec4046c68892cd34798e5d831c5b83f/state-chain/chains/src/lib.rs#L710
|
|
187
186
|
ccmAdditionalData: hexStringWithMaxByteSize(3e3).optional(),
|
|
188
|
-
/** @deprecated DEPRECATED(1.
|
|
187
|
+
/** @deprecated DEPRECATED(1.10) pass additionalData instead */
|
|
189
188
|
cfParameters: hexStringWithMaxByteSize(3e3).optional()
|
|
190
189
|
}).transform(({ gasBudget, message, ccmAdditionalData, cfParameters }) => ({
|
|
191
190
|
gasBudget,
|
|
192
191
|
message,
|
|
193
192
|
ccmAdditionalData: ccmAdditionalData ?? cfParameters
|
|
194
193
|
}));
|
|
195
|
-
var affiliateBroker =
|
|
194
|
+
var affiliateBroker = z6.z.object({
|
|
196
195
|
account: chainflipAddress,
|
|
197
|
-
commissionBps:
|
|
196
|
+
commissionBps: z6.z.number()
|
|
198
197
|
}).transform(({ account, commissionBps: bps }) => ({ account, bps }));
|
|
199
|
-
var dcaParams =
|
|
200
|
-
numberOfChunks:
|
|
201
|
-
chunkIntervalBlocks:
|
|
198
|
+
var dcaParams = z6.z.object({
|
|
199
|
+
numberOfChunks: z6.z.number(),
|
|
200
|
+
chunkIntervalBlocks: z6.z.number()
|
|
202
201
|
});
|
|
203
|
-
|
|
204
|
-
retryDurationBlocks:
|
|
205
|
-
refundAddress:
|
|
202
|
+
var fillOrKillParams = z6.z.object({
|
|
203
|
+
retryDurationBlocks: z6.z.number(),
|
|
204
|
+
refundAddress: z6.z.string(),
|
|
206
205
|
minPriceX128: numericString
|
|
207
206
|
});
|
|
208
207
|
var validatePolkadotAddress = (address) => {
|
|
@@ -264,9 +263,9 @@ var validators = {
|
|
|
264
263
|
var validateAddress = (chain2, address, network) => validators[network][chain2](address);
|
|
265
264
|
|
|
266
265
|
// ../shared/src/broker.ts
|
|
267
|
-
var transformedFokSchema =
|
|
268
|
-
retryDurationBlocks:
|
|
269
|
-
refundAddress:
|
|
266
|
+
var transformedFokSchema = z6.z.object({
|
|
267
|
+
retryDurationBlocks: z6.z.number(),
|
|
268
|
+
refundAddress: z6.z.string(),
|
|
270
269
|
minPriceX128: numericString
|
|
271
270
|
}).transform(({ retryDurationBlocks, refundAddress, minPriceX128 }) => ({
|
|
272
271
|
retry_duration: retryDurationBlocks,
|
|
@@ -284,74 +283,74 @@ var transformedCcmParamsSchema = ccmParamsSchema.transform(
|
|
|
284
283
|
message,
|
|
285
284
|
gas_budget: gasBudget,
|
|
286
285
|
ccm_additional_data: ccmAdditionalData,
|
|
287
|
-
/** @deprecated DEPRECATED(1.
|
|
286
|
+
/** @deprecated DEPRECATED(1.10) we still need to pass cf_parameters until 1.8 is deployed to all networks */
|
|
288
287
|
cf_parameters: ccmAdditionalData
|
|
289
288
|
})
|
|
290
289
|
);
|
|
291
|
-
var getDepositAddressRequestSchema = (network) =>
|
|
290
|
+
var getDepositAddressRequestSchema = (network) => z6.z.object({
|
|
292
291
|
srcAsset: assetAndChain,
|
|
293
292
|
destAsset: assetAndChain,
|
|
294
|
-
destAddress:
|
|
295
|
-
commissionBps:
|
|
293
|
+
destAddress: z6.z.string(),
|
|
294
|
+
commissionBps: z6.z.number().optional().default(0),
|
|
296
295
|
ccmParams: transformedCcmParamsSchema.optional(),
|
|
297
|
-
maxBoostFeeBps:
|
|
298
|
-
affiliates:
|
|
296
|
+
maxBoostFeeBps: z6.z.number().optional(),
|
|
297
|
+
affiliates: z6.z.array(affiliateBroker).optional(),
|
|
299
298
|
fillOrKillParams: transformedFokSchema,
|
|
300
299
|
dcaParams: transformedDcaParamsSchema.optional()
|
|
301
300
|
}).superRefine((val, ctx) => {
|
|
302
301
|
if (!validateAddress(val.destAsset.chain, val.destAddress, network)) {
|
|
303
302
|
ctx.addIssue({
|
|
304
303
|
message: `Address "${val.destAddress}" is not a valid "${val.destAsset.chain}" address for "${network}"`,
|
|
305
|
-
code:
|
|
304
|
+
code: z6.z.ZodIssueCode.custom
|
|
306
305
|
});
|
|
307
306
|
}
|
|
308
307
|
}).superRefine((val, ctx) => {
|
|
309
308
|
if (!validateAddress(val.srcAsset.chain, val.fillOrKillParams.refund_address, network)) {
|
|
310
309
|
ctx.addIssue({
|
|
311
310
|
message: `Address "${val.fillOrKillParams.refund_address}" is not a valid "${val.srcAsset.chain}" address for "${network}"`,
|
|
312
|
-
code:
|
|
311
|
+
code: z6.z.ZodIssueCode.custom
|
|
313
312
|
});
|
|
314
313
|
}
|
|
315
314
|
});
|
|
316
|
-
var
|
|
315
|
+
var getVaultSwapParameterEncodingRequestSchema = (network) => z6.z.object({
|
|
317
316
|
srcAsset: assetAndChain,
|
|
318
|
-
srcAddress:
|
|
317
|
+
srcAddress: z6.z.string().optional(),
|
|
319
318
|
destAsset: assetAndChain,
|
|
320
|
-
destAddress:
|
|
319
|
+
destAddress: z6.z.string(),
|
|
321
320
|
amount: unsignedInteger,
|
|
322
|
-
commissionBps:
|
|
321
|
+
commissionBps: z6.z.number().optional().default(0),
|
|
323
322
|
ccmParams: transformedCcmParamsSchema.optional(),
|
|
324
|
-
maxBoostFeeBps:
|
|
325
|
-
affiliates:
|
|
323
|
+
maxBoostFeeBps: z6.z.number().optional(),
|
|
324
|
+
affiliates: z6.z.array(affiliateBroker).optional(),
|
|
326
325
|
fillOrKillParams: transformedFokSchema,
|
|
327
326
|
dcaParams: transformedDcaParamsSchema.optional(),
|
|
328
|
-
extraParams:
|
|
327
|
+
extraParams: z6.z.object({ seed: hexString.optional() }).optional()
|
|
329
328
|
}).superRefine((val, ctx) => {
|
|
330
329
|
if (val.srcAddress && !validateAddress(val.srcAsset.chain, val.srcAddress, network)) {
|
|
331
330
|
ctx.addIssue({
|
|
332
331
|
message: `Address "${val.srcAddress}" is not a valid "${val.srcAsset.chain}" address for "${network}"`,
|
|
333
|
-
code:
|
|
332
|
+
code: z6.z.ZodIssueCode.custom
|
|
334
333
|
});
|
|
335
334
|
}
|
|
336
335
|
if (!validateAddress(val.destAsset.chain, val.destAddress, network)) {
|
|
337
336
|
ctx.addIssue({
|
|
338
337
|
message: `Address "${val.destAddress}" is not a valid "${val.destAsset.chain}" address for "${network}"`,
|
|
339
|
-
code:
|
|
338
|
+
code: z6.z.ZodIssueCode.custom
|
|
340
339
|
});
|
|
341
340
|
}
|
|
342
341
|
if (!validateAddress(val.srcAsset.chain, val.fillOrKillParams.refund_address, network)) {
|
|
343
342
|
ctx.addIssue({
|
|
344
343
|
message: `Address "${val.fillOrKillParams.refund_address}" is not a valid "${val.srcAsset.chain}" address for "${network}"`,
|
|
345
|
-
code:
|
|
344
|
+
code: z6.z.ZodIssueCode.custom
|
|
346
345
|
});
|
|
347
346
|
}
|
|
348
347
|
if (val.extraParams?.seed && val.extraParams.seed.length !== 66) {
|
|
349
|
-
ctx.addIssue({ message: "Seed must be 32 bytes", code:
|
|
348
|
+
ctx.addIssue({ message: "Seed must be 32 bytes", code: z6.z.ZodIssueCode.custom });
|
|
350
349
|
}
|
|
351
350
|
}).transform((data) => {
|
|
352
351
|
let extraParams;
|
|
353
352
|
if (data.srcAsset.chain === "Bitcoin") {
|
|
354
|
-
const minOutputAmount =
|
|
353
|
+
const minOutputAmount = BigNumber3__default.default(data.amount.toString()).multipliedBy(tickMath.priceX128ToPrice(data.fillOrKillParams.min_price)).toFixed(0);
|
|
355
354
|
extraParams = {
|
|
356
355
|
chain: "Bitcoin",
|
|
357
356
|
min_output_amount: `0x${BigInt(minOutputAmount).toString(16)}`,
|
|
@@ -417,7 +416,7 @@ async function requestSwapDepositAddress(request, opts, chainflipNetwork) {
|
|
|
417
416
|
}
|
|
418
417
|
async function requestSwapParameterEncoding(request, opts, chainflipNetwork) {
|
|
419
418
|
const client = new rpc.HttpClient(opts.url);
|
|
420
|
-
const params =
|
|
419
|
+
const params = getVaultSwapParameterEncodingRequestSchema(chainflipNetwork).parse(request);
|
|
421
420
|
const response = await client.sendRequest(
|
|
422
421
|
"broker_request_swap_parameter_encoding",
|
|
423
422
|
params.srcAsset,
|
|
@@ -432,6 +431,283 @@ async function requestSwapParameterEncoding(request, opts, chainflipNetwork) {
|
|
|
432
431
|
);
|
|
433
432
|
return transformKeysToCamelCase(response);
|
|
434
433
|
}
|
|
434
|
+
var cfParameterEncodingRequestSchema = z6.z.object({
|
|
435
|
+
srcAsset: assetAndChain,
|
|
436
|
+
srcAddress: z6.z.string().optional(),
|
|
437
|
+
destAsset: assetAndChain,
|
|
438
|
+
destAddress: z6.z.string(),
|
|
439
|
+
amount: unsignedInteger,
|
|
440
|
+
commissionBps: z6.z.number().optional().default(0),
|
|
441
|
+
ccmParams: transformedCcmParamsSchema.optional(),
|
|
442
|
+
maxBoostFeeBps: z6.z.number().optional(),
|
|
443
|
+
affiliates: z6.z.array(affiliateBroker).optional(),
|
|
444
|
+
fillOrKillParams: transformedFokSchema,
|
|
445
|
+
dcaParams: transformedDcaParamsSchema.optional(),
|
|
446
|
+
network: z6.z.enum(chainflip.chainflipNetworks)
|
|
447
|
+
}).superRefine(({ network, ...val }, ctx) => {
|
|
448
|
+
if (val.srcAddress && !validateAddress(val.srcAsset.chain, val.srcAddress, network)) {
|
|
449
|
+
ctx.addIssue({
|
|
450
|
+
message: `Address "${val.srcAddress}" is not a valid "${val.srcAsset.chain}" address for "${network}"`,
|
|
451
|
+
code: z6.z.ZodIssueCode.custom
|
|
452
|
+
});
|
|
453
|
+
}
|
|
454
|
+
if (!validateAddress(val.destAsset.chain, val.destAddress, network)) {
|
|
455
|
+
ctx.addIssue({
|
|
456
|
+
message: `Address "${val.destAddress}" is not a valid "${val.destAsset.chain}" address for "${network}"`,
|
|
457
|
+
code: z6.z.ZodIssueCode.custom
|
|
458
|
+
});
|
|
459
|
+
}
|
|
460
|
+
if (!validateAddress(val.srcAsset.chain, val.fillOrKillParams.refund_address, network)) {
|
|
461
|
+
ctx.addIssue({
|
|
462
|
+
message: `Address "${val.fillOrKillParams.refund_address}" is not a valid "${val.srcAsset.chain}" address for "${network}"`,
|
|
463
|
+
code: z6.z.ZodIssueCode.custom
|
|
464
|
+
});
|
|
465
|
+
}
|
|
466
|
+
}).transform(({ network, ...rest }) => rest);
|
|
467
|
+
async function requestCfParametersEncoding(request, opts) {
|
|
468
|
+
const client = new rpc.HttpClient(opts.url);
|
|
469
|
+
const params = cfParameterEncodingRequestSchema.parse(request);
|
|
470
|
+
const response = await client.sendRequest(
|
|
471
|
+
"broker_encode_cf_parameters",
|
|
472
|
+
params.srcAsset,
|
|
473
|
+
params.destAsset,
|
|
474
|
+
params.destAddress,
|
|
475
|
+
params.commissionBps,
|
|
476
|
+
params.fillOrKillParams,
|
|
477
|
+
params.ccmParams,
|
|
478
|
+
params.maxBoostFeeBps,
|
|
479
|
+
params.affiliates,
|
|
480
|
+
params.dcaParams
|
|
481
|
+
);
|
|
482
|
+
return response;
|
|
483
|
+
}
|
|
484
|
+
|
|
485
|
+
// ../shared/src/api/encodeCfParameters.ts
|
|
486
|
+
var CfParameterEncodingRequestWithBroker = cfParameterEncodingRequestSchema.and(
|
|
487
|
+
z6.z.object({
|
|
488
|
+
brokerAccount: chainflipAddress.optional()
|
|
489
|
+
})
|
|
490
|
+
);
|
|
491
|
+
var TransformedCcmParams = ccmParamsSchema.transform(
|
|
492
|
+
({ message, gasBudget, ccmAdditionalData }) => ({
|
|
493
|
+
message,
|
|
494
|
+
gas_budget: gasBudget,
|
|
495
|
+
ccm_additional_data: ccmAdditionalData,
|
|
496
|
+
/** @deprecated DEPRECATED(1.10) we still need to pass cf_parameters until 1.8 is deployed to all networks */
|
|
497
|
+
cf_parameters: ccmAdditionalData
|
|
498
|
+
})
|
|
499
|
+
);
|
|
500
|
+
var FillOrKillParams = fillOrKillParams.transform(
|
|
501
|
+
({ retryDurationBlocks, refundAddress, minPriceX128 }) => ({
|
|
502
|
+
retry_duration: retryDurationBlocks,
|
|
503
|
+
refund_address: refundAddress,
|
|
504
|
+
min_price: `0x${BigInt(minPriceX128).toString(16)}`
|
|
505
|
+
})
|
|
506
|
+
);
|
|
507
|
+
var TransformedDcaParams = dcaParams.transform(
|
|
508
|
+
({ numberOfChunks, chunkIntervalBlocks }) => ({
|
|
509
|
+
number_of_chunks: numberOfChunks,
|
|
510
|
+
chunk_interval: chunkIntervalBlocks
|
|
511
|
+
})
|
|
512
|
+
);
|
|
513
|
+
var EncodeVaultSwapBody = z6.z.object({
|
|
514
|
+
srcAsset: assetAndChain,
|
|
515
|
+
srcAddress: z6.z.string().optional(),
|
|
516
|
+
destAsset: assetAndChain,
|
|
517
|
+
destAddress: z6.z.string(),
|
|
518
|
+
amount: unsignedInteger,
|
|
519
|
+
commissionBps: z6.z.number().optional().default(0),
|
|
520
|
+
ccmParams: TransformedCcmParams.optional(),
|
|
521
|
+
maxBoostFeeBps: z6.z.number().optional(),
|
|
522
|
+
affiliates: z6.z.array(affiliateBroker).optional(),
|
|
523
|
+
fillOrKillParams: FillOrKillParams,
|
|
524
|
+
dcaParams: TransformedDcaParams.optional(),
|
|
525
|
+
extraParams: z6.z.object({ seed: hexString.optional() }).optional(),
|
|
526
|
+
network: z6.z.enum(chainflip.chainflipNetworks)
|
|
527
|
+
}).superRefine(({ network, ...val }, ctx) => {
|
|
528
|
+
if (val.srcAddress && !validateAddress(val.srcAsset.chain, val.srcAddress, network)) {
|
|
529
|
+
ctx.addIssue({
|
|
530
|
+
message: `Address "${val.srcAddress}" is not a valid "${val.srcAsset.chain}" address for "${network}"`,
|
|
531
|
+
code: z6.z.ZodIssueCode.custom
|
|
532
|
+
});
|
|
533
|
+
}
|
|
534
|
+
if (!validateAddress(val.destAsset.chain, val.destAddress, network)) {
|
|
535
|
+
ctx.addIssue({
|
|
536
|
+
message: `Address "${val.destAddress}" is not a valid "${val.destAsset.chain}" address for "${network}"`,
|
|
537
|
+
code: z6.z.ZodIssueCode.custom
|
|
538
|
+
});
|
|
539
|
+
}
|
|
540
|
+
if (!validateAddress(val.srcAsset.chain, val.fillOrKillParams.refund_address, network)) {
|
|
541
|
+
ctx.addIssue({
|
|
542
|
+
message: `Address "${val.fillOrKillParams.refund_address}" is not a valid "${val.srcAsset.chain}" address for "${network}"`,
|
|
543
|
+
code: z6.z.ZodIssueCode.custom
|
|
544
|
+
});
|
|
545
|
+
}
|
|
546
|
+
if (val.extraParams?.seed && val.extraParams.seed.length !== 66) {
|
|
547
|
+
ctx.addIssue({ message: "Seed must be 32 bytes", code: z6.z.ZodIssueCode.custom });
|
|
548
|
+
}
|
|
549
|
+
}).transform(({ network, ...data }) => {
|
|
550
|
+
let extraParams;
|
|
551
|
+
if (data.srcAsset.chain === "Bitcoin") {
|
|
552
|
+
const minOutputAmount = BigNumber(data.amount.toString()).multipliedBy(tickMath.priceX128ToPrice(data.fillOrKillParams.min_price)).toFixed(0);
|
|
553
|
+
extraParams = {
|
|
554
|
+
chain: "Bitcoin",
|
|
555
|
+
min_output_amount: `0x${BigInt(minOutputAmount).toString(16)}`,
|
|
556
|
+
retry_duration: data.fillOrKillParams.retry_duration
|
|
557
|
+
};
|
|
558
|
+
} else if (data.srcAsset.chain === "Ethereum" || data.srcAsset.chain === "Arbitrum") {
|
|
559
|
+
extraParams = {
|
|
560
|
+
chain: data.srcAsset.chain,
|
|
561
|
+
input_amount: `0x${data.amount.toString(16)}`,
|
|
562
|
+
refund_parameters: data.fillOrKillParams
|
|
563
|
+
};
|
|
564
|
+
} else if (data.srcAsset.chain === "Solana") {
|
|
565
|
+
assert(data.srcAddress, "srcAddress is required for Solana");
|
|
566
|
+
extraParams = {
|
|
567
|
+
chain: "Solana",
|
|
568
|
+
from: data.srcAddress,
|
|
569
|
+
seed: data.extraParams?.seed ?? bytes.bytesToHex(crypto.getRandomValues(new Uint8Array(32))),
|
|
570
|
+
input_amount: `0x${data.amount.toString(16)}`,
|
|
571
|
+
refund_parameters: data.fillOrKillParams
|
|
572
|
+
};
|
|
573
|
+
} else {
|
|
574
|
+
throw new Error(`parameter encoding is not supported for ${data.srcAsset.chain}`);
|
|
575
|
+
}
|
|
576
|
+
return { ...data, extraParams };
|
|
577
|
+
});
|
|
578
|
+
var EncodedVaultSwapData = z6.z.discriminatedUnion("chain", [
|
|
579
|
+
z6.z.object({
|
|
580
|
+
chain: z6.z.literal("Bitcoin"),
|
|
581
|
+
nulldataPayload: hexString,
|
|
582
|
+
depositAddress: z6.z.string()
|
|
583
|
+
}),
|
|
584
|
+
z6.z.object({
|
|
585
|
+
chain: z6.z.enum(["Ethereum", "Arbitrum"]),
|
|
586
|
+
value: z6.z.string(),
|
|
587
|
+
to: hexString,
|
|
588
|
+
calldata: hexString,
|
|
589
|
+
sourceTokenAddress: hexString.optional()
|
|
590
|
+
}),
|
|
591
|
+
z6.z.object({
|
|
592
|
+
chain: z6.z.literal("Solana"),
|
|
593
|
+
programId: z6.z.string(),
|
|
594
|
+
data: hexString,
|
|
595
|
+
accounts: z6.z.array(
|
|
596
|
+
z6.z.object({
|
|
597
|
+
pubkey: z6.z.string(),
|
|
598
|
+
isSigner: z6.z.boolean(),
|
|
599
|
+
isWritable: z6.z.boolean()
|
|
600
|
+
})
|
|
601
|
+
)
|
|
602
|
+
})
|
|
603
|
+
]);
|
|
604
|
+
var NetworkInfo = z6__default.default.object({
|
|
605
|
+
assets: z6__default.default.array(
|
|
606
|
+
z6__default.default.object({
|
|
607
|
+
asset: z6__default.default.enum(chainflip.chainflipAssets),
|
|
608
|
+
vaultSwapDepositsEnabled: z6__default.default.boolean(),
|
|
609
|
+
depositChannelDepositsEnabled: z6__default.default.boolean(),
|
|
610
|
+
depositChannelCreationEnabled: z6__default.default.boolean(),
|
|
611
|
+
egressEnabled: z6__default.default.boolean(),
|
|
612
|
+
boostDepositsEnabled: z6__default.default.boolean()
|
|
613
|
+
})
|
|
614
|
+
),
|
|
615
|
+
cfBrokerCommissionBps: z6__default.default.number()
|
|
616
|
+
});
|
|
617
|
+
var ChainflipAsset = z6.z.enum(chainflip.chainflipAssets);
|
|
618
|
+
var NetworkStatus = z6.z.object({
|
|
619
|
+
assets: z6.z.object({
|
|
620
|
+
deposit: z6.z.array(ChainflipAsset),
|
|
621
|
+
destination: z6.z.array(ChainflipAsset),
|
|
622
|
+
all: z6.z.array(ChainflipAsset)
|
|
623
|
+
}),
|
|
624
|
+
boostDepositsEnabled: z6.z.boolean(),
|
|
625
|
+
cfBrokerCommissionBps: z6.z.number()
|
|
626
|
+
});
|
|
627
|
+
var OpenSwapDepositChannelBody = z6.z.object({
|
|
628
|
+
srcAsset: asset,
|
|
629
|
+
destAsset: asset,
|
|
630
|
+
srcChain: chain,
|
|
631
|
+
destChain: chain,
|
|
632
|
+
destAddress: z6.z.string(),
|
|
633
|
+
amount: numericString,
|
|
634
|
+
ccmParams: ccmParamsSchema.optional(),
|
|
635
|
+
maxBoostFeeBps: z6.z.number().optional(),
|
|
636
|
+
srcAddress: z6.z.string().optional(),
|
|
637
|
+
fillOrKillParams,
|
|
638
|
+
dcaParams: dcaParams.optional(),
|
|
639
|
+
quote: z6.z.object({
|
|
640
|
+
intermediateAmount: z6.z.string().optional(),
|
|
641
|
+
egressAmount: z6.z.string(),
|
|
642
|
+
estimatedPrice: z6.z.string(),
|
|
643
|
+
recommendedSlippageTolerancePercent: z6.z.number().optional()
|
|
644
|
+
}).optional(),
|
|
645
|
+
takeCommission: z6.z.boolean().optional()
|
|
646
|
+
}).transform(({ amount, ...rest }) => ({
|
|
647
|
+
...rest,
|
|
648
|
+
expectedDepositAmount: amount
|
|
649
|
+
}));
|
|
650
|
+
var DepositChannelInfo = z6.z.object({
|
|
651
|
+
id: z6.z.string(),
|
|
652
|
+
depositAddress: z6.z.string(),
|
|
653
|
+
brokerCommissionBps: z6.z.number(),
|
|
654
|
+
maxBoostFeeBps: z6.z.number(),
|
|
655
|
+
issuedBlock: z6.z.number(),
|
|
656
|
+
srcChainExpiryBlock: z6.z.string(),
|
|
657
|
+
estimatedExpiryTime: z6.z.number().optional(),
|
|
658
|
+
channelOpeningFee: z6.z.string()
|
|
659
|
+
});
|
|
660
|
+
|
|
661
|
+
// ../shared/src/api/contract.ts
|
|
662
|
+
var c = core.initContract();
|
|
663
|
+
var apiContract = c.router(
|
|
664
|
+
{
|
|
665
|
+
/** @deprecated DEPRECATED(1.9): using `networkInfo` now */
|
|
666
|
+
networkStatus: {
|
|
667
|
+
method: "GET",
|
|
668
|
+
path: "/networkStatus",
|
|
669
|
+
responses: {
|
|
670
|
+
200: NetworkStatus
|
|
671
|
+
},
|
|
672
|
+
summary: "Get information about the Chainflip network"
|
|
673
|
+
},
|
|
674
|
+
networkInfo: {
|
|
675
|
+
method: "GET",
|
|
676
|
+
path: "/networkInfo",
|
|
677
|
+
responses: {
|
|
678
|
+
200: NetworkInfo
|
|
679
|
+
},
|
|
680
|
+
summary: "Get information about the Chainflip network"
|
|
681
|
+
},
|
|
682
|
+
encodeCfParameters: {
|
|
683
|
+
method: "POST",
|
|
684
|
+
path: "/encodeCfParameters",
|
|
685
|
+
body: CfParameterEncodingRequestWithBroker,
|
|
686
|
+
responses: {
|
|
687
|
+
200: hexString
|
|
688
|
+
}
|
|
689
|
+
},
|
|
690
|
+
encodeVaultSwapData: {
|
|
691
|
+
method: "POST",
|
|
692
|
+
path: "/encodeVaultSwapData",
|
|
693
|
+
body: EncodeVaultSwapBody,
|
|
694
|
+
responses: {
|
|
695
|
+
200: EncodedVaultSwapData
|
|
696
|
+
}
|
|
697
|
+
},
|
|
698
|
+
openSwapDepositChannel: {
|
|
699
|
+
method: "POST",
|
|
700
|
+
path: "/openSwapDepositChannel",
|
|
701
|
+
body: OpenSwapDepositChannelBody,
|
|
702
|
+
responses: {
|
|
703
|
+
201: DepositChannelInfo
|
|
704
|
+
}
|
|
705
|
+
}
|
|
706
|
+
},
|
|
707
|
+
{
|
|
708
|
+
pathPrefix: "/api"
|
|
709
|
+
}
|
|
710
|
+
);
|
|
435
711
|
|
|
436
712
|
// ../shared/src/dataStructures.ts
|
|
437
713
|
var MultiCache = class {
|
|
@@ -455,7 +731,7 @@ var MultiCache = class {
|
|
|
455
731
|
return cached.value;
|
|
456
732
|
}
|
|
457
733
|
};
|
|
458
|
-
var getPriceX128FromPrice = (price, srcAsset, destAsset) =>
|
|
734
|
+
var getPriceX128FromPrice = (price, srcAsset, destAsset) => BigNumber3__default.default(price).multipliedBy(new BigNumber3__default.default(2).pow(128)).shiftedBy(chainflip.assetConstants[destAsset].decimals - chainflip.assetConstants[srcAsset].decimals).toFixed(0);
|
|
459
735
|
function parseFoKParams(params, quote) {
|
|
460
736
|
const srcAsset = chainflip.getInternalAsset(quote.srcAsset);
|
|
461
737
|
const destAsset = chainflip.getInternalAsset(quote.destAsset);
|
|
@@ -467,16 +743,16 @@ function parseFoKParams(params, quote) {
|
|
|
467
743
|
);
|
|
468
744
|
minPrice = params.minPrice;
|
|
469
745
|
} else if ("slippageTolerancePercent" in params) {
|
|
470
|
-
const tolerance = new
|
|
746
|
+
const tolerance = new BigNumber3__default.default(params.slippageTolerancePercent);
|
|
471
747
|
assert(!tolerance.isNaN(), "Invalid slippage tolerance");
|
|
472
748
|
assert(
|
|
473
749
|
tolerance.gte(0) && tolerance.lte(100),
|
|
474
750
|
"Slippage tolerance must be between 0 and 100 inclusive",
|
|
475
751
|
RangeError
|
|
476
752
|
);
|
|
477
|
-
const estimatedPrice = new
|
|
753
|
+
const estimatedPrice = new BigNumber3__default.default(quote.estimatedPrice);
|
|
478
754
|
assert(!estimatedPrice.isNaN(), "Invalid estimated price");
|
|
479
|
-
minPrice = estimatedPrice.times(new
|
|
755
|
+
minPrice = estimatedPrice.times(new BigNumber3__default.default(100).minus(tolerance).dividedBy(100)).toFixed(chainflip.assetConstants[destAsset].decimals);
|
|
480
756
|
} else {
|
|
481
757
|
throw new Error("Either minPrice or slippageTolerancePercent must be provided");
|
|
482
758
|
}
|
|
@@ -656,7 +932,7 @@ var getChainData = (chain2, network, env) => ({
|
|
|
656
932
|
|
|
657
933
|
// package.json
|
|
658
934
|
var package_default = {
|
|
659
|
-
version: "1.
|
|
935
|
+
version: "1.10.0"};
|
|
660
936
|
|
|
661
937
|
// src/swap/consts.ts
|
|
662
938
|
var CF_SDK_VERSION_HEADERS = { "X-Chainflip-Sdk-Version": package_default.version };
|
|
@@ -718,7 +994,7 @@ var assertQuoteValid = (quote) => {
|
|
|
718
994
|
var SwapSDK = class {
|
|
719
995
|
options;
|
|
720
996
|
rpcConfig;
|
|
721
|
-
|
|
997
|
+
apiClient;
|
|
722
998
|
cache;
|
|
723
999
|
dcaEnabled = false;
|
|
724
1000
|
constructor(options = {}) {
|
|
@@ -729,14 +1005,11 @@ var SwapSDK = class {
|
|
|
729
1005
|
backendUrl: options.backendUrl ?? BACKEND_SERVICE_URLS[network]
|
|
730
1006
|
};
|
|
731
1007
|
this.rpcConfig = options.rpcUrl ? { rpcUrl: options.rpcUrl } : { network };
|
|
732
|
-
this.
|
|
733
|
-
|
|
734
|
-
|
|
735
|
-
|
|
736
|
-
|
|
737
|
-
headers: CF_SDK_VERSION_HEADERS
|
|
738
|
-
})
|
|
739
|
-
]
|
|
1008
|
+
this.apiClient = core.initClient(apiContract, {
|
|
1009
|
+
// remove trailing slashes. this bug has been fixed in `@ts-rest/core`
|
|
1010
|
+
// but it hasn't been released yet
|
|
1011
|
+
baseUrl: this.options.backendUrl.replace(/\/+$/, ""),
|
|
1012
|
+
baseHeaders: CF_SDK_VERSION_HEADERS
|
|
740
1013
|
});
|
|
741
1014
|
this.dcaEnabled = options.enabledFeatures?.dca ?? false;
|
|
742
1015
|
this.cache = new MultiCache({
|
|
@@ -744,8 +1017,12 @@ var SwapSDK = class {
|
|
|
744
1017
|
fetch: () => getEnvironment(this.rpcConfig),
|
|
745
1018
|
ttl: 6e4
|
|
746
1019
|
},
|
|
747
|
-
|
|
748
|
-
fetch: () =>
|
|
1020
|
+
networkInfo: {
|
|
1021
|
+
fetch: async () => {
|
|
1022
|
+
const res = await this.apiClient.networkInfo();
|
|
1023
|
+
assert(res.status === 200, "Failed to fetch network info");
|
|
1024
|
+
return res.body;
|
|
1025
|
+
},
|
|
749
1026
|
ttl: 6e4
|
|
750
1027
|
}
|
|
751
1028
|
});
|
|
@@ -766,8 +1043,23 @@ var SwapSDK = class {
|
|
|
766
1043
|
return this.cache.read("environment");
|
|
767
1044
|
}
|
|
768
1045
|
async getSupportedAssets(type) {
|
|
769
|
-
const assets = await this.cache.read("
|
|
770
|
-
return assets.assets
|
|
1046
|
+
const assets = await this.cache.read("networkInfo");
|
|
1047
|
+
return assets.assets.filter((a) => {
|
|
1048
|
+
switch (type) {
|
|
1049
|
+
case "all":
|
|
1050
|
+
return true;
|
|
1051
|
+
case "deposit":
|
|
1052
|
+
return a.depositChannelCreationEnabled && a.depositChannelDepositsEnabled && a.vaultSwapDepositsEnabled;
|
|
1053
|
+
case "destination":
|
|
1054
|
+
return a.egressEnabled;
|
|
1055
|
+
case "depositChannel":
|
|
1056
|
+
return a.depositChannelCreationEnabled && a.depositChannelDepositsEnabled;
|
|
1057
|
+
case "vaultSwap":
|
|
1058
|
+
return a.vaultSwapDepositsEnabled;
|
|
1059
|
+
default:
|
|
1060
|
+
return assertion.unreachable(type, "unexpected type");
|
|
1061
|
+
}
|
|
1062
|
+
}).map((a) => a.asset);
|
|
771
1063
|
}
|
|
772
1064
|
async getBoostPoolsDepth() {
|
|
773
1065
|
return getAllBoostPoolsDepth(this.rpcConfig);
|
|
@@ -786,7 +1078,7 @@ var SwapSDK = class {
|
|
|
786
1078
|
}
|
|
787
1079
|
async getCommissionBps(brokerCommissionBps) {
|
|
788
1080
|
if (this.shouldTakeCommission()) {
|
|
789
|
-
return (await this.cache.read("
|
|
1081
|
+
return (await this.cache.read("networkInfo")).cfBrokerCommissionBps;
|
|
790
1082
|
}
|
|
791
1083
|
return brokerCommissionBps ?? this.options.broker?.commissionBps ?? 0;
|
|
792
1084
|
}
|
|
@@ -914,11 +1206,15 @@ var SwapSDK = class {
|
|
|
914
1206
|
!affiliates?.length,
|
|
915
1207
|
"Affiliate brokers are supported only when initializing the SDK with a brokerUrl"
|
|
916
1208
|
);
|
|
917
|
-
|
|
918
|
-
|
|
919
|
-
|
|
920
|
-
|
|
1209
|
+
const res = await this.apiClient.openSwapDepositChannel({
|
|
1210
|
+
body: {
|
|
1211
|
+
...depositAddressRequest,
|
|
1212
|
+
quote,
|
|
1213
|
+
takeCommission: this.shouldTakeCommission()
|
|
1214
|
+
}
|
|
921
1215
|
});
|
|
1216
|
+
assert(res.status === 201, "Failed to open swap deposit channel");
|
|
1217
|
+
response = res.body;
|
|
922
1218
|
}
|
|
923
1219
|
return {
|
|
924
1220
|
...depositAddressRequest,
|
|
@@ -927,9 +1223,9 @@ var SwapSDK = class {
|
|
|
927
1223
|
brokerCommissionBps: response.brokerCommissionBps,
|
|
928
1224
|
affiliateBrokers: affiliates ?? [],
|
|
929
1225
|
maxBoostFeeBps: Number(response.maxBoostFeeBps) || 0,
|
|
930
|
-
depositChannelExpiryBlock: response.srcChainExpiryBlock,
|
|
1226
|
+
depositChannelExpiryBlock: BigInt(response.srcChainExpiryBlock),
|
|
931
1227
|
estimatedDepositChannelExpiryTime: response.estimatedExpiryTime,
|
|
932
|
-
channelOpeningFee: response.channelOpeningFee,
|
|
1228
|
+
channelOpeningFee: BigInt(response.channelOpeningFee),
|
|
933
1229
|
fillOrKillParams: inputFoKParams
|
|
934
1230
|
};
|
|
935
1231
|
}
|
|
@@ -987,7 +1283,73 @@ var SwapSDK = class {
|
|
|
987
1283
|
!vaultSwapRequest.affiliates?.length || vaultSwapRequest.brokerAccount,
|
|
988
1284
|
"Affiliate brokers are supported only when setting a broker account"
|
|
989
1285
|
);
|
|
990
|
-
|
|
1286
|
+
const res = await this.apiClient.encodeVaultSwapData({
|
|
1287
|
+
body: { ...vaultSwapRequest, network: this.options.network }
|
|
1288
|
+
});
|
|
1289
|
+
if (res.status !== 200) {
|
|
1290
|
+
throw new Error("Failed to encode vault swap data", { cause: res });
|
|
1291
|
+
}
|
|
1292
|
+
switch (res.body.chain) {
|
|
1293
|
+
case "Arbitrum":
|
|
1294
|
+
case "Ethereum":
|
|
1295
|
+
return { ...res.body, value: BigInt(res.body.value) };
|
|
1296
|
+
default:
|
|
1297
|
+
return res.body;
|
|
1298
|
+
}
|
|
1299
|
+
}
|
|
1300
|
+
async encodeCfParameters({
|
|
1301
|
+
quote,
|
|
1302
|
+
srcAddress,
|
|
1303
|
+
destAddress,
|
|
1304
|
+
fillOrKillParams: fillOrKillParams2,
|
|
1305
|
+
affiliateBrokers: affiliates,
|
|
1306
|
+
ccmParams,
|
|
1307
|
+
brokerAccount,
|
|
1308
|
+
brokerCommissionBps
|
|
1309
|
+
}) {
|
|
1310
|
+
await this.validateSwapAmount(quote.srcAsset, BigInt(quote.depositAmount));
|
|
1311
|
+
assertQuoteValid(quote);
|
|
1312
|
+
if (ccmParams) {
|
|
1313
|
+
assert(quote.ccmParams, "Cannot encode CCM swap for quote without CCM params");
|
|
1314
|
+
} else {
|
|
1315
|
+
assert(!quote.ccmParams, "Cannot encode regular swap for quote with CCM params");
|
|
1316
|
+
}
|
|
1317
|
+
const requestParams = {
|
|
1318
|
+
srcAsset: quote.srcAsset,
|
|
1319
|
+
destAsset: quote.destAsset,
|
|
1320
|
+
srcAddress,
|
|
1321
|
+
destAddress,
|
|
1322
|
+
amount: quote.depositAmount,
|
|
1323
|
+
ccmParams,
|
|
1324
|
+
maxBoostFeeBps: "maxBoostFeeBps" in quote ? quote.maxBoostFeeBps : void 0,
|
|
1325
|
+
fillOrKillParams: parseFoKParams(fillOrKillParams2, quote),
|
|
1326
|
+
dcaParams: quote.type === "DCA" ? quote.dcaParams : void 0,
|
|
1327
|
+
commissionBps: await this.getCommissionBps(brokerCommissionBps),
|
|
1328
|
+
affiliates,
|
|
1329
|
+
network: this.options.network
|
|
1330
|
+
};
|
|
1331
|
+
if (this.options.broker) {
|
|
1332
|
+
assert(
|
|
1333
|
+
!brokerAccount,
|
|
1334
|
+
"Cannot overwrite broker account when initializing the SDK with a brokerUrl"
|
|
1335
|
+
);
|
|
1336
|
+
return requestCfParametersEncoding(requestParams, { url: this.options.broker.url });
|
|
1337
|
+
}
|
|
1338
|
+
assert(
|
|
1339
|
+
!requestParams.commissionBps || brokerAccount || this.shouldTakeCommission(),
|
|
1340
|
+
"Broker commission is supported only when setting a broker account"
|
|
1341
|
+
);
|
|
1342
|
+
assert(
|
|
1343
|
+
!requestParams.affiliates?.length || brokerAccount,
|
|
1344
|
+
"Affiliate brokers are supported only when setting a broker account"
|
|
1345
|
+
);
|
|
1346
|
+
const res = await this.apiClient.encodeCfParameters({
|
|
1347
|
+
body: { ...requestParams, brokerAccount }
|
|
1348
|
+
});
|
|
1349
|
+
if (res.status !== 200) {
|
|
1350
|
+
throw new Error("Failed to encode cf parameters", { cause: res });
|
|
1351
|
+
}
|
|
1352
|
+
return res.body;
|
|
991
1353
|
}
|
|
992
1354
|
// eslint-disable-next-line class-methods-use-this
|
|
993
1355
|
getOnChainSwapExtrinsicArgs({
|
|
@@ -1009,8 +1371,8 @@ var SwapSDK = class {
|
|
|
1009
1371
|
];
|
|
1010
1372
|
}
|
|
1011
1373
|
async checkBoostEnabled() {
|
|
1012
|
-
const {
|
|
1013
|
-
return boostDepositsEnabled;
|
|
1374
|
+
const { assets } = await this.cache.read("networkInfo");
|
|
1375
|
+
return assets.find((a) => a.asset === "Btc")?.boostDepositsEnabled ?? true;
|
|
1014
1376
|
}
|
|
1015
1377
|
};
|
|
1016
1378
|
var arrayToMap = (array) => Object.fromEntries(array.map((item) => [item, item]));
|