@chainflip/sdk 2.3.3 → 2.3.4-dev.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/swap.cjs +282 -193
- package/dist/swap.d.cts +26 -7
- package/dist/swap.d.ts +26 -7
- package/dist/swap.js +271 -182
- package/package.json +1 -1
package/dist/swap.cjs
CHANGED
|
@@ -12,9 +12,9 @@ var BigNumber2 = require('bignumber.js');
|
|
|
12
12
|
var zod = require('zod');
|
|
13
13
|
var solana = require('@chainflip/solana');
|
|
14
14
|
var tron = require('@chainflip/utils/tron');
|
|
15
|
-
var number = require('@chainflip/utils/number');
|
|
16
15
|
var bitcoin = require('@chainflip/bitcoin');
|
|
17
16
|
var ethers = require('ethers');
|
|
17
|
+
var number = require('@chainflip/utils/number');
|
|
18
18
|
var consts = require('@chainflip/utils/consts');
|
|
19
19
|
var axios = require('axios');
|
|
20
20
|
|
|
@@ -45,25 +45,6 @@ var ethers__namespace = /*#__PURE__*/_interopNamespace(ethers);
|
|
|
45
45
|
var axios__default = /*#__PURE__*/_interopDefault(axios);
|
|
46
46
|
|
|
47
47
|
// src/swap/sdk.ts
|
|
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
48
|
var booleanString = zod.z.string().regex(/^(true|false)$/i).transform((v) => v.toLowerCase() === "true");
|
|
68
49
|
var numericString = zod.z.string().regex(/^[0-9]+$/);
|
|
69
50
|
var numericOrEmptyString = zod.z.string().regex(/^[0-9]*$/);
|
|
@@ -108,6 +89,132 @@ var uncheckedAssetAndChain = zod.z.object({
|
|
|
108
89
|
var assetAndChain = uncheckedAssetAndChain.refine(
|
|
109
90
|
(value) => chain.safeParse(value.chain).success && asset.safeParse(value.asset).success && chainflip.isValidAssetAndChain(value)
|
|
110
91
|
);
|
|
92
|
+
|
|
93
|
+
// ../shared/src/guards.ts
|
|
94
|
+
var isNotNullish = (value) => value !== null && value !== void 0;
|
|
95
|
+
function assert(condition, message, Constructor = Error) {
|
|
96
|
+
if (condition) return;
|
|
97
|
+
const error = new Constructor(message);
|
|
98
|
+
if (error.stack) {
|
|
99
|
+
error.stack = error.stack.replace(/\n.+/, "\n");
|
|
100
|
+
}
|
|
101
|
+
throw error;
|
|
102
|
+
}
|
|
103
|
+
|
|
104
|
+
// ../shared/src/validation/addressValidation.ts
|
|
105
|
+
var validatePolkadotAddress = (address) => {
|
|
106
|
+
if (string.isHex(address)) return address.length === 66;
|
|
107
|
+
try {
|
|
108
|
+
ss58__namespace.decode(address);
|
|
109
|
+
return true;
|
|
110
|
+
} catch {
|
|
111
|
+
return false;
|
|
112
|
+
}
|
|
113
|
+
};
|
|
114
|
+
var validateEvmAddress = (address) => ethers__namespace.isAddress(address);
|
|
115
|
+
var validateBitcoinMainnetAddress = (address) => bitcoin__namespace.isValidAddressForNetwork(address, "mainnet");
|
|
116
|
+
var validateBitcoinTestnetAddress = (address) => bitcoin__namespace.isValidAddressForNetwork(address, "testnet");
|
|
117
|
+
var validateBitcoinRegtestAddress = (address) => bitcoin__namespace.isValidAddressForNetwork(address, "regtest");
|
|
118
|
+
var validateSolanaAddress = solana.isValidSolanaAddress;
|
|
119
|
+
var validateTronAddress = tron.isValidTronAddress;
|
|
120
|
+
var validators = {
|
|
121
|
+
mainnet: {
|
|
122
|
+
Bitcoin: validateBitcoinMainnetAddress,
|
|
123
|
+
Ethereum: validateEvmAddress,
|
|
124
|
+
Arbitrum: validateEvmAddress,
|
|
125
|
+
Solana: validateSolanaAddress,
|
|
126
|
+
Assethub: validatePolkadotAddress,
|
|
127
|
+
Tron: validateTronAddress,
|
|
128
|
+
Bsc: validateEvmAddress
|
|
129
|
+
},
|
|
130
|
+
perseverance: {
|
|
131
|
+
Bitcoin: validateBitcoinTestnetAddress,
|
|
132
|
+
Ethereum: validateEvmAddress,
|
|
133
|
+
Arbitrum: validateEvmAddress,
|
|
134
|
+
Solana: validateSolanaAddress,
|
|
135
|
+
Assethub: validatePolkadotAddress,
|
|
136
|
+
Tron: validateTronAddress,
|
|
137
|
+
Bsc: validateEvmAddress
|
|
138
|
+
},
|
|
139
|
+
sisyphos: {
|
|
140
|
+
Bitcoin: validateBitcoinTestnetAddress,
|
|
141
|
+
Ethereum: validateEvmAddress,
|
|
142
|
+
Arbitrum: validateEvmAddress,
|
|
143
|
+
Solana: validateSolanaAddress,
|
|
144
|
+
Assethub: validatePolkadotAddress,
|
|
145
|
+
Tron: validateTronAddress,
|
|
146
|
+
Bsc: validateEvmAddress
|
|
147
|
+
},
|
|
148
|
+
backspin: {
|
|
149
|
+
Bitcoin: validateBitcoinRegtestAddress,
|
|
150
|
+
Ethereum: validateEvmAddress,
|
|
151
|
+
Arbitrum: validateEvmAddress,
|
|
152
|
+
Solana: validateSolanaAddress,
|
|
153
|
+
Assethub: validatePolkadotAddress,
|
|
154
|
+
Tron: validateTronAddress,
|
|
155
|
+
Bsc: validateEvmAddress
|
|
156
|
+
},
|
|
157
|
+
localnet: {
|
|
158
|
+
Bitcoin: validateBitcoinRegtestAddress,
|
|
159
|
+
Ethereum: validateEvmAddress,
|
|
160
|
+
Arbitrum: validateEvmAddress,
|
|
161
|
+
Solana: validateSolanaAddress,
|
|
162
|
+
Assethub: validatePolkadotAddress,
|
|
163
|
+
Tron: validateTronAddress,
|
|
164
|
+
Bsc: validateEvmAddress
|
|
165
|
+
}
|
|
166
|
+
};
|
|
167
|
+
var validateAddress = (chain2, address, network) => Object.hasOwn(validators, network) && Object.hasOwn(validators[network], chain2) && validators[network][chain2](address);
|
|
168
|
+
|
|
169
|
+
// ../shared/src/api/openAccountCreationDepositChannel.ts
|
|
170
|
+
var getAccountCreationDepositChannelSchema = (network) => zod.z.object({
|
|
171
|
+
signatureData: zod.z.object({
|
|
172
|
+
Ethereum: zod.z.object({
|
|
173
|
+
signature: hexString,
|
|
174
|
+
signer: hexString,
|
|
175
|
+
sigType: zod.z.literal("Eip712")
|
|
176
|
+
}).transform(({ sigType, ...rest }) => ({
|
|
177
|
+
sig_type: sigType,
|
|
178
|
+
...rest
|
|
179
|
+
}))
|
|
180
|
+
}),
|
|
181
|
+
transactionMetadata: zod.z.object({
|
|
182
|
+
nonce: u32,
|
|
183
|
+
expiryBlock: u32.positive()
|
|
184
|
+
}).transform(({ nonce, expiryBlock }) => ({
|
|
185
|
+
nonce,
|
|
186
|
+
expiry_block: expiryBlock
|
|
187
|
+
})),
|
|
188
|
+
asset: assetAndChain,
|
|
189
|
+
refundAddress: zod.z.string(),
|
|
190
|
+
boostFeeBps: u16.optional().default(0)
|
|
191
|
+
}).superRefine(({ asset: asset2, refundAddress }, ctx) => {
|
|
192
|
+
if (!validateAddress(asset2.chain, refundAddress, network)) {
|
|
193
|
+
ctx.addIssue({
|
|
194
|
+
message: `Address "${refundAddress}" is not a valid "${asset2.chain}" address for "${network}"`,
|
|
195
|
+
code: zod.z.ZodIssueCode.custom
|
|
196
|
+
});
|
|
197
|
+
}
|
|
198
|
+
});
|
|
199
|
+
|
|
200
|
+
// ../shared/src/strings.ts
|
|
201
|
+
var toCamelCase = (str) => str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
|
|
202
|
+
|
|
203
|
+
// ../shared/src/objects.ts
|
|
204
|
+
var transformKeysToCamelCase = (obj) => {
|
|
205
|
+
if (Array.isArray(obj)) {
|
|
206
|
+
return obj.map(transformKeysToCamelCase);
|
|
207
|
+
}
|
|
208
|
+
if (obj !== null && typeof obj === "object") {
|
|
209
|
+
return Object.fromEntries(
|
|
210
|
+
Object.entries(obj).map(([key, value]) => [
|
|
211
|
+
toCamelCase(key),
|
|
212
|
+
transformKeysToCamelCase(value)
|
|
213
|
+
])
|
|
214
|
+
);
|
|
215
|
+
}
|
|
216
|
+
return obj;
|
|
217
|
+
};
|
|
111
218
|
zod.z.object({
|
|
112
219
|
srcChain: chain,
|
|
113
220
|
srcAsset: asset,
|
|
@@ -225,82 +332,6 @@ zod.z.object({
|
|
|
225
332
|
refundCcmMetadata: ccmParamsSchema.nullish().optional().default(null)
|
|
226
333
|
});
|
|
227
334
|
|
|
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");
|
|
235
|
-
}
|
|
236
|
-
throw error;
|
|
237
|
-
}
|
|
238
|
-
|
|
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;
|
|
247
|
-
}
|
|
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
|
|
300
|
-
}
|
|
301
|
-
};
|
|
302
|
-
var validateAddress = (chain2, address, network) => Object.hasOwn(validators, network) && Object.hasOwn(validators[network], chain2) && validators[network][chain2](address);
|
|
303
|
-
|
|
304
335
|
// ../shared/src/broker.ts
|
|
305
336
|
var transformedDcaParamsSchema = dcaParams.transform(
|
|
306
337
|
({ numberOfChunks, chunkIntervalBlocks }) => ({
|
|
@@ -373,6 +404,7 @@ var getVaultSwapParameterEncodingRequestSchema = (network) => zod.z.object({
|
|
|
373
404
|
fillOrKillParams: transformedFokSchema,
|
|
374
405
|
dcaParams: transformedDcaParamsSchema.optional(),
|
|
375
406
|
extraParams: zod.z.object({ seed: hexString.optional() }).optional(),
|
|
407
|
+
// TODO: remove after brokerAccount is deprecated
|
|
376
408
|
brokerAccount: chainflipAddress.optional()
|
|
377
409
|
}).superRefine((val, ctx) => {
|
|
378
410
|
if (val.srcAddress && !validateAddress(val.srcAsset.chain, val.srcAddress, network)) {
|
|
@@ -498,6 +530,7 @@ var getParameterEncodingRequestSchema = (network) => zod.z.object({
|
|
|
498
530
|
affiliates: zod.z.array(affiliateBroker).optional(),
|
|
499
531
|
fillOrKillParams: transformedFokSchema,
|
|
500
532
|
dcaParams: transformedDcaParamsSchema.optional(),
|
|
533
|
+
// TODO: remove after brokerAccount is deprecated
|
|
501
534
|
brokerAccount: chainflipAddress.optional()
|
|
502
535
|
}).superRefine(({ ...val }, ctx) => {
|
|
503
536
|
if (val.srcAddress && !validateAddress(val.srcAsset.chain, val.srcAddress, network)) {
|
|
@@ -536,6 +569,22 @@ async function requestCfParametersEncoding(request, opts, network) {
|
|
|
536
569
|
);
|
|
537
570
|
return response;
|
|
538
571
|
}
|
|
572
|
+
async function requestAccountCreationDepositAddress(request, opts, network) {
|
|
573
|
+
const client = new rpc.HttpClient(opts.url);
|
|
574
|
+
const params = getAccountCreationDepositChannelSchema(network).parse(request);
|
|
575
|
+
const response = await client.sendRequest(
|
|
576
|
+
"broker_request_account_creation_deposit_address",
|
|
577
|
+
params.signatureData,
|
|
578
|
+
params.transactionMetadata,
|
|
579
|
+
params.asset,
|
|
580
|
+
params.boostFeeBps,
|
|
581
|
+
params.refundAddress
|
|
582
|
+
);
|
|
583
|
+
return {
|
|
584
|
+
...transformKeysToCamelCase(response),
|
|
585
|
+
address: formatBrokerDepositAddress(params.asset.chain, response.address)
|
|
586
|
+
};
|
|
587
|
+
}
|
|
539
588
|
|
|
540
589
|
// ../shared/src/consts.ts
|
|
541
590
|
var ETHEREUM_EVM_CHAIN_ID = {
|
|
@@ -731,6 +780,17 @@ function parseFoKParams(params, quote) {
|
|
|
731
780
|
return "refundAddress" in params ? { ...parsed, refundAddress: params.refundAddress } : parsed;
|
|
732
781
|
}
|
|
733
782
|
var isTestnet = (network) => network !== "mainnet";
|
|
783
|
+
function calculateExpiryTime(args) {
|
|
784
|
+
const { chainInfo, expiryBlock } = args;
|
|
785
|
+
if (chainInfo == null || expiryBlock == null) {
|
|
786
|
+
return null;
|
|
787
|
+
}
|
|
788
|
+
const remainingBlocks = Number(BigInt(expiryBlock) - BigInt(chainInfo.height));
|
|
789
|
+
const { blockTimeSeconds } = chainflip.anyChainConstants[chainInfo.chain];
|
|
790
|
+
return new Date(
|
|
791
|
+
new Date(chainInfo.blockTrackedAt).getTime() + remainingBlocks * blockTimeSeconds * 1e3
|
|
792
|
+
);
|
|
793
|
+
}
|
|
734
794
|
var camelCase = (str) => str.replace(/_([a-z])/g, (_, char) => char.toUpperCase());
|
|
735
795
|
var camelCaseKeys = (obj) => {
|
|
736
796
|
if (typeof obj !== "object" || obj === null) return obj;
|
|
@@ -839,7 +899,7 @@ var getChainData = (chain2, network, env) => ({
|
|
|
839
899
|
|
|
840
900
|
// package.json
|
|
841
901
|
var package_default = {
|
|
842
|
-
version: "2.3.
|
|
902
|
+
version: "2.3.4-dev.1"};
|
|
843
903
|
|
|
844
904
|
// src/swap/consts.ts
|
|
845
905
|
var CF_SDK_VERSION_HEADERS = { "X-Chainflip-Sdk-Version": package_default.version };
|
|
@@ -909,6 +969,11 @@ var backendRequest = async (baseUrl, method, path, body) => {
|
|
|
909
969
|
}
|
|
910
970
|
return { status: res.status, body: await res.blob(), headers: res.headers };
|
|
911
971
|
};
|
|
972
|
+
var apiError = (action, res) => {
|
|
973
|
+
const { body } = res;
|
|
974
|
+
const message = body && typeof body === "object" && "message" in body && typeof body.message === "string" ? `: ${body.message}` : "";
|
|
975
|
+
return new Error(`Failed to ${action} (${res.status})${message}`, { cause: res });
|
|
976
|
+
};
|
|
912
977
|
var getNetworkInfo = async (baseUrl) => {
|
|
913
978
|
const res = await backendRequest(baseUrl, "GET", "/api/networkInfo");
|
|
914
979
|
assert(res.status === 200, "Failed to fetch network info");
|
|
@@ -916,32 +981,30 @@ var getNetworkInfo = async (baseUrl) => {
|
|
|
916
981
|
};
|
|
917
982
|
var openSwapDepositChannel = async (baseUrl, body) => {
|
|
918
983
|
const res = await backendRequest(baseUrl, "POST", "/api/openSwapDepositChannel", body);
|
|
919
|
-
|
|
984
|
+
if (res.status !== 201) throw apiError("open swap deposit channel", res);
|
|
920
985
|
return res.body;
|
|
921
986
|
};
|
|
922
987
|
var encodeVaultSwapData = async (baseUrl, body) => {
|
|
923
988
|
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
|
-
}
|
|
989
|
+
if (res.status !== 200) throw apiError("encode vault swap data", res);
|
|
927
990
|
return res.body;
|
|
928
991
|
};
|
|
929
992
|
var encodeCfParameters = async (baseUrl, body) => {
|
|
930
993
|
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
|
-
}
|
|
994
|
+
if (res.status !== 200) throw apiError("encode cf parameters", res);
|
|
934
995
|
return res.body;
|
|
935
996
|
};
|
|
936
997
|
var openAccountCreationDepositChannel = async (baseUrl, body) => {
|
|
937
998
|
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
|
-
}
|
|
999
|
+
if (res.status !== 201) throw apiError("open account creation deposit channel", res);
|
|
941
1000
|
return res.body;
|
|
942
1001
|
};
|
|
943
1002
|
|
|
944
1003
|
// src/swap/sdk.ts
|
|
1004
|
+
var BrokerName = {
|
|
1005
|
+
ChainflipSwap: "swap.chainflip.io"
|
|
1006
|
+
};
|
|
1007
|
+
var brokerNames = Object.values(BrokerName);
|
|
945
1008
|
var assertQuoteValid = (quote) => {
|
|
946
1009
|
switch (quote.type) {
|
|
947
1010
|
case "REGULAR":
|
|
@@ -1026,20 +1089,60 @@ var SwapSDK = class {
|
|
|
1026
1089
|
]);
|
|
1027
1090
|
return supportedAssets.map((asset2) => getAssetData(asset2, this.options.network, env)).filter((asset2) => !chain2 || asset2.chain === chain2);
|
|
1028
1091
|
}
|
|
1029
|
-
|
|
1030
|
-
|
|
1031
|
-
|
|
1092
|
+
resolveBroker(fees = {}) {
|
|
1093
|
+
const { broker } = this.options;
|
|
1094
|
+
assert(
|
|
1095
|
+
!(broker && "name" in broker && "url" in broker),
|
|
1096
|
+
"A broker can be set by url or name, not both"
|
|
1097
|
+
);
|
|
1098
|
+
if (broker && "name" in broker) {
|
|
1099
|
+
assert(brokerNames.includes(broker.name), `Broker name "${broker.name}" is not supported`);
|
|
1100
|
+
assert(
|
|
1101
|
+
fees.brokerCommissionBps === void 0 && !fees.affiliates?.length,
|
|
1102
|
+
`Broker commission and affiliates are not supported with the ${broker.name} broker`
|
|
1103
|
+
);
|
|
1104
|
+
}
|
|
1105
|
+
return broker;
|
|
1106
|
+
}
|
|
1107
|
+
requireBroker(fees = {}) {
|
|
1108
|
+
const broker = this.resolveBroker(fees);
|
|
1109
|
+
assert(broker, "A broker url or name is required to open channels or encode swaps");
|
|
1110
|
+
return broker;
|
|
1111
|
+
}
|
|
1112
|
+
// TODO: remove after brokerAccount is deprecated
|
|
1113
|
+
resolveEncodingBroker(brokerAccount, fees) {
|
|
1114
|
+
if (!brokerAccount) return this.requireBroker(fees);
|
|
1115
|
+
assert(
|
|
1116
|
+
!this.options.broker,
|
|
1117
|
+
"Setting brokerAccount is not supported when the SDK is initialized with a broker"
|
|
1118
|
+
);
|
|
1119
|
+
return void 0;
|
|
1120
|
+
}
|
|
1121
|
+
async estimateExpiryTime(chain2, expiryBlock) {
|
|
1122
|
+
try {
|
|
1123
|
+
const { chainTracking } = await this.cache.read("networkInfo");
|
|
1124
|
+
const chainInfo = chainTracking?.find((info) => info.chain === chain2);
|
|
1125
|
+
return calculateExpiryTime({ chainInfo, expiryBlock })?.getTime();
|
|
1126
|
+
} catch {
|
|
1127
|
+
return void 0;
|
|
1128
|
+
}
|
|
1032
1129
|
}
|
|
1033
|
-
async getCommissionBps(
|
|
1034
|
-
|
|
1035
|
-
|
|
1130
|
+
async getCommissionBps({
|
|
1131
|
+
brokerCommissionBps,
|
|
1132
|
+
affiliateBrokers,
|
|
1133
|
+
isOnChain
|
|
1134
|
+
}) {
|
|
1135
|
+
const broker = this.resolveBroker({ brokerCommissionBps, affiliates: affiliateBrokers });
|
|
1136
|
+
if (!isOnChain && broker && "name" in broker && broker.name === BrokerName.ChainflipSwap) {
|
|
1137
|
+
return this.getQuotedBrokerCommissionBps();
|
|
1036
1138
|
}
|
|
1037
1139
|
return brokerCommissionBps ?? 0;
|
|
1038
1140
|
}
|
|
1141
|
+
async getQuotedBrokerCommissionBps() {
|
|
1142
|
+
return (await this.cache.read("networkInfo")).cfBrokerCommissionBps;
|
|
1143
|
+
}
|
|
1039
1144
|
async getQuoteV2(quoteRequest, options = {}) {
|
|
1040
|
-
const submitterBrokerCommissionBps = await this.getCommissionBps(
|
|
1041
|
-
quoteRequest.brokerCommissionBps
|
|
1042
|
-
);
|
|
1145
|
+
const submitterBrokerCommissionBps = await this.getCommissionBps(quoteRequest);
|
|
1043
1146
|
return getQuoteV2(
|
|
1044
1147
|
this.options.backendUrl,
|
|
1045
1148
|
{
|
|
@@ -1126,8 +1229,9 @@ var SwapSDK = class {
|
|
|
1126
1229
|
fillOrKillParams: inputFoKParams,
|
|
1127
1230
|
affiliateBrokers: affiliates,
|
|
1128
1231
|
ccmParams,
|
|
1129
|
-
brokerCommissionBps
|
|
1232
|
+
brokerCommissionBps
|
|
1130
1233
|
}) {
|
|
1234
|
+
const broker = this.requireBroker({ brokerCommissionBps, affiliates });
|
|
1131
1235
|
await this.validateSwapAmount(quote.srcAsset, BigInt(quote.depositAmount));
|
|
1132
1236
|
assertQuoteValid(quote);
|
|
1133
1237
|
assert(!quote.isVaultSwap, "Cannot open a deposit channel for a vault swap quote");
|
|
@@ -1137,7 +1241,6 @@ var SwapSDK = class {
|
|
|
1137
1241
|
} else {
|
|
1138
1242
|
assert(!quote.ccmParams, "Cannot open regular channel for quote with CCM params");
|
|
1139
1243
|
}
|
|
1140
|
-
const brokerCommissionBps = await this.getCommissionBps(brokerCommissionBpsParam);
|
|
1141
1244
|
const depositAddressRequest = {
|
|
1142
1245
|
srcAsset: quote.srcAsset,
|
|
1143
1246
|
destAsset: quote.destAsset,
|
|
@@ -1149,38 +1252,29 @@ var SwapSDK = class {
|
|
|
1149
1252
|
ccmParams,
|
|
1150
1253
|
amount: quote.depositAmount
|
|
1151
1254
|
};
|
|
1152
|
-
let
|
|
1153
|
-
if (
|
|
1255
|
+
let channel;
|
|
1256
|
+
if ("url" in broker) {
|
|
1154
1257
|
const result = await requestSwapDepositAddress(
|
|
1155
|
-
{
|
|
1156
|
-
|
|
1157
|
-
commissionBps: brokerCommissionBps,
|
|
1158
|
-
affiliates
|
|
1159
|
-
},
|
|
1160
|
-
{ url: this.options.broker.url },
|
|
1258
|
+
{ ...depositAddressRequest, commissionBps: brokerCommissionBps ?? 0, affiliates },
|
|
1259
|
+
broker,
|
|
1161
1260
|
this.options.network
|
|
1162
1261
|
);
|
|
1163
|
-
|
|
1262
|
+
channel = {
|
|
1164
1263
|
id: `${result.issuedBlock}-${quote.srcAsset.chain}-${result.channelId}`,
|
|
1165
1264
|
depositAddress: result.address,
|
|
1166
|
-
brokerCommissionBps,
|
|
1265
|
+
brokerCommissionBps: brokerCommissionBps ?? 0,
|
|
1266
|
+
maxBoostFeeBps: Number(depositAddressRequest.maxBoostFeeBps) || 0,
|
|
1167
1267
|
srcChainExpiryBlock: result.sourceChainExpiryBlock,
|
|
1168
|
-
|
|
1268
|
+
estimatedExpiryTime: await this.estimateExpiryTime(
|
|
1269
|
+
quote.srcAsset.chain,
|
|
1270
|
+
result.sourceChainExpiryBlock
|
|
1271
|
+
),
|
|
1169
1272
|
channelOpeningFee: result.channelOpeningFee
|
|
1170
1273
|
};
|
|
1171
1274
|
} else {
|
|
1172
|
-
|
|
1173
|
-
!brokerCommissionBps || this.shouldTakeCommission(),
|
|
1174
|
-
"Broker commission is supported only when initializing the SDK with a brokerUrl"
|
|
1175
|
-
);
|
|
1176
|
-
assert(
|
|
1177
|
-
!affiliates?.length,
|
|
1178
|
-
"Affiliate brokers are supported only when initializing the SDK with a brokerUrl"
|
|
1179
|
-
);
|
|
1180
|
-
response = await openSwapDepositChannel(this.options.backendUrl, {
|
|
1275
|
+
channel = await openSwapDepositChannel(this.options.backendUrl, {
|
|
1181
1276
|
...depositAddressRequest,
|
|
1182
|
-
quote
|
|
1183
|
-
takeCommission: this.shouldTakeCommission()
|
|
1277
|
+
quote
|
|
1184
1278
|
});
|
|
1185
1279
|
}
|
|
1186
1280
|
return {
|
|
@@ -1189,14 +1283,14 @@ var SwapSDK = class {
|
|
|
1189
1283
|
destAsset: quote.destAsset.asset,
|
|
1190
1284
|
srcChain: quote.srcAsset.chain,
|
|
1191
1285
|
destChain: quote.destAsset.chain,
|
|
1192
|
-
depositChannelId:
|
|
1193
|
-
depositAddress:
|
|
1194
|
-
brokerCommissionBps:
|
|
1286
|
+
depositChannelId: channel.id,
|
|
1287
|
+
depositAddress: channel.depositAddress,
|
|
1288
|
+
brokerCommissionBps: channel.brokerCommissionBps,
|
|
1195
1289
|
affiliateBrokers: affiliates ?? [],
|
|
1196
|
-
maxBoostFeeBps:
|
|
1197
|
-
depositChannelExpiryBlock: BigInt(
|
|
1198
|
-
estimatedDepositChannelExpiryTime:
|
|
1199
|
-
channelOpeningFee: BigInt(
|
|
1290
|
+
maxBoostFeeBps: channel.maxBoostFeeBps,
|
|
1291
|
+
depositChannelExpiryBlock: BigInt(channel.srcChainExpiryBlock),
|
|
1292
|
+
estimatedDepositChannelExpiryTime: channel.estimatedExpiryTime,
|
|
1293
|
+
channelOpeningFee: BigInt(channel.channelOpeningFee),
|
|
1200
1294
|
fillOrKillParams: inputFoKParams
|
|
1201
1295
|
};
|
|
1202
1296
|
}
|
|
@@ -1208,9 +1302,10 @@ var SwapSDK = class {
|
|
|
1208
1302
|
affiliateBrokers: affiliates,
|
|
1209
1303
|
ccmParams,
|
|
1210
1304
|
brokerAccount,
|
|
1211
|
-
brokerCommissionBps
|
|
1305
|
+
brokerCommissionBps,
|
|
1212
1306
|
extraParams
|
|
1213
1307
|
}) {
|
|
1308
|
+
const broker = this.resolveEncodingBroker(brokerAccount, { brokerCommissionBps, affiliates });
|
|
1214
1309
|
await this.validateSwapAmount(quote.srcAsset, BigInt(quote.depositAmount));
|
|
1215
1310
|
assertQuoteValid(quote);
|
|
1216
1311
|
assert(quote.isVaultSwap, "Cannot encode vault swap data for non-vault swap quotes");
|
|
@@ -1219,7 +1314,6 @@ var SwapSDK = class {
|
|
|
1219
1314
|
} else {
|
|
1220
1315
|
assert(!quote.ccmParams, "Cannot encode regular swap for quote with CCM params");
|
|
1221
1316
|
}
|
|
1222
|
-
const brokerCommissionBps = await this.getCommissionBps(brokerCommissionBpsParam);
|
|
1223
1317
|
const vaultSwapRequest = {
|
|
1224
1318
|
srcAsset: quote.srcAsset,
|
|
1225
1319
|
destAsset: quote.destAsset,
|
|
@@ -1231,30 +1325,16 @@ var SwapSDK = class {
|
|
|
1231
1325
|
fillOrKillParams: parseFoKParams(inputFoKParams, quote),
|
|
1232
1326
|
dcaParams: quote.type === "DCA" ? quote.dcaParams : void 0,
|
|
1233
1327
|
extraParams,
|
|
1234
|
-
brokerAccount,
|
|
1235
1328
|
commissionBps: brokerCommissionBps,
|
|
1236
1329
|
affiliates
|
|
1237
1330
|
};
|
|
1238
|
-
if (
|
|
1239
|
-
|
|
1240
|
-
!vaultSwapRequest.brokerAccount,
|
|
1241
|
-
"Cannot overwrite broker account when initializing the SDK with a brokerUrl"
|
|
1242
|
-
);
|
|
1243
|
-
return requestSwapParameterEncoding(
|
|
1244
|
-
vaultSwapRequest,
|
|
1245
|
-
{ url: this.options.broker.url },
|
|
1246
|
-
this.options.network
|
|
1247
|
-
);
|
|
1331
|
+
if (broker && "url" in broker) {
|
|
1332
|
+
return requestSwapParameterEncoding(vaultSwapRequest, broker, this.options.network);
|
|
1248
1333
|
}
|
|
1249
|
-
|
|
1250
|
-
|
|
1251
|
-
|
|
1252
|
-
);
|
|
1253
|
-
assert(
|
|
1254
|
-
!vaultSwapRequest.affiliates?.length || vaultSwapRequest.brokerAccount,
|
|
1255
|
-
"Affiliate brokers are supported only when setting a broker account"
|
|
1334
|
+
const body = await encodeVaultSwapData(
|
|
1335
|
+
this.options.backendUrl,
|
|
1336
|
+
brokerAccount ? { ...vaultSwapRequest, brokerAccount, commissionBps: brokerCommissionBps ?? 0 } : { ...vaultSwapRequest, commissionBps: await this.getQuotedBrokerCommissionBps() }
|
|
1256
1337
|
);
|
|
1257
|
-
const body = await encodeVaultSwapData(this.options.backendUrl, vaultSwapRequest);
|
|
1258
1338
|
switch (body.chain) {
|
|
1259
1339
|
case "Arbitrum":
|
|
1260
1340
|
case "Ethereum":
|
|
@@ -1275,6 +1355,7 @@ var SwapSDK = class {
|
|
|
1275
1355
|
brokerAccount,
|
|
1276
1356
|
brokerCommissionBps
|
|
1277
1357
|
}) {
|
|
1358
|
+
const broker = this.resolveEncodingBroker(brokerAccount, { brokerCommissionBps, affiliates });
|
|
1278
1359
|
await this.validateSwapAmount(quote.srcAsset, BigInt(quote.depositAmount));
|
|
1279
1360
|
assertQuoteValid(quote);
|
|
1280
1361
|
if (ccmParams) {
|
|
@@ -1292,45 +1373,52 @@ var SwapSDK = class {
|
|
|
1292
1373
|
maxBoostFeeBps: "maxBoostFeeBps" in quote ? quote.maxBoostFeeBps : void 0,
|
|
1293
1374
|
fillOrKillParams: parseFoKParams(fillOrKillParams2, quote),
|
|
1294
1375
|
dcaParams: quote.type === "DCA" ? quote.dcaParams : void 0,
|
|
1295
|
-
commissionBps:
|
|
1376
|
+
commissionBps: brokerCommissionBps,
|
|
1296
1377
|
affiliates
|
|
1297
1378
|
};
|
|
1298
|
-
if (
|
|
1299
|
-
|
|
1300
|
-
!brokerAccount,
|
|
1301
|
-
"Cannot overwrite broker account when initializing the SDK with a brokerUrl"
|
|
1302
|
-
);
|
|
1303
|
-
return requestCfParametersEncoding(
|
|
1304
|
-
requestParams,
|
|
1305
|
-
{ url: this.options.broker.url },
|
|
1306
|
-
this.options.network
|
|
1307
|
-
);
|
|
1379
|
+
if (broker && "url" in broker) {
|
|
1380
|
+
return requestCfParametersEncoding(requestParams, broker, this.options.network);
|
|
1308
1381
|
}
|
|
1309
|
-
|
|
1310
|
-
|
|
1311
|
-
|
|
1312
|
-
);
|
|
1313
|
-
assert(
|
|
1314
|
-
!requestParams.affiliates?.length || brokerAccount,
|
|
1315
|
-
"Affiliate brokers are supported only when setting a broker account"
|
|
1382
|
+
return encodeCfParameters(
|
|
1383
|
+
this.options.backendUrl,
|
|
1384
|
+
brokerAccount ? { ...requestParams, brokerAccount, commissionBps: brokerCommissionBps ?? 0 } : { ...requestParams, commissionBps: await this.getQuotedBrokerCommissionBps() }
|
|
1316
1385
|
);
|
|
1317
|
-
return encodeCfParameters(this.options.backendUrl, {
|
|
1318
|
-
...requestParams,
|
|
1319
|
-
brokerAccount
|
|
1320
|
-
});
|
|
1321
1386
|
}
|
|
1322
1387
|
async checkBoostEnabled() {
|
|
1323
1388
|
const { assets } = await this.cache.read("networkInfo");
|
|
1324
1389
|
return assets.find((a) => a.asset === "Btc")?.boostDepositsEnabled ?? true;
|
|
1325
1390
|
}
|
|
1326
1391
|
async requestAccountCreationDepositAddress(asset2, refundAddress, signatureData, transactionMetadata, boostFeeBps = 0) {
|
|
1327
|
-
|
|
1328
|
-
|
|
1392
|
+
const broker = this.requireBroker();
|
|
1393
|
+
const rpcAsset = chainflip.internalAssetToRpcAsset[asset2];
|
|
1394
|
+
const request = {
|
|
1395
|
+
asset: rpcAsset,
|
|
1329
1396
|
refundAddress,
|
|
1330
1397
|
signatureData,
|
|
1331
1398
|
transactionMetadata,
|
|
1332
1399
|
boostFeeBps
|
|
1333
|
-
}
|
|
1400
|
+
};
|
|
1401
|
+
if ("url" in broker) {
|
|
1402
|
+
const result = await requestAccountCreationDepositAddress(
|
|
1403
|
+
request,
|
|
1404
|
+
broker,
|
|
1405
|
+
this.options.network
|
|
1406
|
+
);
|
|
1407
|
+
return {
|
|
1408
|
+
id: `${result.issuedBlock}-${rpcAsset.chain}-${result.channelId}`,
|
|
1409
|
+
depositAddress: result.address,
|
|
1410
|
+
brokerCommissionBps: 0,
|
|
1411
|
+
maxBoostFeeBps: boostFeeBps,
|
|
1412
|
+
issuedBlock: result.issuedBlock,
|
|
1413
|
+
srcChainExpiryBlock: result.depositChainExpiryBlock.toString(),
|
|
1414
|
+
estimatedExpiryTime: await this.estimateExpiryTime(
|
|
1415
|
+
rpcAsset.chain,
|
|
1416
|
+
result.depositChainExpiryBlock
|
|
1417
|
+
),
|
|
1418
|
+
channelOpeningFee: result.channelOpeningFee.toString()
|
|
1419
|
+
};
|
|
1420
|
+
}
|
|
1421
|
+
return openAccountCreationDepositChannel(this.options.backendUrl, request);
|
|
1334
1422
|
}
|
|
1335
1423
|
};
|
|
1336
1424
|
var arrayToMap = (array) => Object.fromEntries(array.map((item) => [item, item]));
|
|
@@ -1344,6 +1432,7 @@ Object.defineProperty(exports, "getChainflipId", {
|
|
|
1344
1432
|
get: function () { return chainflip.getInternalAsset; }
|
|
1345
1433
|
});
|
|
1346
1434
|
exports.Assets = Assets;
|
|
1435
|
+
exports.BrokerName = BrokerName;
|
|
1347
1436
|
exports.ChainflipIds = InternalAssets;
|
|
1348
1437
|
exports.ChainflipNetworks = ChainflipNetworks;
|
|
1349
1438
|
exports.Chains = Chains;
|