@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 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.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
- assert(res.status === 201, "Failed to open swap deposit channel");
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
- // eslint-disable-next-line class-methods-use-this
1030
- shouldTakeCommission() {
1031
- return false;
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(brokerCommissionBps) {
1034
- if (this.shouldTakeCommission()) {
1035
- return (await this.cache.read("networkInfo")).cfBrokerCommissionBps;
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: brokerCommissionBpsParam
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 response;
1153
- if (this.options.broker) {
1255
+ let channel;
1256
+ if ("url" in broker) {
1154
1257
  const result = await requestSwapDepositAddress(
1155
- {
1156
- ...depositAddressRequest,
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
- response = {
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
- maxBoostFeeBps: depositAddressRequest.maxBoostFeeBps,
1268
+ estimatedExpiryTime: await this.estimateExpiryTime(
1269
+ quote.srcAsset.chain,
1270
+ result.sourceChainExpiryBlock
1271
+ ),
1169
1272
  channelOpeningFee: result.channelOpeningFee
1170
1273
  };
1171
1274
  } else {
1172
- assert(
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: response.id,
1193
- depositAddress: response.depositAddress,
1194
- brokerCommissionBps: response.brokerCommissionBps,
1286
+ depositChannelId: channel.id,
1287
+ depositAddress: channel.depositAddress,
1288
+ brokerCommissionBps: channel.brokerCommissionBps,
1195
1289
  affiliateBrokers: affiliates ?? [],
1196
- maxBoostFeeBps: Number(response.maxBoostFeeBps) || 0,
1197
- depositChannelExpiryBlock: BigInt(response.srcChainExpiryBlock),
1198
- estimatedDepositChannelExpiryTime: response.estimatedExpiryTime,
1199
- channelOpeningFee: BigInt(response.channelOpeningFee),
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: brokerCommissionBpsParam,
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 (this.options.broker) {
1239
- assert(
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
- assert(
1250
- !vaultSwapRequest.commissionBps || vaultSwapRequest.brokerAccount || this.shouldTakeCommission(),
1251
- "Broker commission is supported only when setting a broker account"
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: await this.getCommissionBps(brokerCommissionBps),
1376
+ commissionBps: brokerCommissionBps,
1296
1377
  affiliates
1297
1378
  };
1298
- if (this.options.broker) {
1299
- assert(
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
- assert(
1310
- !requestParams.commissionBps || brokerAccount || this.shouldTakeCommission(),
1311
- "Broker commission is supported only when setting a broker account"
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
- return openAccountCreationDepositChannel(this.options.backendUrl, {
1328
- asset: chainflip.internalAssetToRpcAsset[asset2],
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;