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