@chainflip/sdk 1.7.0 → 1.8.0-beta.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/chunk-HBQFFIRA.mjs +292 -0
- package/dist/{contracts-Bgib7w_h.d.mts → enums-_AFEOA70.d.mts} +1 -10
- package/dist/{contracts-Bgib7w_h.d.ts → enums-_AFEOA70.d.ts} +1 -10
- package/dist/funding.d.mts +10 -1
- package/dist/funding.d.ts +10 -1
- package/dist/funding.js +89 -233
- package/dist/funding.mjs +832 -43
- package/dist/swap.d.mts +86 -65
- package/dist/swap.d.ts +86 -65
- package/dist/swap.js +628 -2127
- package/dist/swap.mjs +474 -568
- package/package.json +11 -11
- package/dist/chunk-KLBPIDTY.mjs +0 -2373
package/dist/swap.mjs
CHANGED
|
@@ -1,33 +1,53 @@
|
|
|
1
|
-
import { isString, InternalAssets, Chains, Assets, ChainflipNetworks, isValidAssetAndChain, getInternalAssets,
|
|
2
|
-
export { Assets, InternalAssets as ChainflipIds, ChainflipNetworks, Chains, getInternalAsset as getChainflipId } from './chunk-
|
|
1
|
+
import { isString, InternalAssets, Chains, Assets, ChainflipNetworks, isValidAssetAndChain, getInternalAssets, getEnvironment, assetConstants, getEvmChainId, getSupportedAssets, getInternalAsset, isNotNullish, getAllBoostPoolsDepth, assert, getAssetAndChain, isTestnet, readChainAssetValue, ADDRESSES } from './chunk-HBQFFIRA.mjs';
|
|
2
|
+
export { Assets, InternalAssets as ChainflipIds, ChainflipNetworks, Chains, getInternalAsset as getChainflipId } from './chunk-HBQFFIRA.mjs';
|
|
3
3
|
import { createTRPCProxyClient, httpBatchLink } from '@trpc/client';
|
|
4
4
|
import superjson from 'superjson';
|
|
5
5
|
import { HttpClient } from '@chainflip/rpc';
|
|
6
6
|
import * as ss582 from '@chainflip/utils/ss58';
|
|
7
|
+
import { isHex, toUpperCase } from '@chainflip/utils/string';
|
|
8
|
+
import { priceX128ToPrice } from '@chainflip/utils/tickMath';
|
|
9
|
+
import BigNumber2 from 'bignumber.js';
|
|
7
10
|
import { z } from 'zod';
|
|
8
11
|
import * as bitcoin from '@chainflip/bitcoin';
|
|
9
12
|
import { isValidSolanaAddress } from '@chainflip/solana';
|
|
10
13
|
import * as base58 from '@chainflip/utils/base58';
|
|
11
|
-
import { hexToBytes
|
|
12
|
-
import { isHex } from '@chainflip/utils/string';
|
|
14
|
+
import { hexToBytes } from '@chainflip/utils/bytes';
|
|
13
15
|
import * as ethers from 'ethers';
|
|
14
16
|
import { isValidSolanaAddress as isValidSolanaAddress$1 } from '@chainflip/solana/address';
|
|
15
17
|
import { hexEncodeNumber } from '@chainflip/utils/number';
|
|
16
|
-
import BigNumber from 'bignumber.js';
|
|
17
18
|
import axios from 'axios';
|
|
18
19
|
|
|
19
|
-
|
|
20
|
+
// ../shared/src/strings.ts
|
|
21
|
+
var toCamelCase = (str) => str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
|
|
22
|
+
|
|
23
|
+
// ../shared/src/objects.ts
|
|
24
|
+
var transformKeysToCamelCase = (obj) => {
|
|
25
|
+
if (Array.isArray(obj)) {
|
|
26
|
+
return obj.map(transformKeysToCamelCase);
|
|
27
|
+
}
|
|
28
|
+
if (obj !== null && typeof obj === "object") {
|
|
29
|
+
return Object.fromEntries(
|
|
30
|
+
Object.entries(obj).map(([key, value]) => [
|
|
31
|
+
toCamelCase(key),
|
|
32
|
+
transformKeysToCamelCase(value)
|
|
33
|
+
])
|
|
34
|
+
);
|
|
35
|
+
}
|
|
36
|
+
return obj;
|
|
37
|
+
};
|
|
38
|
+
var validatePolkadotAddress = (address) => {
|
|
39
|
+
if (isHex(address)) return address.length === 66;
|
|
20
40
|
try {
|
|
21
41
|
ss582.decode(address);
|
|
22
42
|
return true;
|
|
23
43
|
} catch {
|
|
24
44
|
return false;
|
|
25
45
|
}
|
|
26
|
-
}
|
|
27
|
-
var validateEvmAddress =
|
|
28
|
-
var validateBitcoinMainnetAddress =
|
|
29
|
-
var validateBitcoinTestnetAddress =
|
|
30
|
-
var validateBitcoinRegtestAddress =
|
|
46
|
+
};
|
|
47
|
+
var validateEvmAddress = (address) => ethers.isAddress(address);
|
|
48
|
+
var validateBitcoinMainnetAddress = (address) => bitcoin.isValidAddressForNetwork(address, "mainnet");
|
|
49
|
+
var validateBitcoinTestnetAddress = (address) => bitcoin.isValidAddressForNetwork(address, "testnet");
|
|
50
|
+
var validateBitcoinRegtestAddress = (address) => bitcoin.isValidAddressForNetwork(address, "regtest");
|
|
31
51
|
var validateSolanaAddress = isValidSolanaAddress$1;
|
|
32
52
|
var validators = {
|
|
33
53
|
mainnet: {
|
|
@@ -66,90 +86,52 @@ var validators = {
|
|
|
66
86
|
Solana: validateSolanaAddress
|
|
67
87
|
}
|
|
68
88
|
};
|
|
69
|
-
var
|
|
89
|
+
var validateAddress = (chain2, address, network) => validators[network][chain2](address);
|
|
70
90
|
|
|
71
91
|
// ../shared/src/parsers.ts
|
|
72
92
|
var chainflipSS58Prefix = 2112;
|
|
73
93
|
var enumValues = Object.values;
|
|
74
|
-
var safeStringify =
|
|
75
|
-
var errorMap =
|
|
94
|
+
var safeStringify = (obj) => JSON.stringify(obj, (key, value) => typeof value === "bigint" ? value.toString() : value);
|
|
95
|
+
var errorMap = (_issue, context) => ({
|
|
76
96
|
message: `received: ${safeStringify(context.data)}`
|
|
77
|
-
}), "errorMap");
|
|
78
|
-
var string = z.string({
|
|
79
|
-
errorMap
|
|
80
|
-
});
|
|
81
|
-
var number = z.number({
|
|
82
|
-
errorMap
|
|
83
97
|
});
|
|
98
|
+
var string = z.string({ errorMap });
|
|
99
|
+
var number = z.number({ errorMap });
|
|
84
100
|
var booleanString = string.regex(/^(true|false)$/i).transform((v) => v.toLowerCase() === "true");
|
|
85
101
|
var numericString = string.regex(/^[0-9]+$/);
|
|
86
102
|
var numericOrEmptyString = string.regex(/^[0-9]*$/);
|
|
87
103
|
var hexString = string.refine((v) => /^0x[0-9a-f]*$/i.test(v));
|
|
88
|
-
var hexStringWithMaxByteSize =
|
|
104
|
+
var hexStringWithMaxByteSize = (maxByteSize) => hexString.refine((val) => val.length / 2 <= maxByteSize + 1, {
|
|
89
105
|
message: `String must be less than or equal to ${maxByteSize} bytes`
|
|
90
|
-
})
|
|
91
|
-
var btcAddress = /* @__PURE__ */ __name((network) => {
|
|
92
|
-
if (network === "mainnet") {
|
|
93
|
-
return string.regex(/^(1|3|bc1)/).refine(validateBitcoinMainnetAddress, (address) => ({
|
|
94
|
-
message: `"${address}" is not a valid Bitcoin mainnet address`
|
|
95
|
-
}));
|
|
96
|
-
}
|
|
97
|
-
return z.union([
|
|
98
|
-
string.regex(/^(m|n|2|tb1)/).refine(validateBitcoinTestnetAddress, (address) => ({
|
|
99
|
-
message: `"${address}" is not a valid Bitcoin testnet address`
|
|
100
|
-
})),
|
|
101
|
-
string.regex(/^bcrt1/).refine(validateBitcoinRegtestAddress, (address) => ({
|
|
102
|
-
message: `"${address}" is not a valid Bitcoin regtest address`
|
|
103
|
-
}))
|
|
104
|
-
]);
|
|
105
|
-
}, "btcAddress");
|
|
106
|
+
});
|
|
106
107
|
var DOT_PREFIX = 0;
|
|
107
|
-
|
|
108
|
-
string,
|
|
109
|
-
hexString
|
|
110
|
-
]).transform((arg) => {
|
|
108
|
+
z.union([string, hexString]).transform((arg) => {
|
|
111
109
|
try {
|
|
112
110
|
if (arg.startsWith("0x")) {
|
|
113
|
-
return ss582.encode({
|
|
114
|
-
data: arg,
|
|
115
|
-
ss58Format: DOT_PREFIX
|
|
116
|
-
});
|
|
111
|
+
return ss582.encode({ data: arg, ss58Format: DOT_PREFIX });
|
|
117
112
|
}
|
|
118
|
-
return ss582.encode({
|
|
119
|
-
data: ss582.decode(arg).data,
|
|
120
|
-
ss58Format: DOT_PREFIX
|
|
121
|
-
});
|
|
113
|
+
return ss582.encode({ data: ss582.decode(arg).data, ss58Format: DOT_PREFIX });
|
|
122
114
|
} catch {
|
|
123
115
|
return null;
|
|
124
116
|
}
|
|
125
117
|
}).refine(isString, {
|
|
126
118
|
message: `address is not a valid polkadot address`
|
|
127
119
|
});
|
|
128
|
-
|
|
129
|
-
|
|
130
|
-
})
|
|
131
|
-
|
|
132
|
-
|
|
133
|
-
|
|
120
|
+
hexString.refine(
|
|
121
|
+
(address) => ethers.isAddress(address),
|
|
122
|
+
(address) => ({ message: `${address} is not a valid Ethereum address` })
|
|
123
|
+
);
|
|
124
|
+
var chainflipAddress = string.refine(
|
|
125
|
+
(address) => address.startsWith("cF") && ss582.decode(address),
|
|
126
|
+
(address) => ({ message: `${address} is not a valid Chainflip address` })
|
|
127
|
+
);
|
|
134
128
|
var solanaAddress = string.refine(isValidSolanaAddress, (address) => ({
|
|
135
129
|
message: `${address} is not a valid Solana address`
|
|
136
130
|
}));
|
|
137
|
-
var polkadotAddress = string.refine((address) => ss582.decode(address), (address) => ({
|
|
138
|
-
message: `${address} is not a valid polkadot address`
|
|
139
|
-
}));
|
|
140
131
|
numericString.transform((arg) => BigInt(arg));
|
|
141
|
-
var u128 = z.union([
|
|
142
|
-
|
|
143
|
-
|
|
144
|
-
hexString
|
|
145
|
-
]).transform((arg) => BigInt(arg));
|
|
146
|
-
var unsignedInteger = z.union([
|
|
147
|
-
u128,
|
|
148
|
-
z.number().transform((n) => BigInt(n))
|
|
149
|
-
]);
|
|
150
|
-
var rustEnum = /* @__PURE__ */ __name((values) => z.object({
|
|
151
|
-
__kind: z.enum(values)
|
|
152
|
-
}).transform(({ __kind }) => __kind), "rustEnum");
|
|
132
|
+
var u128 = z.union([number, numericString, hexString]).transform((arg) => BigInt(arg));
|
|
133
|
+
var unsignedInteger = z.union([u128, z.number().transform((n) => BigInt(n))]);
|
|
134
|
+
var rustEnum = (values) => z.object({ __kind: z.enum(values) }).transform(({ __kind }) => __kind);
|
|
153
135
|
rustEnum(enumValues(InternalAssets));
|
|
154
136
|
rustEnum(enumValues(Chains));
|
|
155
137
|
var chain = z.nativeEnum(Chains);
|
|
@@ -159,44 +141,19 @@ var uncheckedAssetAndChain = z.object({
|
|
|
159
141
|
asset: z.string(),
|
|
160
142
|
chain: z.string()
|
|
161
143
|
});
|
|
162
|
-
var assetAndChain = uncheckedAssetAndChain.refine(
|
|
163
|
-
|
|
164
|
-
|
|
165
|
-
__kind: z.literal("CcmPrincipal"),
|
|
166
|
-
value: unsignedInteger
|
|
167
|
-
}).transform(({ value: ccmId }) => ({
|
|
168
|
-
type: "PRINCIPAL",
|
|
169
|
-
ccmId
|
|
170
|
-
})),
|
|
171
|
-
z.object({
|
|
172
|
-
__kind: z.literal("CcmGas"),
|
|
173
|
-
value: unsignedInteger
|
|
174
|
-
}).transform(({ value: ccmId }) => ({
|
|
175
|
-
type: "GAS",
|
|
176
|
-
ccmId
|
|
177
|
-
})),
|
|
178
|
-
z.object({
|
|
179
|
-
__kind: z.literal("Swap")
|
|
180
|
-
}).transform(() => ({
|
|
181
|
-
type: "SWAP"
|
|
182
|
-
}))
|
|
183
|
-
]);
|
|
144
|
+
var assetAndChain = uncheckedAssetAndChain.refine(
|
|
145
|
+
(value) => isValidAssetAndChain(value)
|
|
146
|
+
);
|
|
184
147
|
z.union([
|
|
185
148
|
hexString,
|
|
149
|
+
//
|
|
186
150
|
string.regex(/^[a-f\d]$/i).transform((value) => `0x${value}`)
|
|
187
|
-
]).transform(
|
|
188
|
-
data: value,
|
|
189
|
-
|
|
190
|
-
}));
|
|
151
|
+
]).transform(
|
|
152
|
+
(value) => ss582.encode({ data: value, ss58Format: chainflipSS58Prefix })
|
|
153
|
+
);
|
|
191
154
|
z.union([
|
|
192
|
-
z.object({
|
|
193
|
-
|
|
194
|
-
swapId: u128
|
|
195
|
-
}),
|
|
196
|
-
z.object({
|
|
197
|
-
__kind: z.literal("LiquidityProvision"),
|
|
198
|
-
lpAccount: hexString
|
|
199
|
-
}),
|
|
155
|
+
z.object({ __kind: z.literal("Swap"), swapId: u128 }),
|
|
156
|
+
z.object({ __kind: z.literal("LiquidityProvision"), lpAccount: hexString }),
|
|
200
157
|
z.object({
|
|
201
158
|
__kind: z.literal("CcmTransfer"),
|
|
202
159
|
principalSwapId: u128.nullable().optional(),
|
|
@@ -216,27 +173,22 @@ z.object({
|
|
|
216
173
|
srcAsset: asset,
|
|
217
174
|
destChain: chain,
|
|
218
175
|
destAsset: asset,
|
|
219
|
-
amount: numericString.transform((
|
|
176
|
+
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" }),
|
|
220
177
|
brokerCommissionBps: numericOrEmptyString.transform((v) => Number(v)).optional(),
|
|
221
|
-
dcaEnabled: booleanString
|
|
178
|
+
dcaEnabled: booleanString.default("false"),
|
|
179
|
+
isVaultSwap: booleanString.default("false")
|
|
222
180
|
}).transform((args, ctx) => {
|
|
223
181
|
const { srcAsset, destAsset } = getInternalAssets(args, false);
|
|
224
182
|
if (srcAsset === null) {
|
|
225
183
|
ctx.addIssue({
|
|
226
|
-
message: `invalid asset and chain combination: ${JSON.stringify({
|
|
227
|
-
asset: args.srcAsset,
|
|
228
|
-
chain: args.srcChain
|
|
229
|
-
})}`,
|
|
184
|
+
message: `invalid asset and chain combination: ${JSON.stringify({ asset: args.srcAsset, chain: args.srcChain })}`,
|
|
230
185
|
code: z.ZodIssueCode.custom
|
|
231
186
|
});
|
|
232
187
|
return z.NEVER;
|
|
233
188
|
}
|
|
234
189
|
if (destAsset === null) {
|
|
235
190
|
ctx.addIssue({
|
|
236
|
-
message: `invalid asset and chain combination: ${JSON.stringify({
|
|
237
|
-
asset: args.destAsset,
|
|
238
|
-
chain: args.destChain
|
|
239
|
-
})}`,
|
|
191
|
+
message: `invalid asset and chain combination: ${JSON.stringify({ asset: args.destAsset, chain: args.destChain })}`,
|
|
240
192
|
code: z.ZodIssueCode.custom
|
|
241
193
|
});
|
|
242
194
|
return z.NEVER;
|
|
@@ -246,35 +198,37 @@ z.object({
|
|
|
246
198
|
destAsset,
|
|
247
199
|
amount: args.amount,
|
|
248
200
|
brokerCommissionBps: args.brokerCommissionBps,
|
|
249
|
-
dcaEnabled: args.dcaEnabled
|
|
201
|
+
dcaEnabled: args.dcaEnabled,
|
|
202
|
+
isVaultSwap: args.isVaultSwap
|
|
250
203
|
};
|
|
251
204
|
});
|
|
252
205
|
var ccmParamsSchema = z.object({
|
|
253
|
-
gasBudget: z.union([
|
|
254
|
-
|
|
255
|
-
|
|
256
|
-
|
|
257
|
-
|
|
258
|
-
|
|
259
|
-
cfParameters: hexStringWithMaxByteSize(
|
|
260
|
-
})
|
|
206
|
+
gasBudget: z.union([numericString, hexString]).transform((n) => hexEncodeNumber(BigInt(n))),
|
|
207
|
+
// https://github.com/chainflip-io/chainflip-backend/blob/415aa9e20ec4046c68892cd34798e5d831c5b83f/state-chain/chains/src/lib.rs#L709
|
|
208
|
+
message: hexStringWithMaxByteSize(15e3),
|
|
209
|
+
// https://github.com/chainflip-io/chainflip-backend/blob/415aa9e20ec4046c68892cd34798e5d831c5b83f/state-chain/chains/src/lib.rs#L710
|
|
210
|
+
additionalData: hexStringWithMaxByteSize(3e3).optional(),
|
|
211
|
+
/** @deprecated DEPRECATED(1.8) pass additionalData instead */
|
|
212
|
+
cfParameters: hexStringWithMaxByteSize(3e3).optional()
|
|
213
|
+
}).transform(({ gasBudget, message, additionalData, cfParameters }) => ({
|
|
214
|
+
gasBudget,
|
|
215
|
+
message,
|
|
216
|
+
additionalData: additionalData ?? cfParameters
|
|
217
|
+
}));
|
|
261
218
|
var affiliateBroker = z.object({
|
|
262
219
|
account: chainflipAddress,
|
|
263
220
|
commissionBps: number
|
|
264
|
-
}).transform(({ account, commissionBps: bps }) => ({
|
|
265
|
-
account,
|
|
266
|
-
bps
|
|
267
|
-
}));
|
|
221
|
+
}).transform(({ account, commissionBps: bps }) => ({ account, bps }));
|
|
268
222
|
var dcaParams = z.object({
|
|
269
223
|
numberOfChunks: number,
|
|
270
224
|
chunkIntervalBlocks: number
|
|
271
225
|
});
|
|
272
|
-
|
|
226
|
+
z.object({
|
|
273
227
|
retryDurationBlocks: number,
|
|
274
228
|
refundAddress: z.string(),
|
|
275
229
|
minPriceX128: numericString
|
|
276
230
|
});
|
|
277
|
-
var ensureDcaWithFok =
|
|
231
|
+
var ensureDcaWithFok = (args, ctx) => {
|
|
278
232
|
if (args.dcaParams && !args.fillOrKillParams) {
|
|
279
233
|
ctx.addIssue({
|
|
280
234
|
code: "custom",
|
|
@@ -282,144 +236,188 @@ var ensureDcaWithFok = /* @__PURE__ */ __name((args, ctx) => {
|
|
|
282
236
|
});
|
|
283
237
|
return z.NEVER;
|
|
284
238
|
}
|
|
285
|
-
}
|
|
286
|
-
z.object({
|
|
287
|
-
srcAsset: asset,
|
|
288
|
-
destAsset: asset,
|
|
289
|
-
srcChain: chain,
|
|
290
|
-
destChain: chain,
|
|
291
|
-
destAddress: z.string(),
|
|
292
|
-
amount: numericString,
|
|
293
|
-
ccmParams: ccmParamsSchema.optional(),
|
|
294
|
-
maxBoostFeeBps: z.number().optional(),
|
|
295
|
-
srcAddress: z.string().optional(),
|
|
296
|
-
fillOrKillParams,
|
|
297
|
-
dcaParams: dcaParams.optional(),
|
|
298
|
-
quote: z.object({
|
|
299
|
-
intermediateAmount: z.string().optional(),
|
|
300
|
-
egressAmount: z.string(),
|
|
301
|
-
estimatedPrice: z.string(),
|
|
302
|
-
recommendedSlippageTolerancePercent: z.number().optional()
|
|
303
|
-
}).optional()
|
|
304
|
-
}).superRefine(ensureDcaWithFok).transform(({ amount, ...rest }) => ({
|
|
305
|
-
...rest,
|
|
306
|
-
expectedDepositAmount: amount
|
|
307
|
-
}));
|
|
239
|
+
};
|
|
308
240
|
|
|
309
241
|
// ../shared/src/broker.ts
|
|
310
|
-
var
|
|
311
|
-
"srcAsset",
|
|
312
|
-
"destAsset",
|
|
313
|
-
"destAddress",
|
|
314
|
-
"commissionBps",
|
|
315
|
-
"ccmParams",
|
|
316
|
-
"maxBoostFeeBps",
|
|
317
|
-
"affiliates",
|
|
318
|
-
"fillOrKillParams",
|
|
319
|
-
"dcaParams"
|
|
320
|
-
];
|
|
321
|
-
var getTransformedFokSchema = /* @__PURE__ */ __name((addressSchema) => z.object({
|
|
242
|
+
var transformedFokSchema = z.object({
|
|
322
243
|
retryDurationBlocks: number,
|
|
323
|
-
refundAddress:
|
|
244
|
+
refundAddress: z.string(),
|
|
324
245
|
minPriceX128: numericString
|
|
325
246
|
}).transform(({ retryDurationBlocks, refundAddress, minPriceX128 }) => ({
|
|
326
247
|
retry_duration: retryDurationBlocks,
|
|
327
248
|
refund_address: refundAddress,
|
|
328
249
|
min_price: `0x${BigInt(minPriceX128).toString(16)}`
|
|
329
|
-
})), "getTransformedFokSchema");
|
|
330
|
-
var transformedDcaParamsSchema = dcaParams.transform(({ numberOfChunks, chunkIntervalBlocks }) => ({
|
|
331
|
-
number_of_chunks: numberOfChunks,
|
|
332
|
-
chunk_interval: chunkIntervalBlocks
|
|
333
250
|
}));
|
|
334
|
-
var
|
|
335
|
-
|
|
336
|
-
|
|
337
|
-
|
|
338
|
-
})
|
|
339
|
-
|
|
340
|
-
|
|
341
|
-
|
|
251
|
+
var transformedDcaParamsSchema = dcaParams.transform(
|
|
252
|
+
({ numberOfChunks, chunkIntervalBlocks }) => ({
|
|
253
|
+
number_of_chunks: numberOfChunks,
|
|
254
|
+
chunk_interval: chunkIntervalBlocks
|
|
255
|
+
})
|
|
256
|
+
);
|
|
257
|
+
var transformedCcmParamsSchema = ccmParamsSchema.transform(
|
|
258
|
+
({ message, gasBudget, additionalData }) => ({
|
|
259
|
+
message,
|
|
260
|
+
gas_budget: gasBudget,
|
|
261
|
+
ccm_additional_data: additionalData,
|
|
262
|
+
/** @deprecated DEPRECATED(1.8) we still need to pass cf_parameters until 1.8 is deployed to all networks */
|
|
263
|
+
cf_parameters: additionalData
|
|
264
|
+
})
|
|
265
|
+
);
|
|
266
|
+
var getDepositAddressRequestSchema = (network) => z.object({
|
|
267
|
+
srcAsset: assetAndChain,
|
|
268
|
+
destAsset: assetAndChain,
|
|
269
|
+
destAddress: z.string(),
|
|
270
|
+
commissionBps: z.number().optional().default(0),
|
|
271
|
+
ccmParams: transformedCcmParamsSchema.optional(),
|
|
272
|
+
maxBoostFeeBps: z.number().optional(),
|
|
273
|
+
affiliates: z.array(affiliateBroker).optional(),
|
|
274
|
+
fillOrKillParams: transformedFokSchema.optional(),
|
|
275
|
+
dcaParams: transformedDcaParamsSchema.optional()
|
|
276
|
+
}).superRefine((val, ctx) => {
|
|
277
|
+
if (!validateAddress(val.destAsset.chain, val.destAddress, network)) {
|
|
278
|
+
ctx.addIssue({
|
|
279
|
+
message: `Address "${val.destAddress}" is not a valid "${val.destAsset.chain}" address for "${network}"`,
|
|
280
|
+
code: z.ZodIssueCode.custom
|
|
281
|
+
});
|
|
282
|
+
}
|
|
283
|
+
}).superRefine((val, ctx) => {
|
|
284
|
+
if (val.fillOrKillParams && !validateAddress(val.srcAsset.chain, val.fillOrKillParams.refund_address, network)) {
|
|
285
|
+
ctx.addIssue({
|
|
286
|
+
message: `Address "${val.fillOrKillParams.refund_address}" is not a valid "${val.srcAsset.chain}" address for "${network}"`,
|
|
287
|
+
code: z.ZodIssueCode.custom
|
|
288
|
+
});
|
|
342
289
|
}
|
|
343
|
-
|
|
344
|
-
|
|
290
|
+
}).superRefine(ensureDcaWithFok);
|
|
291
|
+
var getParameterEncodingRequestSchema = (network) => z.object({
|
|
292
|
+
srcAsset: assetAndChain,
|
|
293
|
+
srcAddress: z.string().optional(),
|
|
294
|
+
destAsset: assetAndChain,
|
|
295
|
+
destAddress: z.string(),
|
|
296
|
+
amount: unsignedInteger,
|
|
297
|
+
commissionBps: z.number().optional().default(0),
|
|
298
|
+
ccmParams: transformedCcmParamsSchema.optional(),
|
|
299
|
+
maxBoostFeeBps: z.number().optional(),
|
|
300
|
+
affiliates: z.array(affiliateBroker).optional(),
|
|
301
|
+
fillOrKillParams: transformedFokSchema,
|
|
302
|
+
dcaParams: transformedDcaParamsSchema.optional(),
|
|
303
|
+
extraParams: z.object({ solanaDataAccount: solanaAddress.optional() }).optional()
|
|
304
|
+
}).superRefine((val, ctx) => {
|
|
305
|
+
if (val.srcAddress && !validateAddress(val.srcAsset.chain, val.srcAddress, network)) {
|
|
306
|
+
ctx.addIssue({
|
|
307
|
+
message: `Address "${val.srcAddress}" is not a valid "${val.srcAsset.chain}" address for "${network}"`,
|
|
308
|
+
code: z.ZodIssueCode.custom
|
|
309
|
+
});
|
|
345
310
|
}
|
|
346
|
-
},
|
|
347
|
-
|
|
348
|
-
|
|
349
|
-
|
|
350
|
-
|
|
351
|
-
|
|
352
|
-
|
|
353
|
-
|
|
354
|
-
|
|
355
|
-
|
|
356
|
-
|
|
357
|
-
|
|
358
|
-
|
|
359
|
-
|
|
360
|
-
|
|
361
|
-
|
|
362
|
-
|
|
363
|
-
|
|
364
|
-
|
|
365
|
-
|
|
366
|
-
|
|
367
|
-
|
|
368
|
-
|
|
311
|
+
}).superRefine((val, ctx) => {
|
|
312
|
+
if (!validateAddress(val.destAsset.chain, val.destAddress, network)) {
|
|
313
|
+
ctx.addIssue({
|
|
314
|
+
message: `Address "${val.destAddress}" is not a valid "${val.destAsset.chain}" address for "${network}"`,
|
|
315
|
+
code: z.ZodIssueCode.custom
|
|
316
|
+
});
|
|
317
|
+
}
|
|
318
|
+
}).superRefine((val, ctx) => {
|
|
319
|
+
if (val.fillOrKillParams && !validateAddress(val.srcAsset.chain, val.fillOrKillParams.refund_address, network)) {
|
|
320
|
+
ctx.addIssue({
|
|
321
|
+
message: `Address "${val.fillOrKillParams.refund_address}" is not a valid "${val.srcAsset.chain}" address for "${network}"`,
|
|
322
|
+
code: z.ZodIssueCode.custom
|
|
323
|
+
});
|
|
324
|
+
}
|
|
325
|
+
}).transform((data) => {
|
|
326
|
+
let extraParams;
|
|
327
|
+
if (data.srcAsset.chain === "Bitcoin") {
|
|
328
|
+
const minOutputAmount = BigNumber2(data.amount.toString()).multipliedBy(priceX128ToPrice(data.fillOrKillParams.min_price)).toFixed(0);
|
|
329
|
+
extraParams = {
|
|
330
|
+
chain: "Bitcoin",
|
|
331
|
+
min_output_amount: `0x${BigInt(minOutputAmount).toString(16)}`,
|
|
332
|
+
retry_duration: data.fillOrKillParams.retry_duration
|
|
333
|
+
};
|
|
334
|
+
} else if (data.srcAsset.chain === "Ethereum" || data.srcAsset.chain === "Arbitrum") {
|
|
335
|
+
extraParams = {
|
|
336
|
+
chain: data.srcAsset.chain,
|
|
337
|
+
input_amount: `0x${BigInt(data.amount).toString(16)}`,
|
|
338
|
+
refund_parameters: data.fillOrKillParams
|
|
339
|
+
};
|
|
340
|
+
} else if (data.srcAsset.chain === "Solana") {
|
|
341
|
+
assert(data.srcAddress, "srcAddress is required for Solana");
|
|
342
|
+
assert(data.extraParams?.solanaDataAccount, "solanaDataAccount is required for Solana");
|
|
343
|
+
extraParams = {
|
|
344
|
+
chain: "Solana",
|
|
345
|
+
from: data.srcAddress,
|
|
346
|
+
event_data_account: data.extraParams.solanaDataAccount,
|
|
347
|
+
input_amount: `0x${BigInt(data.amount).toString(16)}`,
|
|
348
|
+
refund_parameters: data.fillOrKillParams
|
|
349
|
+
};
|
|
350
|
+
} else {
|
|
351
|
+
throw new Error(`parameter encoding is not supported for ${data.srcAsset.chain}`);
|
|
369
352
|
}
|
|
370
|
-
return
|
|
371
|
-
}
|
|
372
|
-
|
|
373
|
-
address: z.union([
|
|
374
|
-
dotAddress,
|
|
375
|
-
ethereumAddress,
|
|
376
|
-
btcAddress(network),
|
|
377
|
-
solanaAddress
|
|
378
|
-
]),
|
|
379
|
-
issued_block: z.number(),
|
|
380
|
-
channel_id: z.number(),
|
|
381
|
-
source_chain_expiry_block: z.bigint(),
|
|
382
|
-
channel_opening_fee: z.bigint()
|
|
383
|
-
}).transform(({ address, issued_block, channel_id, source_chain_expiry_block, channel_opening_fee }) => ({
|
|
384
|
-
address,
|
|
385
|
-
issuedBlock: issued_block,
|
|
386
|
-
channelId: BigInt(channel_id),
|
|
387
|
-
sourceChainExpiryBlock: source_chain_expiry_block,
|
|
388
|
-
channelOpeningFee: channel_opening_fee
|
|
389
|
-
})).parse(response), "validateResponse");
|
|
390
|
-
async function requestSwapDepositAddress(swapRequest, opts, chainflipNetwork2) {
|
|
353
|
+
return { ...data, extraParams };
|
|
354
|
+
});
|
|
355
|
+
async function requestSwapDepositAddress(request, opts, chainflipNetwork2) {
|
|
391
356
|
const client = new HttpClient(opts.url);
|
|
392
|
-
|
|
393
|
-
...
|
|
394
|
-
|
|
395
|
-
|
|
396
|
-
|
|
397
|
-
|
|
398
|
-
|
|
399
|
-
|
|
400
|
-
|
|
401
|
-
|
|
402
|
-
|
|
403
|
-
|
|
404
|
-
|
|
357
|
+
if (request.srcChain && typeof request.srcAsset === "string") {
|
|
358
|
+
request = { ...request, srcAsset: { asset: request.srcAsset, chain: request.srcChain } };
|
|
359
|
+
}
|
|
360
|
+
if (request.destChain && typeof request.destAsset === "string") {
|
|
361
|
+
request = { ...request, destAsset: { asset: request.destAsset, chain: request.destChain } };
|
|
362
|
+
}
|
|
363
|
+
const params = getDepositAddressRequestSchema(chainflipNetwork2).parse(request);
|
|
364
|
+
const response = await client.sendRequest(
|
|
365
|
+
"broker_requestSwapDepositAddress",
|
|
366
|
+
params.srcAsset,
|
|
367
|
+
params.destAsset,
|
|
368
|
+
params.destAddress,
|
|
369
|
+
params.commissionBps,
|
|
370
|
+
params.ccmParams,
|
|
371
|
+
params.maxBoostFeeBps,
|
|
372
|
+
params.affiliates,
|
|
373
|
+
params.fillOrKillParams,
|
|
374
|
+
params.dcaParams
|
|
375
|
+
);
|
|
376
|
+
if (params.srcAsset.chain === "Polkadot" && isHex(response.address)) {
|
|
377
|
+
response.address = ss582.encode({ data: response.address, ss58Format: DOT_PREFIX });
|
|
378
|
+
}
|
|
379
|
+
return transformKeysToCamelCase(response);
|
|
405
380
|
}
|
|
406
|
-
|
|
407
|
-
|
|
408
|
-
|
|
381
|
+
async function requestSwapParameterEncoding(request, opts, chainflipNetwork2) {
|
|
382
|
+
const client = new HttpClient(opts.url);
|
|
383
|
+
const params = getParameterEncodingRequestSchema(chainflipNetwork2).parse(request);
|
|
384
|
+
const response = await client.sendRequest(
|
|
385
|
+
"broker_request_swap_parameter_encoding",
|
|
386
|
+
params.srcAsset,
|
|
387
|
+
params.destAsset,
|
|
388
|
+
params.destAddress,
|
|
389
|
+
params.commissionBps,
|
|
390
|
+
params.extraParams,
|
|
391
|
+
params.ccmParams,
|
|
392
|
+
params.maxBoostFeeBps,
|
|
393
|
+
params.affiliates,
|
|
394
|
+
params.dcaParams
|
|
395
|
+
);
|
|
396
|
+
return transformKeysToCamelCase(response);
|
|
397
|
+
}
|
|
398
|
+
var getPriceX128FromPrice = (price, srcAsset, destAsset) => BigNumber2(price).multipliedBy(new BigNumber2(2).pow(128)).shiftedBy(assetConstants[destAsset].decimals - assetConstants[srcAsset].decimals).toFixed(0);
|
|
399
|
+
var parseFoKParams = (params, quote) => {
|
|
409
400
|
if (!params) return void 0;
|
|
410
401
|
const srcAsset = getInternalAsset(quote.srcAsset);
|
|
411
402
|
const destAsset = getInternalAsset(quote.destAsset);
|
|
412
403
|
let minPrice;
|
|
413
404
|
if ("minPrice" in params) {
|
|
414
|
-
assert(
|
|
405
|
+
assert(
|
|
406
|
+
!("slippageTolerancePercent" in params),
|
|
407
|
+
"Cannot have both minPrice and slippageTolerancePercent"
|
|
408
|
+
);
|
|
415
409
|
minPrice = params.minPrice;
|
|
416
410
|
} else if ("slippageTolerancePercent" in params) {
|
|
417
|
-
const tolerance = new
|
|
411
|
+
const tolerance = new BigNumber2(params.slippageTolerancePercent);
|
|
418
412
|
assert(!tolerance.isNaN(), "Invalid slippage tolerance");
|
|
419
|
-
assert(
|
|
420
|
-
|
|
413
|
+
assert(
|
|
414
|
+
tolerance.gte(0) && tolerance.lte(100),
|
|
415
|
+
"Slippage tolerance must be between 0 and 100 inclusive",
|
|
416
|
+
RangeError
|
|
417
|
+
);
|
|
418
|
+
const estimatedPrice = new BigNumber2(quote.estimatedPrice);
|
|
421
419
|
assert(!estimatedPrice.isNaN(), "Invalid estimated price");
|
|
422
|
-
minPrice = estimatedPrice.times(new
|
|
420
|
+
minPrice = estimatedPrice.times(new BigNumber2(100).minus(tolerance).dividedBy(100)).toFixed(assetConstants[destAsset].decimals);
|
|
423
421
|
} else {
|
|
424
422
|
throw new Error("Either minPrice or slippageTolerancePercent must be provided");
|
|
425
423
|
}
|
|
@@ -428,11 +426,11 @@ var parseFoKParams = /* @__PURE__ */ __name((params, quote) => {
|
|
|
428
426
|
retryDurationBlocks: params.retryDurationBlocks,
|
|
429
427
|
minPriceX128: getPriceX128FromPrice(minPrice, srcAsset, destAsset)
|
|
430
428
|
};
|
|
431
|
-
}
|
|
429
|
+
};
|
|
432
430
|
|
|
433
431
|
// ../shared/src/rpc/utils.ts
|
|
434
432
|
var MAX_SWAP_AMOUNT = 2n ** 128n - 1n;
|
|
435
|
-
var validateSwapAmount =
|
|
433
|
+
var validateSwapAmount = (env, asset2, amount) => {
|
|
436
434
|
const minimumAmount = readChainAssetValue(env.ingressEgress.minimumDepositAmounts, asset2);
|
|
437
435
|
if (amount < minimumAmount) {
|
|
438
436
|
return {
|
|
@@ -447,152 +445,12 @@ var validateSwapAmount = /* @__PURE__ */ __name((env, asset2, amount) => {
|
|
|
447
445
|
reason: `expected amount is above maximum swap amount (${maxAmount})`
|
|
448
446
|
};
|
|
449
447
|
}
|
|
450
|
-
return {
|
|
451
|
-
|
|
452
|
-
};
|
|
453
|
-
}, "validateSwapAmount");
|
|
454
|
-
|
|
455
|
-
// ../shared/src/evm.ts
|
|
456
|
-
var assertIsEvmChain = /* @__PURE__ */ __name((chain2) => {
|
|
457
|
-
const evmChainId = getEvmChainId(chain2, ChainflipNetworks.backspin);
|
|
458
|
-
assert(evmChainId, `Chain ${chain2} is not an evm chain`);
|
|
459
|
-
}, "assertIsEvmChain");
|
|
460
|
-
var assertIsCCMDestination = /* @__PURE__ */ __name((chain2) => {
|
|
461
|
-
if (chain2 === "Solana") return;
|
|
462
|
-
assertIsEvmChain(chain2);
|
|
463
|
-
}, "assertIsCCMDestination");
|
|
464
|
-
var assertSignerIsConnectedToChain = /* @__PURE__ */ __name(async (opts, chain2) => {
|
|
465
|
-
if (opts.network === "localnet") return;
|
|
466
|
-
assert(opts.signer.provider, "Signer has no provider");
|
|
467
|
-
const sourceChainId = getEvmChainId(chain2, opts.network);
|
|
468
|
-
assert(sourceChainId, `Chain ${chain2} has no evm chain id`);
|
|
469
|
-
const { chainId: signerChainId } = await opts.signer.provider.getNetwork();
|
|
470
|
-
assert(BigInt(signerChainId) === BigInt(sourceChainId), `Signer is connected to unexpected evm chain (expected: ${sourceChainId}, got: ${signerChainId})`);
|
|
471
|
-
}, "assertSignerIsConnectedToChain");
|
|
472
|
-
|
|
473
|
-
// ../shared/src/vault/executeSwap.ts
|
|
474
|
-
var encodeAddress2 = /* @__PURE__ */ __name((chain2, address) => {
|
|
475
|
-
if (chain2 === Chains.Polkadot) return bytesToHex(ss582.decode(dotAddress.parse(address)).data);
|
|
476
|
-
if (chain2 === Chains.Bitcoin) return `0x${Buffer.from(address).toString("hex")}`;
|
|
477
|
-
if (chain2 === Chains.Ethereum || chain2 === Chains.Arbitrum) return address;
|
|
478
|
-
if (chain2 === Chains.Solana) {
|
|
479
|
-
if (isHex(address)) return address;
|
|
480
|
-
return bytesToHex(base58.decode(address));
|
|
481
|
-
}
|
|
482
|
-
throw new Error(`cannot encode address for chain ${chain2}`);
|
|
483
|
-
}, "encodeAddress");
|
|
484
|
-
var assertIsValidSwap = /* @__PURE__ */ __name((params) => {
|
|
485
|
-
const { srcAsset, destAsset } = getInternalAssets(params);
|
|
486
|
-
assert(srcAsset !== destAsset, "source asset and destination asset cannot be the same");
|
|
487
|
-
}, "assertIsValidSwap");
|
|
488
|
-
var getVaultContract = /* @__PURE__ */ __name((chain2, networkOpts) => {
|
|
489
|
-
const vaultContractAddress = networkOpts.network === "localnet" ? networkOpts.vaultContractAddress : getVaultContractAddress(chain2, networkOpts.network);
|
|
490
|
-
return {
|
|
491
|
-
vaultContract: Vault__factory.connect(vaultContractAddress, networkOpts.signer),
|
|
492
|
-
vaultAddress: vaultContractAddress
|
|
493
|
-
};
|
|
494
|
-
}, "getVaultContract");
|
|
495
|
-
var getErc20Address = /* @__PURE__ */ __name((asset2, networkOpts) => {
|
|
496
|
-
const erc20Address = networkOpts.network === "localnet" ? networkOpts.srcTokenContractAddress : getTokenContractAddress(asset2, networkOpts.network);
|
|
497
|
-
assert(erc20Address !== void 0, `Missing ERC20 contract address for ${asset2}`);
|
|
498
|
-
return erc20Address;
|
|
499
|
-
}, "getErc20Address");
|
|
500
|
-
var swapNative = /* @__PURE__ */ __name(async (params, networkOpts, txOpts) => {
|
|
501
|
-
const destAsset = getInternalAsset({
|
|
502
|
-
chain: params.destChain,
|
|
503
|
-
asset: params.destAsset
|
|
504
|
-
});
|
|
505
|
-
const { vaultContract: vault } = getVaultContract(params.srcChain, networkOpts);
|
|
506
|
-
const transaction = await vault.xSwapNative(chainConstants[params.destChain].contractId, encodeAddress2(params.destChain, params.destAddress), assetConstants[destAsset].contractId, params.ccmParams?.cfParameters ?? "0x", {
|
|
507
|
-
value: params.amount,
|
|
508
|
-
...extractOverrides(txOpts)
|
|
509
|
-
});
|
|
510
|
-
await transaction.wait(txOpts.wait);
|
|
511
|
-
return transaction;
|
|
512
|
-
}, "swapNative");
|
|
513
|
-
var swapToken = /* @__PURE__ */ __name(async (params, networkOpts, txOpts) => {
|
|
514
|
-
const { srcAsset, destAsset } = getInternalAssets(params);
|
|
515
|
-
const { vaultContract: vault, vaultAddress } = getVaultContract(params.srcChain, networkOpts);
|
|
516
|
-
const erc20Address = getErc20Address(srcAsset, networkOpts);
|
|
517
|
-
const { hasSufficientAllowance } = await checkAllowance(BigInt(params.amount), vaultAddress, erc20Address, networkOpts.signer);
|
|
518
|
-
assert(hasSufficientAllowance, "Swap amount exceeds allowance");
|
|
519
|
-
const transaction = await vault.xSwapToken(chainConstants[params.destChain].contractId, encodeAddress2(params.destChain, params.destAddress), assetConstants[destAsset].contractId, erc20Address, params.amount, params.ccmParams?.cfParameters ?? "0x", extractOverrides(txOpts));
|
|
520
|
-
await transaction.wait(txOpts.wait);
|
|
521
|
-
return transaction;
|
|
522
|
-
}, "swapToken");
|
|
523
|
-
var callNative = /* @__PURE__ */ __name(async (params, networkOpts, txOpts) => {
|
|
524
|
-
const destAsset = getInternalAsset({
|
|
525
|
-
chain: params.destChain,
|
|
526
|
-
asset: params.destAsset
|
|
527
|
-
});
|
|
528
|
-
const { vaultContract: vault } = getVaultContract(params.srcChain, networkOpts);
|
|
529
|
-
const transaction = await vault.xCallNative(chainConstants[params.destChain].contractId, encodeAddress2(params.destChain, params.destAddress), assetConstants[destAsset].contractId, params.ccmParams.message, params.ccmParams.gasBudget, params.ccmParams?.cfParameters ?? "0x", {
|
|
530
|
-
value: params.amount,
|
|
531
|
-
...extractOverrides(txOpts)
|
|
532
|
-
});
|
|
533
|
-
await transaction.wait(txOpts.wait);
|
|
534
|
-
return transaction;
|
|
535
|
-
}, "callNative");
|
|
536
|
-
var callToken = /* @__PURE__ */ __name(async (params, networkOpts, txOpts) => {
|
|
537
|
-
const { srcAsset, destAsset } = getInternalAssets(params);
|
|
538
|
-
const { vaultContract: vault, vaultAddress } = getVaultContract(params.srcChain, networkOpts);
|
|
539
|
-
const erc20Address = getErc20Address(srcAsset, networkOpts);
|
|
540
|
-
const { hasSufficientAllowance } = await checkAllowance(BigInt(params.amount), vaultAddress, erc20Address, networkOpts.signer);
|
|
541
|
-
assert(hasSufficientAllowance, "Swap amount exceeds allowance");
|
|
542
|
-
const transaction = await vault.xCallToken(chainConstants[params.destChain].contractId, encodeAddress2(params.destChain, params.destAddress), assetConstants[destAsset].contractId, params.ccmParams.message, params.ccmParams.gasBudget, erc20Address, params.amount, params.ccmParams?.cfParameters ?? "0x", extractOverrides(txOpts));
|
|
543
|
-
await transaction.wait(txOpts.wait);
|
|
544
|
-
return transaction;
|
|
545
|
-
}, "callToken");
|
|
546
|
-
var executeSwap = /* @__PURE__ */ __name(async ({ ccmParams: unvalidatedCcmParams, ...params }, networkOpts, txOpts) => {
|
|
547
|
-
assertIsValidSwap(params);
|
|
548
|
-
assertIsEvmChain(params.srcChain);
|
|
549
|
-
assertValidAddress(params.destChain, params.destAddress, networkOpts.network);
|
|
550
|
-
await assertSignerIsConnectedToChain(networkOpts, params.srcChain);
|
|
551
|
-
const internalSrcAsset = getInternalAsset({
|
|
552
|
-
asset: params.srcAsset,
|
|
553
|
-
chain: params.srcChain
|
|
554
|
-
});
|
|
555
|
-
if (unvalidatedCcmParams) {
|
|
556
|
-
assertIsCCMDestination(params.destChain);
|
|
557
|
-
const validatedCcmParams = ccmParamsSchema.parse(unvalidatedCcmParams);
|
|
558
|
-
return internalSrcAsset === chainConstants[params.srcChain].gasAsset ? callNative({
|
|
559
|
-
...params,
|
|
560
|
-
ccmParams: validatedCcmParams
|
|
561
|
-
}, networkOpts, txOpts) : callToken({
|
|
562
|
-
...params,
|
|
563
|
-
ccmParams: validatedCcmParams
|
|
564
|
-
}, networkOpts, txOpts);
|
|
565
|
-
}
|
|
566
|
-
return internalSrcAsset === chainConstants[params.srcChain].gasAsset ? swapNative(params, networkOpts, txOpts) : swapToken(params, networkOpts, txOpts);
|
|
567
|
-
}, "executeSwap");
|
|
568
|
-
var executeSwap_default = executeSwap;
|
|
569
|
-
|
|
570
|
-
// ../shared/src/vault/approval.ts
|
|
571
|
-
var checkVaultAllowance = /* @__PURE__ */ __name((params, networkOpts) => {
|
|
572
|
-
const erc20Address = networkOpts.network === "localnet" ? networkOpts.srcTokenContractAddress : getTokenContractAddress(getInternalAsset({
|
|
573
|
-
chain: params.srcChain,
|
|
574
|
-
asset: params.srcAsset
|
|
575
|
-
}), networkOpts.network);
|
|
576
|
-
assert(erc20Address !== void 0, "Missing ERC20 contract address");
|
|
577
|
-
const vaultContractAddress = networkOpts.network === "localnet" ? networkOpts.vaultContractAddress : getVaultContractAddress(params.srcChain, networkOpts.network);
|
|
578
|
-
return checkAllowance(BigInt(params.amount), vaultContractAddress, erc20Address, networkOpts.signer);
|
|
579
|
-
}, "checkVaultAllowance");
|
|
580
|
-
var approveVault = /* @__PURE__ */ __name(async (params, networkOpts, txOpts) => {
|
|
581
|
-
await assertSignerIsConnectedToChain(networkOpts, params.srcChain);
|
|
582
|
-
const { hasSufficientAllowance, erc20, allowance } = await checkVaultAllowance(params, networkOpts);
|
|
583
|
-
if (hasSufficientAllowance) return null;
|
|
584
|
-
const vaultContractAddress = networkOpts.network === "localnet" ? networkOpts.vaultContractAddress : getVaultContractAddress(params.srcChain, networkOpts.network);
|
|
585
|
-
return approve(BigInt(params.amount), vaultContractAddress, erc20, allowance, txOpts);
|
|
586
|
-
}, "approveVault");
|
|
448
|
+
return { success: true };
|
|
449
|
+
};
|
|
587
450
|
|
|
588
451
|
// ../swap/src/utils/dataStructures.ts
|
|
589
|
-
var
|
|
590
|
-
var Timer = (_a = class {
|
|
452
|
+
var Timer = class {
|
|
591
453
|
constructor(value, cb, ms) {
|
|
592
|
-
__publicField(this, "value");
|
|
593
|
-
__publicField(this, "cb");
|
|
594
|
-
__publicField(this, "ms");
|
|
595
|
-
__publicField(this, "timeout");
|
|
596
454
|
this.value = value;
|
|
597
455
|
this.cb = cb;
|
|
598
456
|
this.ms = ms;
|
|
@@ -611,12 +469,9 @@ var Timer = (_a = class {
|
|
|
611
469
|
clear() {
|
|
612
470
|
if (this.timeout) clearTimeout(this.timeout);
|
|
613
471
|
}
|
|
614
|
-
}
|
|
615
|
-
var
|
|
472
|
+
};
|
|
473
|
+
var CacheMap = class {
|
|
616
474
|
constructor(ttl, resetExpiryOnLookup = true) {
|
|
617
|
-
__publicField(this, "ttl");
|
|
618
|
-
__publicField(this, "resetExpiryOnLookup");
|
|
619
|
-
__publicField(this, "store");
|
|
620
475
|
this.ttl = ttl;
|
|
621
476
|
this.resetExpiryOnLookup = resetExpiryOnLookup;
|
|
622
477
|
this.store = /* @__PURE__ */ new Map();
|
|
@@ -635,12 +490,13 @@ var _CacheMap = class _CacheMap {
|
|
|
635
490
|
return this.store.delete(key);
|
|
636
491
|
}
|
|
637
492
|
};
|
|
638
|
-
|
|
639
|
-
|
|
640
|
-
|
|
641
|
-
|
|
493
|
+
var AsyncCacheMap = class extends CacheMap {
|
|
494
|
+
constructor({
|
|
495
|
+
fetch,
|
|
496
|
+
ttl,
|
|
497
|
+
resetExpiryOnLookup = true
|
|
498
|
+
}) {
|
|
642
499
|
super(ttl, resetExpiryOnLookup);
|
|
643
|
-
__publicField(this, "fetch");
|
|
644
500
|
this.fetch = fetch;
|
|
645
501
|
}
|
|
646
502
|
get(key) {
|
|
@@ -655,58 +511,69 @@ var _AsyncCacheMap = class _AsyncCacheMap extends CacheMap {
|
|
|
655
511
|
return promise;
|
|
656
512
|
}
|
|
657
513
|
load(key) {
|
|
658
|
-
return this.get(key).then(
|
|
514
|
+
return this.get(key).then(
|
|
515
|
+
() => true,
|
|
516
|
+
() => false
|
|
517
|
+
);
|
|
659
518
|
}
|
|
660
519
|
};
|
|
661
|
-
|
|
662
|
-
|
|
663
|
-
|
|
664
|
-
|
|
665
|
-
|
|
666
|
-
|
|
667
|
-
|
|
668
|
-
|
|
669
|
-
|
|
520
|
+
var getTokenContractAddress = (asset2, network) => {
|
|
521
|
+
switch (asset2) {
|
|
522
|
+
case "Btc":
|
|
523
|
+
case "Dot":
|
|
524
|
+
case "Eth":
|
|
525
|
+
case "ArbEth":
|
|
526
|
+
case "Sol":
|
|
527
|
+
return void 0;
|
|
528
|
+
default:
|
|
529
|
+
return ADDRESSES[network][`${toUpperCase(asset2)}_CONTRACT_ADDRESS`];
|
|
530
|
+
}
|
|
531
|
+
};
|
|
532
|
+
var getAssetData = (asset2, network, env) => {
|
|
670
533
|
const assetConstant = assetConstants[asset2];
|
|
671
534
|
return {
|
|
672
535
|
chainflipId: asset2,
|
|
673
536
|
asset: assetConstant.asset,
|
|
674
537
|
chain: assetConstant.chain,
|
|
675
|
-
contractAddress:
|
|
538
|
+
contractAddress: getTokenContractAddress(asset2, network),
|
|
676
539
|
decimals: assetConstant.decimals,
|
|
677
540
|
name: assetConstant.name,
|
|
678
541
|
symbol: assetConstant.asset,
|
|
679
542
|
isMainnet: !isTestnet(network),
|
|
680
|
-
minimumSwapAmount: readChainAssetValue(
|
|
543
|
+
minimumSwapAmount: readChainAssetValue(
|
|
544
|
+
env.ingressEgress.minimumDepositAmounts,
|
|
545
|
+
asset2
|
|
546
|
+
).toString(),
|
|
681
547
|
maximumSwapAmount: readChainAssetValue(env.swapping.maximumSwapAmounts, asset2)?.toString() ?? null,
|
|
682
|
-
minimumEgressAmount: readChainAssetValue(
|
|
548
|
+
minimumEgressAmount: readChainAssetValue(
|
|
549
|
+
env.ingressEgress.minimumEgressAmounts,
|
|
550
|
+
asset2
|
|
551
|
+
).toString()
|
|
683
552
|
};
|
|
684
|
-
}
|
|
553
|
+
};
|
|
685
554
|
|
|
686
555
|
// src/swap/chains.ts
|
|
687
|
-
var getChainData =
|
|
556
|
+
var getChainData = (chain2, network, env) => ({
|
|
688
557
|
chain: chain2,
|
|
689
558
|
name: chain2,
|
|
690
559
|
evmChainId: getEvmChainId(chain2, network),
|
|
691
560
|
isMainnet: !isTestnet(network),
|
|
692
561
|
requiredBlockConfirmations: isNotNullish(env.ingressEgress.witnessSafetyMargins[chain2]) ? Number(env.ingressEgress.witnessSafetyMargins[chain2]) + 1 : void 0,
|
|
693
562
|
maxRetryDurationBlocks: env.ingressEgress.maxSwapRetryDurationBlocks[chain2]
|
|
694
|
-
})
|
|
563
|
+
});
|
|
695
564
|
|
|
696
565
|
// package.json
|
|
697
|
-
var version = "1.
|
|
566
|
+
var version = "1.8.0-beta.1";
|
|
698
567
|
|
|
699
568
|
// src/swap/consts.ts
|
|
700
|
-
var CF_SDK_VERSION_HEADERS = {
|
|
701
|
-
"X-Chainflip-Sdk-Version": version
|
|
702
|
-
};
|
|
569
|
+
var CF_SDK_VERSION_HEADERS = { "X-Chainflip-Sdk-Version": version };
|
|
703
570
|
var BACKEND_SERVICE_URLS = {
|
|
704
571
|
[ChainflipNetworks.backspin]: "https://chainflip-swap-backspin.staging/",
|
|
705
572
|
[ChainflipNetworks.sisyphos]: "https://chainflip-swap.staging/",
|
|
706
573
|
[ChainflipNetworks.perseverance]: "https://chainflip-swap-perseverance.chainflip.io/",
|
|
707
574
|
[ChainflipNetworks.mainnet]: "https://chainflip-swap.chainflip.io/"
|
|
708
575
|
};
|
|
709
|
-
var getQuote =
|
|
576
|
+
var getQuote = async (baseUrl, quoteRequest, { signal }) => {
|
|
710
577
|
const { brokerCommissionBps, ...returnedRequestData } = quoteRequest;
|
|
711
578
|
const params = {
|
|
712
579
|
amount: returnedRequestData.amount,
|
|
@@ -714,6 +581,7 @@ var getQuote = /* @__PURE__ */ __name(async (baseUrl, quoteRequest, { signal })
|
|
|
714
581
|
srcAsset: returnedRequestData.srcAsset,
|
|
715
582
|
destChain: returnedRequestData.destChain,
|
|
716
583
|
destAsset: returnedRequestData.destAsset,
|
|
584
|
+
isVaultSwap: String(Boolean(quoteRequest.isVaultSwap)),
|
|
717
585
|
...brokerCommissionBps && {
|
|
718
586
|
brokerCommissionBps: String(brokerCommissionBps)
|
|
719
587
|
},
|
|
@@ -725,12 +593,9 @@ var getQuote = /* @__PURE__ */ __name(async (baseUrl, quoteRequest, { signal })
|
|
|
725
593
|
signal,
|
|
726
594
|
headers: CF_SDK_VERSION_HEADERS
|
|
727
595
|
});
|
|
728
|
-
return {
|
|
729
|
-
|
|
730
|
-
|
|
731
|
-
};
|
|
732
|
-
}, "getQuote");
|
|
733
|
-
var getQuoteV2 = /* @__PURE__ */ __name(async (baseUrl, quoteRequest, { signal }) => {
|
|
596
|
+
return { ...returnedRequestData, quote: data };
|
|
597
|
+
};
|
|
598
|
+
var getQuoteV2 = async (baseUrl, quoteRequest, { signal }) => {
|
|
734
599
|
const { brokerCommissionBps, ...returnedRequestData } = quoteRequest;
|
|
735
600
|
const params = {
|
|
736
601
|
amount: returnedRequestData.amount,
|
|
@@ -738,10 +603,11 @@ var getQuoteV2 = /* @__PURE__ */ __name(async (baseUrl, quoteRequest, { signal }
|
|
|
738
603
|
srcAsset: returnedRequestData.srcAsset,
|
|
739
604
|
destChain: returnedRequestData.destChain,
|
|
740
605
|
destAsset: returnedRequestData.destAsset,
|
|
606
|
+
isVaultSwap: String(Boolean(quoteRequest.isVaultSwap)),
|
|
741
607
|
...brokerCommissionBps && {
|
|
742
608
|
brokerCommissionBps: String(brokerCommissionBps)
|
|
743
609
|
},
|
|
744
|
-
dcaEnabled: String(quoteRequest.dcaEnabled)
|
|
610
|
+
dcaEnabled: String(Boolean(quoteRequest.dcaEnabled))
|
|
745
611
|
};
|
|
746
612
|
const { data } = await axios.get("/v2/quote", {
|
|
747
613
|
baseURL: baseUrl,
|
|
@@ -749,30 +615,27 @@ var getQuoteV2 = /* @__PURE__ */ __name(async (baseUrl, quoteRequest, { signal }
|
|
|
749
615
|
signal,
|
|
750
616
|
headers: CF_SDK_VERSION_HEADERS
|
|
751
617
|
});
|
|
752
|
-
return {
|
|
753
|
-
|
|
754
|
-
|
|
755
|
-
};
|
|
756
|
-
}, "getQuoteV2");
|
|
757
|
-
var getStatus = /* @__PURE__ */ __name(async (baseUrl, { id }, { signal }) => {
|
|
618
|
+
return { ...returnedRequestData, quotes: data };
|
|
619
|
+
};
|
|
620
|
+
var getStatus = async (baseUrl, { id }, { signal }) => {
|
|
758
621
|
const { data } = await axios.get(`/swaps/${id}`, {
|
|
759
622
|
baseURL: baseUrl,
|
|
760
623
|
signal,
|
|
761
624
|
headers: CF_SDK_VERSION_HEADERS
|
|
762
625
|
});
|
|
763
626
|
return data;
|
|
764
|
-
}
|
|
765
|
-
var getStatusV2 =
|
|
627
|
+
};
|
|
628
|
+
var getStatusV2 = async (baseUrl, { id }, { signal }) => {
|
|
766
629
|
const { data } = await axios.get(`/v2/swaps/${id}`, {
|
|
767
630
|
baseURL: baseUrl,
|
|
768
631
|
signal,
|
|
769
632
|
headers: CF_SDK_VERSION_HEADERS
|
|
770
633
|
});
|
|
771
634
|
return data;
|
|
772
|
-
}
|
|
635
|
+
};
|
|
773
636
|
|
|
774
637
|
// src/swap/sdk.ts
|
|
775
|
-
var assertQuoteValid =
|
|
638
|
+
var assertQuoteValid = (quote) => {
|
|
776
639
|
switch (quote.type) {
|
|
777
640
|
case "REGULAR":
|
|
778
641
|
break;
|
|
@@ -782,26 +645,17 @@ var assertQuoteValid = /* @__PURE__ */ __name((quote) => {
|
|
|
782
645
|
default:
|
|
783
646
|
throw new Error("Invalid quote type");
|
|
784
647
|
}
|
|
785
|
-
}
|
|
786
|
-
var
|
|
648
|
+
};
|
|
649
|
+
var SwapSDK = class {
|
|
787
650
|
constructor(options = {}) {
|
|
788
|
-
|
|
789
|
-
__publicField(this, "rpcConfig");
|
|
790
|
-
__publicField(this, "trpc");
|
|
791
|
-
__publicField(this, "stateChainEnvironmentCache");
|
|
792
|
-
__publicField(this, "supportedAssets");
|
|
793
|
-
__publicField(this, "dcaEnabled", false);
|
|
651
|
+
this.dcaEnabled = false;
|
|
794
652
|
const network = options.network ?? ChainflipNetworks.perseverance;
|
|
795
653
|
this.options = {
|
|
796
654
|
...options,
|
|
797
655
|
network,
|
|
798
656
|
backendUrl: options.backendUrl ?? BACKEND_SERVICE_URLS[network]
|
|
799
657
|
};
|
|
800
|
-
this.rpcConfig = options.rpcUrl ? {
|
|
801
|
-
rpcUrl: options.rpcUrl
|
|
802
|
-
} : {
|
|
803
|
-
network
|
|
804
|
-
};
|
|
658
|
+
this.rpcConfig = options.rpcUrl ? { rpcUrl: options.rpcUrl } : { network };
|
|
805
659
|
this.trpc = createTRPCProxyClient({
|
|
806
660
|
transformer: superjson,
|
|
807
661
|
links: [
|
|
@@ -813,20 +667,19 @@ var _SwapSDK = class _SwapSDK {
|
|
|
813
667
|
});
|
|
814
668
|
this.dcaEnabled = options.enabledFeatures?.dca ?? false;
|
|
815
669
|
this.stateChainEnvironmentCache = new AsyncCacheMap({
|
|
816
|
-
fetch:
|
|
670
|
+
fetch: (_key) => getEnvironment(this.rpcConfig),
|
|
817
671
|
ttl: 6e4 * 10,
|
|
818
672
|
resetExpiryOnLookup: false
|
|
819
673
|
});
|
|
820
674
|
}
|
|
821
675
|
async getChains(sourceChain) {
|
|
822
|
-
if (sourceChain && !(sourceChain in Chains))
|
|
676
|
+
if (sourceChain && !(sourceChain in Chains))
|
|
677
|
+
throw new Error(`unsupported source chain "${sourceChain}"`);
|
|
823
678
|
const [env, supportedAssets] = await Promise.all([
|
|
824
679
|
this.getStateChainEnvironment(),
|
|
825
680
|
this.getSupportedAssets()
|
|
826
681
|
]);
|
|
827
|
-
const supportedChains = [
|
|
828
|
-
...new Set(supportedAssets.map((a) => assetConstants[a].chain))
|
|
829
|
-
];
|
|
682
|
+
const supportedChains = [...new Set(supportedAssets.map((a) => assetConstants[a].chain))];
|
|
830
683
|
return supportedChains.map((chain2) => getChainData(chain2, this.options.network, env)).filter((chain2) => chain2.chain !== sourceChain);
|
|
831
684
|
}
|
|
832
685
|
async getStateChainEnvironment() {
|
|
@@ -847,64 +700,89 @@ var _SwapSDK = class _SwapSDK {
|
|
|
847
700
|
]);
|
|
848
701
|
return supportedAssets.map((asset2) => getAssetData(asset2, this.options.network, env)).filter((asset2) => !chain2 || asset2.chain === chain2);
|
|
849
702
|
}
|
|
850
|
-
/** @deprecated DEPRECATED(1.
|
|
703
|
+
/** @deprecated DEPRECATED(1.7) use getQuoteV2() */
|
|
851
704
|
getQuote(quoteRequest, options = {}) {
|
|
705
|
+
console.error(
|
|
706
|
+
"[@chainflip/sdk] The getQuote method is deprecated and will be removed in the 1.9 release. Use the getQuoteV2 method instead."
|
|
707
|
+
);
|
|
852
708
|
const { brokerCommissionBps, affiliateBrokers, ...remainingRequest } = quoteRequest;
|
|
853
709
|
const submitterBrokerCommissionBps = brokerCommissionBps ?? this.options.broker?.commissionBps ?? 0;
|
|
854
710
|
const affiliateBrokerCommissionBps = affiliateBrokers?.reduce((acc, affiliate) => acc + affiliate.commissionBps, 0) ?? 0;
|
|
855
|
-
return getQuote(
|
|
856
|
-
|
|
857
|
-
|
|
858
|
-
|
|
711
|
+
return getQuote(
|
|
712
|
+
this.options.backendUrl,
|
|
713
|
+
{
|
|
714
|
+
...remainingRequest,
|
|
715
|
+
brokerCommissionBps: submitterBrokerCommissionBps + affiliateBrokerCommissionBps
|
|
716
|
+
},
|
|
717
|
+
options
|
|
718
|
+
);
|
|
859
719
|
}
|
|
860
720
|
getQuoteV2(quoteRequest, options = {}) {
|
|
861
721
|
const { brokerCommissionBps, affiliateBrokers, ...remainingRequest } = quoteRequest;
|
|
862
722
|
const submitterBrokerCommissionBps = brokerCommissionBps ?? this.options.broker?.commissionBps ?? 0;
|
|
863
723
|
const affiliateBrokerCommissionBps = affiliateBrokers?.reduce((acc, affiliate) => acc + affiliate.commissionBps, 0) ?? 0;
|
|
864
|
-
return getQuoteV2(
|
|
865
|
-
|
|
866
|
-
|
|
867
|
-
|
|
868
|
-
|
|
869
|
-
|
|
870
|
-
|
|
724
|
+
return getQuoteV2(
|
|
725
|
+
this.options.backendUrl,
|
|
726
|
+
{
|
|
727
|
+
...remainingRequest,
|
|
728
|
+
brokerCommissionBps: submitterBrokerCommissionBps + affiliateBrokerCommissionBps,
|
|
729
|
+
dcaEnabled: this.dcaEnabled
|
|
730
|
+
},
|
|
731
|
+
options
|
|
732
|
+
);
|
|
733
|
+
}
|
|
734
|
+
/** @deprecated DEPRECATED(1.7) use requestDepositAddressV2() */
|
|
871
735
|
async requestDepositAddress(depositAddressRequest) {
|
|
872
|
-
|
|
873
|
-
|
|
874
|
-
|
|
875
|
-
|
|
876
|
-
|
|
736
|
+
console.error(
|
|
737
|
+
"[@chainflip/sdk] The requestDepositAddress method is deprecated and will be removed in the 1.9 release. Use the requestDepositAddressV2 method instead."
|
|
738
|
+
);
|
|
739
|
+
const {
|
|
740
|
+
srcChain,
|
|
741
|
+
srcAsset,
|
|
742
|
+
amount,
|
|
743
|
+
destChain,
|
|
744
|
+
destAsset,
|
|
745
|
+
brokerCommissionBps,
|
|
746
|
+
affiliateBrokers
|
|
747
|
+
} = depositAddressRequest;
|
|
748
|
+
await this.validateSwapAmount({ chain: srcChain, asset: srcAsset }, BigInt(amount));
|
|
877
749
|
const fillOrKillParams2 = depositAddressRequest.fillOrKillParams ? {
|
|
878
750
|
...depositAddressRequest.fillOrKillParams,
|
|
879
|
-
minPriceX128: getPriceX128FromPrice(
|
|
880
|
-
|
|
881
|
-
asset: srcAsset
|
|
882
|
-
|
|
883
|
-
|
|
884
|
-
asset: destAsset
|
|
885
|
-
}))
|
|
751
|
+
minPriceX128: getPriceX128FromPrice(
|
|
752
|
+
depositAddressRequest.fillOrKillParams.minPrice,
|
|
753
|
+
getInternalAsset({ chain: srcChain, asset: srcAsset }),
|
|
754
|
+
getInternalAsset({ chain: destChain, asset: destAsset })
|
|
755
|
+
)
|
|
886
756
|
} : void 0;
|
|
887
757
|
let response;
|
|
888
|
-
if (this.options.broker
|
|
889
|
-
const result = await requestSwapDepositAddress(
|
|
890
|
-
|
|
891
|
-
|
|
892
|
-
|
|
893
|
-
|
|
894
|
-
|
|
895
|
-
|
|
896
|
-
|
|
758
|
+
if (this.options.broker) {
|
|
759
|
+
const result = await requestSwapDepositAddress(
|
|
760
|
+
{
|
|
761
|
+
...depositAddressRequest,
|
|
762
|
+
commissionBps: brokerCommissionBps ?? this.options.broker.commissionBps,
|
|
763
|
+
affiliates: affiliateBrokers,
|
|
764
|
+
fillOrKillParams: fillOrKillParams2
|
|
765
|
+
},
|
|
766
|
+
{ url: this.options.broker.url },
|
|
767
|
+
this.options.network
|
|
768
|
+
);
|
|
897
769
|
response = {
|
|
898
770
|
id: `${result.issuedBlock}-${depositAddressRequest.srcChain}-${result.channelId}`,
|
|
899
771
|
depositAddress: result.address,
|
|
900
|
-
brokerCommissionBps: this.options.broker.commissionBps,
|
|
772
|
+
brokerCommissionBps: brokerCommissionBps ?? this.options.broker.commissionBps ?? 0,
|
|
901
773
|
srcChainExpiryBlock: result.sourceChainExpiryBlock,
|
|
902
774
|
maxBoostFeeBps: depositAddressRequest.maxBoostFeeBps,
|
|
903
775
|
channelOpeningFee: result.channelOpeningFee
|
|
904
776
|
};
|
|
905
777
|
} else {
|
|
906
|
-
assert(
|
|
907
|
-
|
|
778
|
+
assert(
|
|
779
|
+
!depositAddressRequest.brokerCommissionBps,
|
|
780
|
+
"Broker commission is supported only when initializing the SDK with a brokerUrl"
|
|
781
|
+
);
|
|
782
|
+
assert(
|
|
783
|
+
!depositAddressRequest.affiliateBrokers?.length,
|
|
784
|
+
"Affiliate brokers are supported only when initializing the SDK with a brokerUrl"
|
|
785
|
+
);
|
|
908
786
|
assert(fillOrKillParams2, "Fill or kill parameters are required");
|
|
909
787
|
response = await this.trpc.openSwapDepositChannel.mutate({
|
|
910
788
|
...depositAddressRequest,
|
|
@@ -923,94 +801,52 @@ var _SwapSDK = class _SwapSDK {
|
|
|
923
801
|
channelOpeningFee: response.channelOpeningFee
|
|
924
802
|
};
|
|
925
803
|
}
|
|
926
|
-
/** @deprecated DEPRECATED(1.
|
|
804
|
+
/** @deprecated DEPRECATED(1.7) use getStatusV2() */
|
|
927
805
|
getStatus(swapStatusRequest, options = {}) {
|
|
806
|
+
console.error(
|
|
807
|
+
"[@chainflip/sdk] The getStatus method is deprecated and will be removed in the 1.9 release. Use the getStatusV2 method instead."
|
|
808
|
+
);
|
|
928
809
|
return getStatus(this.options.backendUrl, swapStatusRequest, options);
|
|
929
810
|
}
|
|
930
811
|
getStatusV2(swapStatusRequest, options = {}) {
|
|
931
812
|
return getStatusV2(this.options.backendUrl, swapStatusRequest, options);
|
|
932
813
|
}
|
|
933
|
-
async executeSwap(params, txOpts = {}) {
|
|
934
|
-
const { srcChain, srcAsset, amount } = params;
|
|
935
|
-
const { signer: optsSigner, ...remainingTxOpts } = txOpts;
|
|
936
|
-
const signer = optsSigner ?? this.options.signer;
|
|
937
|
-
assert(signer, "No signer provided");
|
|
938
|
-
await this.validateSwapAmount({
|
|
939
|
-
chain: srcChain,
|
|
940
|
-
asset: srcAsset
|
|
941
|
-
}, BigInt(amount));
|
|
942
|
-
const tx = await executeSwap_default(params, {
|
|
943
|
-
network: this.options.network,
|
|
944
|
-
signer
|
|
945
|
-
}, remainingTxOpts);
|
|
946
|
-
return tx.hash;
|
|
947
|
-
}
|
|
948
|
-
async approveVault(params, txOpts = {}) {
|
|
949
|
-
const { signer: optsSigner, ...remainingTxOpts } = txOpts;
|
|
950
|
-
const signer = optsSigner ?? this.options.signer;
|
|
951
|
-
assert(signer, "No signer provided");
|
|
952
|
-
const tx = await approveVault(params, {
|
|
953
|
-
signer,
|
|
954
|
-
network: this.options.network
|
|
955
|
-
}, remainingTxOpts);
|
|
956
|
-
return tx ? tx.hash : null;
|
|
957
|
-
}
|
|
958
814
|
async validateSwapAmount(asset2, amount) {
|
|
959
815
|
const stateChainEnv = await this.getStateChainEnvironment();
|
|
960
816
|
const internalAsset = getInternalAsset(asset2);
|
|
961
817
|
const result = validateSwapAmount(stateChainEnv, internalAsset, amount);
|
|
962
818
|
if (!result.success) throw new Error(result.reason);
|
|
963
819
|
}
|
|
964
|
-
async approveAndExecuteSwap(params, txOpts = {}) {
|
|
965
|
-
const { srcChain, srcAsset } = params;
|
|
966
|
-
const signer = txOpts.signer ?? this.options.signer;
|
|
967
|
-
assert(signer, "No signer provided");
|
|
968
|
-
const internalAsset = getInternalAsset({
|
|
969
|
-
chain: srcChain,
|
|
970
|
-
asset: srcAsset
|
|
971
|
-
});
|
|
972
|
-
let approveTxRef = null;
|
|
973
|
-
if (!isGasAsset(internalAsset)) {
|
|
974
|
-
approveTxRef = await this.approveVault(params, {
|
|
975
|
-
...txOpts,
|
|
976
|
-
nonce: void 0
|
|
977
|
-
});
|
|
978
|
-
}
|
|
979
|
-
const swapTxRef = await this.executeSwap(params, {
|
|
980
|
-
...txOpts,
|
|
981
|
-
nonce: void 0
|
|
982
|
-
});
|
|
983
|
-
return {
|
|
984
|
-
approveTxRef,
|
|
985
|
-
swapTxRef
|
|
986
|
-
};
|
|
987
|
-
}
|
|
988
820
|
async getSwapLimits() {
|
|
989
|
-
const {
|
|
990
|
-
|
|
991
|
-
|
|
992
|
-
|
|
993
|
-
};
|
|
821
|
+
const {
|
|
822
|
+
swapping: { maximumSwapAmounts },
|
|
823
|
+
ingressEgress: { minimumDepositAmounts }
|
|
824
|
+
} = await this.getStateChainEnvironment();
|
|
825
|
+
return { minimumSwapAmounts: minimumDepositAmounts, maximumSwapAmounts };
|
|
994
826
|
}
|
|
995
827
|
async getRequiredBlockConfirmations() {
|
|
996
|
-
const {
|
|
997
|
-
|
|
998
|
-
|
|
999
|
-
|
|
1000
|
-
|
|
828
|
+
const {
|
|
829
|
+
ingressEgress: { witnessSafetyMargins }
|
|
830
|
+
} = await this.getStateChainEnvironment();
|
|
831
|
+
return Object.keys(Chains).reduce(
|
|
832
|
+
(acc, chain2) => {
|
|
833
|
+
acc[chain2] = witnessSafetyMargins[chain2] ? Number(witnessSafetyMargins[chain2]) + 1 : null;
|
|
834
|
+
return acc;
|
|
835
|
+
},
|
|
836
|
+
{}
|
|
837
|
+
);
|
|
1001
838
|
}
|
|
1002
839
|
async getChannelOpeningFees() {
|
|
1003
|
-
const {
|
|
840
|
+
const {
|
|
841
|
+
ingressEgress: { channelOpeningFees }
|
|
842
|
+
} = await this.getStateChainEnvironment();
|
|
1004
843
|
return channelOpeningFees;
|
|
1005
844
|
}
|
|
1006
845
|
async getBoostLiquidity(params = {}) {
|
|
1007
846
|
let poolsDepth = await this.getBoostPoolsDepth();
|
|
1008
847
|
if ("chain" in params && "asset" in params) {
|
|
1009
848
|
const { chain: chain2, asset: asset2 } = params;
|
|
1010
|
-
const internalAsset = getInternalAsset({
|
|
1011
|
-
chain: chain2,
|
|
1012
|
-
asset: asset2
|
|
1013
|
-
});
|
|
849
|
+
const internalAsset = getInternalAsset({ chain: chain2, asset: asset2 });
|
|
1014
850
|
poolsDepth = poolsDepth.filter((boostPoolDepth) => boostPoolDepth.asset === internalAsset).sort((a, b) => b.tier - a.tier);
|
|
1015
851
|
}
|
|
1016
852
|
if ("feeTierBps" in params && params.feeTierBps !== void 0) {
|
|
@@ -1022,9 +858,18 @@ var _SwapSDK = class _SwapSDK {
|
|
|
1022
858
|
...getAssetAndChain(depth.asset)
|
|
1023
859
|
}));
|
|
1024
860
|
}
|
|
1025
|
-
async requestDepositAddressV2({
|
|
861
|
+
async requestDepositAddressV2({
|
|
862
|
+
quote,
|
|
863
|
+
srcAddress,
|
|
864
|
+
destAddress,
|
|
865
|
+
fillOrKillParams: inputFoKParams,
|
|
866
|
+
affiliateBrokers: affiliates,
|
|
867
|
+
ccmParams,
|
|
868
|
+
brokerCommissionBps
|
|
869
|
+
}) {
|
|
1026
870
|
await this.validateSwapAmount(quote.srcAsset, BigInt(quote.depositAmount));
|
|
1027
871
|
assertQuoteValid(quote);
|
|
872
|
+
assert(!quote.isVaultSwap, "Cannot open a deposit channel for a vault swap quote");
|
|
1028
873
|
const depositAddressRequest = {
|
|
1029
874
|
srcAsset: quote.srcAsset.asset,
|
|
1030
875
|
srcChain: quote.srcAsset.chain,
|
|
@@ -1039,24 +884,34 @@ var _SwapSDK = class _SwapSDK {
|
|
|
1039
884
|
amount: quote.depositAmount
|
|
1040
885
|
};
|
|
1041
886
|
let response;
|
|
1042
|
-
if (this.options.broker
|
|
1043
|
-
const result = await requestSwapDepositAddress(
|
|
1044
|
-
|
|
1045
|
-
|
|
1046
|
-
|
|
1047
|
-
|
|
1048
|
-
|
|
1049
|
-
|
|
887
|
+
if (this.options.broker) {
|
|
888
|
+
const result = await requestSwapDepositAddress(
|
|
889
|
+
{
|
|
890
|
+
...depositAddressRequest,
|
|
891
|
+
commissionBps: brokerCommissionBps ?? this.options.broker.commissionBps,
|
|
892
|
+
affiliates
|
|
893
|
+
},
|
|
894
|
+
{ url: this.options.broker.url },
|
|
895
|
+
this.options.network
|
|
896
|
+
);
|
|
1050
897
|
response = {
|
|
1051
898
|
id: `${result.issuedBlock}-${quote.srcAsset.chain}-${result.channelId}`,
|
|
1052
899
|
depositAddress: result.address,
|
|
1053
|
-
brokerCommissionBps: this.options.broker.commissionBps,
|
|
900
|
+
brokerCommissionBps: brokerCommissionBps ?? this.options.broker.commissionBps ?? 0,
|
|
1054
901
|
srcChainExpiryBlock: result.sourceChainExpiryBlock,
|
|
1055
902
|
maxBoostFeeBps: depositAddressRequest.maxBoostFeeBps,
|
|
1056
903
|
channelOpeningFee: result.channelOpeningFee
|
|
1057
904
|
};
|
|
1058
905
|
} else {
|
|
1059
906
|
assert(depositAddressRequest.fillOrKillParams, "fill or kill params are required");
|
|
907
|
+
assert(
|
|
908
|
+
!brokerCommissionBps,
|
|
909
|
+
"Broker commission is supported only when initializing the SDK with a brokerUrl"
|
|
910
|
+
);
|
|
911
|
+
assert(
|
|
912
|
+
!affiliates?.length,
|
|
913
|
+
"Affiliate brokers are supported only when initializing the SDK with a brokerUrl"
|
|
914
|
+
);
|
|
1060
915
|
response = await this.trpc.openSwapDepositChannel.mutate({
|
|
1061
916
|
...depositAddressRequest,
|
|
1062
917
|
fillOrKillParams: depositAddressRequest.fillOrKillParams,
|
|
@@ -1076,8 +931,59 @@ var _SwapSDK = class _SwapSDK {
|
|
|
1076
931
|
fillOrKillParams: inputFoKParams
|
|
1077
932
|
};
|
|
1078
933
|
}
|
|
934
|
+
async encodeVaultSwapData({
|
|
935
|
+
quote,
|
|
936
|
+
srcAddress,
|
|
937
|
+
destAddress,
|
|
938
|
+
fillOrKillParams: inputFoKParams,
|
|
939
|
+
affiliateBrokers: affiliates,
|
|
940
|
+
ccmParams,
|
|
941
|
+
brokerAccount,
|
|
942
|
+
brokerCommissionBps,
|
|
943
|
+
extraParams
|
|
944
|
+
}) {
|
|
945
|
+
await this.validateSwapAmount(quote.srcAsset, BigInt(quote.depositAmount));
|
|
946
|
+
assertQuoteValid(quote);
|
|
947
|
+
assert(quote.isVaultSwap, "Cannot encode vault swap data for a deposit channel quote");
|
|
948
|
+
const vaultSwapRequest = {
|
|
949
|
+
srcAsset: quote.srcAsset,
|
|
950
|
+
destAsset: quote.destAsset,
|
|
951
|
+
srcAddress,
|
|
952
|
+
destAddress,
|
|
953
|
+
amount: quote.depositAmount,
|
|
954
|
+
ccmParams,
|
|
955
|
+
maxBoostFeeBps: "maxBoostFeeBps" in quote ? quote.maxBoostFeeBps : void 0,
|
|
956
|
+
fillOrKillParams: parseFoKParams(inputFoKParams, quote),
|
|
957
|
+
dcaParams: quote.type === "DCA" ? quote.dcaParams : void 0,
|
|
958
|
+
extraParams,
|
|
959
|
+
brokerAccount,
|
|
960
|
+
brokerCommissionBps,
|
|
961
|
+
affiliates
|
|
962
|
+
};
|
|
963
|
+
if (this.options.broker) {
|
|
964
|
+
assert(
|
|
965
|
+
!vaultSwapRequest.brokerAccount,
|
|
966
|
+
"Cannot overwrite broker account when initializing the SDK with a brokerUrl"
|
|
967
|
+
);
|
|
968
|
+
return requestSwapParameterEncoding(
|
|
969
|
+
{
|
|
970
|
+
...vaultSwapRequest,
|
|
971
|
+
commissionBps: vaultSwapRequest.brokerCommissionBps ?? this.options.broker.commissionBps
|
|
972
|
+
},
|
|
973
|
+
{ url: this.options.broker.url },
|
|
974
|
+
this.options.network
|
|
975
|
+
);
|
|
976
|
+
}
|
|
977
|
+
assert(
|
|
978
|
+
!vaultSwapRequest.brokerCommissionBps || vaultSwapRequest.brokerAccount,
|
|
979
|
+
"Broker commission is supported only when setting a broker account"
|
|
980
|
+
);
|
|
981
|
+
assert(
|
|
982
|
+
!vaultSwapRequest.affiliates?.length || vaultSwapRequest.brokerAccount,
|
|
983
|
+
"Affiliate brokers are supported only when setting a broker account"
|
|
984
|
+
);
|
|
985
|
+
return this.trpc.encodeVaultSwapData.mutate(vaultSwapRequest);
|
|
986
|
+
}
|
|
1079
987
|
};
|
|
1080
|
-
__name(_SwapSDK, "SwapSDK");
|
|
1081
|
-
var SwapSDK = _SwapSDK;
|
|
1082
988
|
|
|
1083
989
|
export { SwapSDK };
|