@chainflip/sdk 2.3.2 → 2.3.3
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 +273 -417
- package/dist/swap.d.cts +39 -183
- package/dist/swap.d.ts +39 -183
- package/dist/swap.js +211 -355
- package/package.json +5 -6
package/dist/swap.js
CHANGED
|
@@ -1,24 +1,41 @@
|
|
|
1
|
-
import { getEnvironment,
|
|
1
|
+
import { getEnvironment, getEvmChainId, getAllSupplyPoolsDepth, getAllBoostPoolsDepth, SUPPLY_POOL_BOOST_FEE_BPS, assert, isNotNullish, ADDRESSES } from './chunk-6KPGKVRC.js';
|
|
2
2
|
import { unreachable } from '@chainflip/utils/assertion';
|
|
3
|
-
import { chainflipChains, assetSymbols, isValidAssetAndChain,
|
|
3
|
+
import { chainflipChains, assetSymbols, isValidAssetAndChain, getInternalAssets, assetConstants, isChainflipAsset, internalAssetToRpcAsset, getInternalAsset, chainflipNetworks, chainflipAssets, readAssetValue, anyAssetConstants } from '@chainflip/utils/chainflip';
|
|
4
4
|
export { getInternalAsset as getChainflipId } from '@chainflip/utils/chainflip';
|
|
5
5
|
import { calculateTotalEffectiveBorrowableAmount, ppmToBps } from '@chainflip/utils/lending';
|
|
6
|
-
import { initContract, initClient } from '@ts-rest/core';
|
|
7
|
-
import z3, { z } from 'zod';
|
|
8
|
-
import { isValidSolanaAddress } from '@chainflip/solana';
|
|
9
|
-
import * as ss58 from '@chainflip/utils/ss58';
|
|
10
|
-
import { isValidTronAddress } from '@chainflip/utils/tron';
|
|
11
|
-
import * as bitcoin from '@chainflip/bitcoin';
|
|
12
|
-
import { toUpperCase, isHex } from '@chainflip/utils/string';
|
|
13
|
-
import * as ethers from 'ethers';
|
|
14
|
-
import { hexEncodeNumber } from '@chainflip/utils/number';
|
|
15
6
|
import { HttpClient } from '@chainflip/rpc';
|
|
16
7
|
import { bytesToHex } from '@chainflip/utils/bytes';
|
|
8
|
+
import * as ss58 from '@chainflip/utils/ss58';
|
|
9
|
+
import { toUpperCase, isHex } from '@chainflip/utils/string';
|
|
17
10
|
import { priceX128ToPrice } from '@chainflip/utils/tickMath';
|
|
18
11
|
import BigNumber2 from 'bignumber.js';
|
|
12
|
+
import { z } from 'zod';
|
|
13
|
+
import { isValidSolanaAddress } from '@chainflip/solana';
|
|
14
|
+
import { isValidTronAddress } from '@chainflip/utils/tron';
|
|
15
|
+
import { hexEncodeNumber } from '@chainflip/utils/number';
|
|
16
|
+
import * as bitcoin from '@chainflip/bitcoin';
|
|
17
|
+
import * as ethers from 'ethers';
|
|
19
18
|
import { CHAINFLIP_BLOCK_TIME_SECONDS } from '@chainflip/utils/consts';
|
|
20
19
|
import axios from 'axios';
|
|
21
20
|
|
|
21
|
+
// ../shared/src/strings.ts
|
|
22
|
+
var toCamelCase = (str) => str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
|
|
23
|
+
|
|
24
|
+
// ../shared/src/objects.ts
|
|
25
|
+
var transformKeysToCamelCase = (obj) => {
|
|
26
|
+
if (Array.isArray(obj)) {
|
|
27
|
+
return obj.map(transformKeysToCamelCase);
|
|
28
|
+
}
|
|
29
|
+
if (obj !== null && typeof obj === "object") {
|
|
30
|
+
return Object.fromEntries(
|
|
31
|
+
Object.entries(obj).map(([key, value]) => [
|
|
32
|
+
toCamelCase(key),
|
|
33
|
+
transformKeysToCamelCase(value)
|
|
34
|
+
])
|
|
35
|
+
);
|
|
36
|
+
}
|
|
37
|
+
return obj;
|
|
38
|
+
};
|
|
22
39
|
var booleanString = z.string().regex(/^(true|false)$/i).transform((v) => v.toLowerCase() === "true");
|
|
23
40
|
var numericString = z.string().regex(/^[0-9]+$/);
|
|
24
41
|
var numericOrEmptyString = z.string().regex(/^[0-9]*$/);
|
|
@@ -38,16 +55,22 @@ var chainflipAddress = z.string().refine(
|
|
|
38
55
|
return false;
|
|
39
56
|
}
|
|
40
57
|
},
|
|
41
|
-
(
|
|
58
|
+
{ error: (issue) => `${issue.input} is not a valid Chainflip address` }
|
|
42
59
|
);
|
|
43
|
-
z.string().refine(isValidSolanaAddress,
|
|
44
|
-
|
|
45
|
-
})
|
|
46
|
-
|
|
47
|
-
|
|
48
|
-
})
|
|
49
|
-
var
|
|
50
|
-
var
|
|
60
|
+
z.string().refine(isValidSolanaAddress, {
|
|
61
|
+
error: (issue) => `${issue.input} is not a valid Solana address`
|
|
62
|
+
});
|
|
63
|
+
z.string().refine(isValidTronAddress, {
|
|
64
|
+
error: (issue) => `${issue.input} is not a valid Tron address`
|
|
65
|
+
});
|
|
66
|
+
var u16 = z.number().int().nonnegative().max(65535);
|
|
67
|
+
var u32 = z.number().int().nonnegative().max(4294967295);
|
|
68
|
+
var u128 = z.union([
|
|
69
|
+
z.number().int().nonnegative().safe(),
|
|
70
|
+
numericString,
|
|
71
|
+
hexString.refine((v) => v.length > 2, { message: "hex string must not be empty" })
|
|
72
|
+
]).transform((arg) => BigInt(arg)).refine((n) => n < 2n ** 128n, { message: "must be less than 2^128" });
|
|
73
|
+
var unsignedInteger = u128;
|
|
51
74
|
var chain = z.enum(chainflipChains);
|
|
52
75
|
var asset = z.enum(assetSymbols);
|
|
53
76
|
var uncheckedAssetAndChain = z.object({
|
|
@@ -55,175 +78,31 @@ var uncheckedAssetAndChain = z.object({
|
|
|
55
78
|
chain: z.string()
|
|
56
79
|
});
|
|
57
80
|
var assetAndChain = uncheckedAssetAndChain.refine(
|
|
58
|
-
(value) => isValidAssetAndChain(value)
|
|
81
|
+
(value) => chain.safeParse(value.chain).success && asset.safeParse(value.asset).success && isValidAssetAndChain(value)
|
|
59
82
|
);
|
|
60
|
-
|
|
61
|
-
// ../shared/src/api/encodeVaultSwapData.ts
|
|
62
|
-
var EncodedVaultSwapData = z.discriminatedUnion("chain", [
|
|
63
|
-
z.object({
|
|
64
|
-
chain: z.literal("Bitcoin"),
|
|
65
|
-
nulldataPayload: hexString,
|
|
66
|
-
depositAddress: z.string()
|
|
67
|
-
}),
|
|
68
|
-
z.object({
|
|
69
|
-
chain: z.enum(["Ethereum", "Arbitrum", "Bsc"]),
|
|
70
|
-
value: z.string(),
|
|
71
|
-
to: hexString,
|
|
72
|
-
calldata: hexString,
|
|
73
|
-
sourceTokenAddress: hexString.optional()
|
|
74
|
-
}),
|
|
75
|
-
z.object({
|
|
76
|
-
chain: z.literal("Tron"),
|
|
77
|
-
calldata: hexString,
|
|
78
|
-
value: z.string(),
|
|
79
|
-
to: tronAddress,
|
|
80
|
-
note: hexString,
|
|
81
|
-
sourceTokenAddress: tronAddress.optional()
|
|
82
|
-
}),
|
|
83
|
-
z.object({
|
|
84
|
-
chain: z.literal("Solana"),
|
|
85
|
-
programId: z.string(),
|
|
86
|
-
data: hexString,
|
|
87
|
-
accounts: z.array(
|
|
88
|
-
z.object({
|
|
89
|
-
pubkey: z.string(),
|
|
90
|
-
isSigner: z.boolean(),
|
|
91
|
-
isWritable: z.boolean()
|
|
92
|
-
})
|
|
93
|
-
)
|
|
94
|
-
})
|
|
95
|
-
]);
|
|
96
|
-
var NetworkInfo = z3.object({
|
|
97
|
-
assets: z3.array(
|
|
98
|
-
z3.object({
|
|
99
|
-
asset: z3.enum(chainflipAssets),
|
|
100
|
-
vaultSwapDepositsEnabled: z3.boolean(),
|
|
101
|
-
depositChannelDepositsEnabled: z3.boolean(),
|
|
102
|
-
depositChannelCreationEnabled: z3.boolean(),
|
|
103
|
-
egressEnabled: z3.boolean(),
|
|
104
|
-
boostDepositsEnabled: z3.boolean(),
|
|
105
|
-
livePriceProtectionEnabled: z3.boolean()
|
|
106
|
-
})
|
|
107
|
-
),
|
|
108
|
-
cfBrokerCommissionBps: z3.number()
|
|
109
|
-
});
|
|
110
|
-
var validatePolkadotAddress = (address) => {
|
|
111
|
-
if (isHex(address)) return address.length === 66;
|
|
112
|
-
try {
|
|
113
|
-
ss58.decode(address);
|
|
114
|
-
return true;
|
|
115
|
-
} catch {
|
|
116
|
-
return false;
|
|
117
|
-
}
|
|
118
|
-
};
|
|
119
|
-
var validateEvmAddress = (address) => ethers.isAddress(address);
|
|
120
|
-
var validateBitcoinMainnetAddress = (address) => bitcoin.isValidAddressForNetwork(address, "mainnet");
|
|
121
|
-
var validateBitcoinTestnetAddress = (address) => bitcoin.isValidAddressForNetwork(address, "testnet");
|
|
122
|
-
var validateBitcoinRegtestAddress = (address) => bitcoin.isValidAddressForNetwork(address, "regtest");
|
|
123
|
-
var validateSolanaAddress = isValidSolanaAddress;
|
|
124
|
-
var validateTronAddress = isValidTronAddress;
|
|
125
|
-
var validators = {
|
|
126
|
-
mainnet: {
|
|
127
|
-
Bitcoin: validateBitcoinMainnetAddress,
|
|
128
|
-
Ethereum: validateEvmAddress,
|
|
129
|
-
Arbitrum: validateEvmAddress,
|
|
130
|
-
Solana: validateSolanaAddress,
|
|
131
|
-
Assethub: validatePolkadotAddress,
|
|
132
|
-
Tron: validateTronAddress,
|
|
133
|
-
Bsc: validateEvmAddress
|
|
134
|
-
},
|
|
135
|
-
perseverance: {
|
|
136
|
-
Bitcoin: validateBitcoinTestnetAddress,
|
|
137
|
-
Ethereum: validateEvmAddress,
|
|
138
|
-
Arbitrum: validateEvmAddress,
|
|
139
|
-
Solana: validateSolanaAddress,
|
|
140
|
-
Assethub: validatePolkadotAddress,
|
|
141
|
-
Tron: validateTronAddress,
|
|
142
|
-
Bsc: validateEvmAddress
|
|
143
|
-
},
|
|
144
|
-
sisyphos: {
|
|
145
|
-
Bitcoin: validateBitcoinTestnetAddress,
|
|
146
|
-
Ethereum: validateEvmAddress,
|
|
147
|
-
Arbitrum: validateEvmAddress,
|
|
148
|
-
Solana: validateSolanaAddress,
|
|
149
|
-
Assethub: validatePolkadotAddress,
|
|
150
|
-
Tron: validateTronAddress,
|
|
151
|
-
Bsc: validateEvmAddress
|
|
152
|
-
},
|
|
153
|
-
backspin: {
|
|
154
|
-
Bitcoin: validateBitcoinRegtestAddress,
|
|
155
|
-
Ethereum: validateEvmAddress,
|
|
156
|
-
Arbitrum: validateEvmAddress,
|
|
157
|
-
Solana: validateSolanaAddress,
|
|
158
|
-
Assethub: validatePolkadotAddress,
|
|
159
|
-
Tron: validateTronAddress,
|
|
160
|
-
Bsc: validateEvmAddress
|
|
161
|
-
},
|
|
162
|
-
localnet: {
|
|
163
|
-
Bitcoin: validateBitcoinRegtestAddress,
|
|
164
|
-
Ethereum: validateEvmAddress,
|
|
165
|
-
Arbitrum: validateEvmAddress,
|
|
166
|
-
Solana: validateSolanaAddress,
|
|
167
|
-
Assethub: validatePolkadotAddress,
|
|
168
|
-
Tron: validateTronAddress,
|
|
169
|
-
Bsc: validateEvmAddress
|
|
170
|
-
}
|
|
171
|
-
};
|
|
172
|
-
var validateAddress = (chain2, address, network) => validators[network][chain2](address);
|
|
173
|
-
|
|
174
|
-
// ../shared/src/api/openAccountCreationDepositChannel.ts
|
|
175
|
-
var getAccountCreationDepositChannelSchema = (network) => z.object({
|
|
176
|
-
signatureData: z.object({
|
|
177
|
-
Ethereum: z.object({
|
|
178
|
-
signature: hexString,
|
|
179
|
-
signer: hexString,
|
|
180
|
-
sigType: z.literal("Eip712")
|
|
181
|
-
}).transform(({ sigType, ...rest }) => ({
|
|
182
|
-
sig_type: sigType,
|
|
183
|
-
...rest
|
|
184
|
-
}))
|
|
185
|
-
}),
|
|
186
|
-
transactionMetadata: z.object({
|
|
187
|
-
nonce: z.number().gte(0),
|
|
188
|
-
expiryBlock: z.number().positive()
|
|
189
|
-
}).transform(({ nonce, expiryBlock }) => ({
|
|
190
|
-
nonce,
|
|
191
|
-
expiry_block: expiryBlock
|
|
192
|
-
})),
|
|
193
|
-
asset: assetAndChain,
|
|
194
|
-
refundAddress: z.string(),
|
|
195
|
-
boostFeeBps: z.number().optional().default(0)
|
|
196
|
-
}).superRefine(({ asset: asset2, refundAddress }, ctx) => {
|
|
197
|
-
if (!validateAddress(asset2.chain, refundAddress, network)) {
|
|
198
|
-
ctx.addIssue({
|
|
199
|
-
message: `Address "${refundAddress}" is not a valid "${asset2.chain}" address for "${network}"`,
|
|
200
|
-
code: z.ZodIssueCode.custom
|
|
201
|
-
});
|
|
202
|
-
}
|
|
203
|
-
});
|
|
204
83
|
z.object({
|
|
205
84
|
srcChain: chain,
|
|
206
85
|
srcAsset: asset,
|
|
207
86
|
destChain: chain,
|
|
208
87
|
destAsset: asset,
|
|
209
88
|
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" }),
|
|
210
|
-
brokerCommissionBps: numericOrEmptyString.transform((v) => Number(v)).optional(),
|
|
89
|
+
brokerCommissionBps: numericOrEmptyString.transform((v) => Number(v)).pipe(u16).optional(),
|
|
211
90
|
ccmGasBudget: z.union([
|
|
212
91
|
numericString.transform((v) => BigInt(v)).refine((v) => v < 2n ** 128n, { message: "ccm gas budget must be less than 2^128" }),
|
|
213
92
|
z.literal("undefined").transform(() => void 0)
|
|
214
93
|
// sdk version 1.8.2 sends undefined string if not set
|
|
215
94
|
]).optional(),
|
|
216
95
|
ccmMessageLengthBytes: z.union([
|
|
217
|
-
numericString.transform((v) => Number(v)),
|
|
96
|
+
numericString.transform((v) => Number(v)).pipe(u32),
|
|
218
97
|
z.literal("undefined").transform(() => void 0)
|
|
219
98
|
// sdk version 1.8.2 sends undefined string if not set
|
|
220
99
|
]).optional(),
|
|
221
|
-
dcaV2Enabled: booleanString.
|
|
100
|
+
dcaV2Enabled: booleanString.prefault("false"),
|
|
222
101
|
isVaultSwap: booleanString.optional(),
|
|
223
102
|
isOnChain: booleanString.optional(),
|
|
224
103
|
brokerAccount: chainflipAddress.optional(),
|
|
225
104
|
brokerIdSs58: chainflipAddress.optional(),
|
|
226
|
-
expectedResponseTimeMs: numericString.transform((v) => Number(v)).optional()
|
|
105
|
+
expectedResponseTimeMs: numericString.transform((v) => Number(v)).pipe(u32).optional()
|
|
227
106
|
}).transform((args, ctx) => {
|
|
228
107
|
const { srcAsset, destAsset } = getInternalAssets(args, false);
|
|
229
108
|
let hadError = false;
|
|
@@ -304,91 +183,82 @@ var ccmParamsSchema = z.object({
|
|
|
304
183
|
}));
|
|
305
184
|
var affiliateBroker = z.object({
|
|
306
185
|
account: chainflipAddress,
|
|
307
|
-
commissionBps:
|
|
186
|
+
commissionBps: u16
|
|
308
187
|
}).transform(({ account, commissionBps: bps }) => ({ account, bps }));
|
|
309
188
|
var dcaParams = z.object({
|
|
310
|
-
numberOfChunks:
|
|
311
|
-
chunkIntervalBlocks:
|
|
189
|
+
numberOfChunks: u32.min(1, { message: "number of chunks must be greater than 0" }),
|
|
190
|
+
chunkIntervalBlocks: u32
|
|
312
191
|
});
|
|
313
|
-
|
|
314
|
-
retryDurationBlocks:
|
|
192
|
+
z.object({
|
|
193
|
+
retryDurationBlocks: u32,
|
|
315
194
|
refundAddress: z.string(),
|
|
316
195
|
minPriceX128: numericString,
|
|
317
196
|
maxOraclePriceSlippage: basisPoints.nullish().transform((v) => v ?? null),
|
|
318
197
|
refundCcmMetadata: ccmParamsSchema.nullish().optional().default(null)
|
|
319
198
|
});
|
|
320
|
-
|
|
321
|
-
|
|
322
|
-
|
|
323
|
-
|
|
324
|
-
|
|
325
|
-
}
|
|
326
|
-
|
|
327
|
-
var getOpenSwapDepositChannelSchema = (network) => z.intersection(
|
|
328
|
-
assets,
|
|
329
|
-
z.object({
|
|
330
|
-
destAddress: z.string(),
|
|
331
|
-
amount: amountString,
|
|
332
|
-
ccmParams: ccmParamsSchema.optional(),
|
|
333
|
-
maxBoostFeeBps: z.number().optional(),
|
|
334
|
-
srcAddress: z.string().optional(),
|
|
335
|
-
fillOrKillParams,
|
|
336
|
-
dcaParams: dcaParams.optional(),
|
|
337
|
-
quote: z.object({
|
|
338
|
-
intermediateAmount: amountString.optional(),
|
|
339
|
-
egressAmount: amountString,
|
|
340
|
-
estimatedPrice: z.string().regex(/^[0-9]+(\.[0-9]+)?(e[+-]?[0-9]+)?$/i, { message: "must be a decimal number" }).refine((v) => Number(v) < 1e35, { message: "must be less than 10^35" }),
|
|
341
|
-
recommendedSlippageTolerancePercent: z.number().optional(),
|
|
342
|
-
recommendedLivePriceSlippageTolerancePercent: z.number().optional()
|
|
343
|
-
}).optional(),
|
|
344
|
-
takeCommission: z.boolean().optional()
|
|
345
|
-
})
|
|
346
|
-
).superRefine(({ ...val }, ctx) => {
|
|
347
|
-
if (!validateAddress(val.destAsset.chain, val.destAddress, network)) {
|
|
348
|
-
ctx.addIssue({
|
|
349
|
-
message: `Address "${val.destAddress}" is not a valid "${val.destAsset.chain}" address for "${network}"`,
|
|
350
|
-
code: z.ZodIssueCode.custom
|
|
351
|
-
});
|
|
352
|
-
}
|
|
353
|
-
if (!validateAddress(val.srcAsset.chain, val.fillOrKillParams.refundAddress, network)) {
|
|
354
|
-
ctx.addIssue({
|
|
355
|
-
message: `Address "${val.fillOrKillParams.refundAddress}" is not a valid "${val.srcAsset.chain}" address for "${network}"`,
|
|
356
|
-
code: z.ZodIssueCode.custom
|
|
357
|
-
});
|
|
358
|
-
}
|
|
359
|
-
}).transform(({ amount, ...rest }) => ({
|
|
360
|
-
...rest,
|
|
361
|
-
expectedDepositAmount: amount
|
|
362
|
-
}));
|
|
363
|
-
var DepositChannelInfo = z.object({
|
|
364
|
-
id: z.string(),
|
|
365
|
-
depositAddress: z.string(),
|
|
366
|
-
brokerCommissionBps: z.number(),
|
|
367
|
-
maxBoostFeeBps: z.number(),
|
|
368
|
-
issuedBlock: z.number(),
|
|
369
|
-
srcChainExpiryBlock: z.string(),
|
|
370
|
-
estimatedExpiryTime: z.number().optional(),
|
|
371
|
-
channelOpeningFee: z.string()
|
|
372
|
-
});
|
|
373
|
-
|
|
374
|
-
// ../shared/src/strings.ts
|
|
375
|
-
var toCamelCase = (str) => str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
|
|
376
|
-
|
|
377
|
-
// ../shared/src/objects.ts
|
|
378
|
-
var transformKeysToCamelCase = (obj) => {
|
|
379
|
-
if (Array.isArray(obj)) {
|
|
380
|
-
return obj.map(transformKeysToCamelCase);
|
|
199
|
+
var validatePolkadotAddress = (address) => {
|
|
200
|
+
if (isHex(address)) return address.length === 66;
|
|
201
|
+
try {
|
|
202
|
+
ss58.decode(address);
|
|
203
|
+
return true;
|
|
204
|
+
} catch {
|
|
205
|
+
return false;
|
|
381
206
|
}
|
|
382
|
-
|
|
383
|
-
|
|
384
|
-
|
|
385
|
-
|
|
386
|
-
|
|
387
|
-
|
|
388
|
-
|
|
207
|
+
};
|
|
208
|
+
var validateEvmAddress = (address) => ethers.isAddress(address);
|
|
209
|
+
var validateBitcoinMainnetAddress = (address) => bitcoin.isValidAddressForNetwork(address, "mainnet");
|
|
210
|
+
var validateBitcoinTestnetAddress = (address) => bitcoin.isValidAddressForNetwork(address, "testnet");
|
|
211
|
+
var validateBitcoinRegtestAddress = (address) => bitcoin.isValidAddressForNetwork(address, "regtest");
|
|
212
|
+
var validateSolanaAddress = isValidSolanaAddress;
|
|
213
|
+
var validateTronAddress = isValidTronAddress;
|
|
214
|
+
var validators = {
|
|
215
|
+
mainnet: {
|
|
216
|
+
Bitcoin: validateBitcoinMainnetAddress,
|
|
217
|
+
Ethereum: validateEvmAddress,
|
|
218
|
+
Arbitrum: validateEvmAddress,
|
|
219
|
+
Solana: validateSolanaAddress,
|
|
220
|
+
Assethub: validatePolkadotAddress,
|
|
221
|
+
Tron: validateTronAddress,
|
|
222
|
+
Bsc: validateEvmAddress
|
|
223
|
+
},
|
|
224
|
+
perseverance: {
|
|
225
|
+
Bitcoin: validateBitcoinTestnetAddress,
|
|
226
|
+
Ethereum: validateEvmAddress,
|
|
227
|
+
Arbitrum: validateEvmAddress,
|
|
228
|
+
Solana: validateSolanaAddress,
|
|
229
|
+
Assethub: validatePolkadotAddress,
|
|
230
|
+
Tron: validateTronAddress,
|
|
231
|
+
Bsc: validateEvmAddress
|
|
232
|
+
},
|
|
233
|
+
sisyphos: {
|
|
234
|
+
Bitcoin: validateBitcoinTestnetAddress,
|
|
235
|
+
Ethereum: validateEvmAddress,
|
|
236
|
+
Arbitrum: validateEvmAddress,
|
|
237
|
+
Solana: validateSolanaAddress,
|
|
238
|
+
Assethub: validatePolkadotAddress,
|
|
239
|
+
Tron: validateTronAddress,
|
|
240
|
+
Bsc: validateEvmAddress
|
|
241
|
+
},
|
|
242
|
+
backspin: {
|
|
243
|
+
Bitcoin: validateBitcoinRegtestAddress,
|
|
244
|
+
Ethereum: validateEvmAddress,
|
|
245
|
+
Arbitrum: validateEvmAddress,
|
|
246
|
+
Solana: validateSolanaAddress,
|
|
247
|
+
Assethub: validatePolkadotAddress,
|
|
248
|
+
Tron: validateTronAddress,
|
|
249
|
+
Bsc: validateEvmAddress
|
|
250
|
+
},
|
|
251
|
+
localnet: {
|
|
252
|
+
Bitcoin: validateBitcoinRegtestAddress,
|
|
253
|
+
Ethereum: validateEvmAddress,
|
|
254
|
+
Arbitrum: validateEvmAddress,
|
|
255
|
+
Solana: validateSolanaAddress,
|
|
256
|
+
Assethub: validatePolkadotAddress,
|
|
257
|
+
Tron: validateTronAddress,
|
|
258
|
+
Bsc: validateEvmAddress
|
|
389
259
|
}
|
|
390
|
-
return obj;
|
|
391
260
|
};
|
|
261
|
+
var validateAddress = (chain2, address, network) => Object.hasOwn(validators, network) && Object.hasOwn(validators[network], chain2) && validators[network][chain2](address);
|
|
392
262
|
|
|
393
263
|
// ../shared/src/broker.ts
|
|
394
264
|
var transformedDcaParamsSchema = dcaParams.transform(
|
|
@@ -405,7 +275,7 @@ var transformedCcmParamsSchema = ccmParamsSchema.transform(
|
|
|
405
275
|
})
|
|
406
276
|
);
|
|
407
277
|
var transformedFokSchema = z.object({
|
|
408
|
-
retryDurationBlocks:
|
|
278
|
+
retryDurationBlocks: u32,
|
|
409
279
|
refundAddress: z.string(),
|
|
410
280
|
minPriceX128: numericString,
|
|
411
281
|
maxOraclePriceSlippage: basisPoints.nullish().transform((v) => v ?? null),
|
|
@@ -429,9 +299,9 @@ var getDepositAddressRequestSchema = (network) => z.object({
|
|
|
429
299
|
srcAsset: assetAndChain,
|
|
430
300
|
destAsset: assetAndChain,
|
|
431
301
|
destAddress: z.string(),
|
|
432
|
-
commissionBps:
|
|
302
|
+
commissionBps: u16.optional().default(0),
|
|
433
303
|
ccmParams: transformedCcmParamsSchema.optional(),
|
|
434
|
-
maxBoostFeeBps:
|
|
304
|
+
maxBoostFeeBps: u16.optional(),
|
|
435
305
|
affiliates: z.array(affiliateBroker).optional(),
|
|
436
306
|
fillOrKillParams: transformedFokSchema,
|
|
437
307
|
dcaParams: transformedDcaParamsSchema.optional()
|
|
@@ -455,9 +325,9 @@ var getVaultSwapParameterEncodingRequestSchema = (network) => z.object({
|
|
|
455
325
|
destAsset: assetAndChain,
|
|
456
326
|
destAddress: z.string(),
|
|
457
327
|
amount: unsignedInteger,
|
|
458
|
-
commissionBps:
|
|
328
|
+
commissionBps: u16.optional().default(0),
|
|
459
329
|
ccmParams: transformedCcmParamsSchema.optional(),
|
|
460
|
-
maxBoostFeeBps:
|
|
330
|
+
maxBoostFeeBps: u16.optional(),
|
|
461
331
|
affiliates: z.array(affiliateBroker).optional(),
|
|
462
332
|
fillOrKillParams: transformedFokSchema,
|
|
463
333
|
dcaParams: transformedDcaParamsSchema.optional(),
|
|
@@ -485,7 +355,7 @@ var getVaultSwapParameterEncodingRequestSchema = (network) => z.object({
|
|
|
485
355
|
if (val.extraParams?.seed && val.extraParams.seed.length !== 66) {
|
|
486
356
|
ctx.addIssue({ message: "Seed must be 32 bytes", code: z.ZodIssueCode.custom });
|
|
487
357
|
}
|
|
488
|
-
}).transform((data) => {
|
|
358
|
+
}).transform((data, ctx) => {
|
|
489
359
|
let extraParams;
|
|
490
360
|
if (data.srcAsset.chain === "Bitcoin") {
|
|
491
361
|
const minOutputAmount = BigNumber2(data.amount.toString()).multipliedBy(priceX128ToPrice(data.fillOrKillParams.min_price)).toFixed(0);
|
|
@@ -502,7 +372,13 @@ var getVaultSwapParameterEncodingRequestSchema = (network) => z.object({
|
|
|
502
372
|
refund_parameters: data.fillOrKillParams
|
|
503
373
|
};
|
|
504
374
|
} else if (data.srcAsset.chain === "Solana") {
|
|
505
|
-
|
|
375
|
+
if (!data.srcAddress) {
|
|
376
|
+
ctx.addIssue({
|
|
377
|
+
message: "srcAddress is required for Solana",
|
|
378
|
+
code: z.ZodIssueCode.custom
|
|
379
|
+
});
|
|
380
|
+
return z.NEVER;
|
|
381
|
+
}
|
|
506
382
|
extraParams = {
|
|
507
383
|
chain: "Solana",
|
|
508
384
|
from: data.srcAddress,
|
|
@@ -511,7 +387,11 @@ var getVaultSwapParameterEncodingRequestSchema = (network) => z.object({
|
|
|
511
387
|
refund_parameters: data.fillOrKillParams
|
|
512
388
|
};
|
|
513
389
|
} else {
|
|
514
|
-
|
|
390
|
+
ctx.addIssue({
|
|
391
|
+
message: `parameter encoding is not supported for ${data.srcAsset.chain}`,
|
|
392
|
+
code: z.ZodIssueCode.custom
|
|
393
|
+
});
|
|
394
|
+
return z.NEVER;
|
|
515
395
|
}
|
|
516
396
|
return { ...data, extraParams };
|
|
517
397
|
});
|
|
@@ -571,9 +451,9 @@ var getParameterEncodingRequestSchema = (network) => z.object({
|
|
|
571
451
|
destAsset: assetAndChain,
|
|
572
452
|
destAddress: z.string(),
|
|
573
453
|
amount: unsignedInteger,
|
|
574
|
-
commissionBps:
|
|
454
|
+
commissionBps: u16.optional().default(0),
|
|
575
455
|
ccmParams: transformedCcmParamsSchema.optional(),
|
|
576
|
-
maxBoostFeeBps:
|
|
456
|
+
maxBoostFeeBps: u16.optional(),
|
|
577
457
|
affiliates: z.array(affiliateBroker).optional(),
|
|
578
458
|
fillOrKillParams: transformedFokSchema,
|
|
579
459
|
dcaParams: transformedDcaParamsSchema.optional(),
|
|
@@ -615,68 +495,18 @@ async function requestCfParametersEncoding(request, opts, network) {
|
|
|
615
495
|
);
|
|
616
496
|
return response;
|
|
617
497
|
}
|
|
618
|
-
|
|
619
|
-
// ../shared/src/api/contract.ts
|
|
620
|
-
var c = initContract();
|
|
621
|
-
var createApiContract = (network) => c.router(
|
|
622
|
-
{
|
|
623
|
-
networkInfo: {
|
|
624
|
-
method: "GET",
|
|
625
|
-
path: "/networkInfo",
|
|
626
|
-
responses: {
|
|
627
|
-
200: NetworkInfo
|
|
628
|
-
},
|
|
629
|
-
summary: "Get information about the Chainflip network"
|
|
630
|
-
},
|
|
631
|
-
encodeCfParameters: {
|
|
632
|
-
method: "POST",
|
|
633
|
-
path: "/encodeCfParameters",
|
|
634
|
-
body: getParameterEncodingRequestSchema(network),
|
|
635
|
-
responses: {
|
|
636
|
-
200: hexString
|
|
637
|
-
}
|
|
638
|
-
},
|
|
639
|
-
encodeVaultSwapData: {
|
|
640
|
-
method: "POST",
|
|
641
|
-
path: "/encodeVaultSwapData",
|
|
642
|
-
body: getVaultSwapParameterEncodingRequestSchema(network),
|
|
643
|
-
responses: {
|
|
644
|
-
200: EncodedVaultSwapData
|
|
645
|
-
}
|
|
646
|
-
},
|
|
647
|
-
openSwapDepositChannel: {
|
|
648
|
-
method: "POST",
|
|
649
|
-
path: "/openSwapDepositChannel",
|
|
650
|
-
body: getOpenSwapDepositChannelSchema(network),
|
|
651
|
-
responses: {
|
|
652
|
-
201: DepositChannelInfo
|
|
653
|
-
}
|
|
654
|
-
},
|
|
655
|
-
openAccountCreationDepositChannel: {
|
|
656
|
-
method: "POST",
|
|
657
|
-
path: "/openAccountCreationDepositChannel",
|
|
658
|
-
body: getAccountCreationDepositChannelSchema(network),
|
|
659
|
-
responses: {
|
|
660
|
-
201: DepositChannelInfo
|
|
661
|
-
}
|
|
662
|
-
}
|
|
663
|
-
},
|
|
664
|
-
{
|
|
665
|
-
pathPrefix: "/api"
|
|
666
|
-
}
|
|
667
|
-
);
|
|
668
498
|
var MultiCache = class {
|
|
669
499
|
constructor(fetchers) {
|
|
670
500
|
this.fetchers = fetchers;
|
|
671
501
|
}
|
|
672
502
|
values = {};
|
|
673
503
|
read(type) {
|
|
674
|
-
const { fetch, ttl } = this.fetchers[type];
|
|
504
|
+
const { fetch: fetch2, ttl } = this.fetchers[type];
|
|
675
505
|
let cached = this.values[type];
|
|
676
506
|
if (!cached || cached.timestamp + ttl < Date.now()) {
|
|
677
507
|
cached = {
|
|
678
508
|
timestamp: Date.now(),
|
|
679
|
-
value:
|
|
509
|
+
value: fetch2().catch((err) => {
|
|
680
510
|
this.values[type] = void 0;
|
|
681
511
|
throw err;
|
|
682
512
|
})
|
|
@@ -824,7 +654,7 @@ var getChainData = (chain2, network, env) => ({
|
|
|
824
654
|
|
|
825
655
|
// package.json
|
|
826
656
|
var package_default = {
|
|
827
|
-
version: "2.3.
|
|
657
|
+
version: "2.3.3"};
|
|
828
658
|
|
|
829
659
|
// src/swap/consts.ts
|
|
830
660
|
var CF_SDK_VERSION_HEADERS = { "X-Chainflip-Sdk-Version": package_default.version };
|
|
@@ -872,6 +702,59 @@ var getStatusV2 = async (baseUrl, { id }, { signal }) => {
|
|
|
872
702
|
});
|
|
873
703
|
return data;
|
|
874
704
|
};
|
|
705
|
+
var lowercaseKeys = (headers) => Object.fromEntries(Object.entries(headers).map(([key, value]) => [key.toLowerCase(), value]));
|
|
706
|
+
var backendRequest = async (baseUrl, method, path, body) => {
|
|
707
|
+
const headers = lowercaseKeys(CF_SDK_VERSION_HEADERS);
|
|
708
|
+
let serializedBody;
|
|
709
|
+
if (method !== "GET" && body != null) {
|
|
710
|
+
headers["content-type"] = "application/json";
|
|
711
|
+
serializedBody = JSON.stringify(body);
|
|
712
|
+
}
|
|
713
|
+
const res = await fetch(`${baseUrl.replace(/\/+$/, "")}${path}`, {
|
|
714
|
+
method,
|
|
715
|
+
headers,
|
|
716
|
+
body: serializedBody
|
|
717
|
+
});
|
|
718
|
+
const contentType = res.headers.get("content-type") ?? "";
|
|
719
|
+
if (contentType.includes("application/") && contentType.includes("json")) {
|
|
720
|
+
return { status: res.status, body: await res.json(), headers: res.headers };
|
|
721
|
+
}
|
|
722
|
+
if (contentType.includes("text/")) {
|
|
723
|
+
return { status: res.status, body: await res.text(), headers: res.headers };
|
|
724
|
+
}
|
|
725
|
+
return { status: res.status, body: await res.blob(), headers: res.headers };
|
|
726
|
+
};
|
|
727
|
+
var getNetworkInfo = async (baseUrl) => {
|
|
728
|
+
const res = await backendRequest(baseUrl, "GET", "/api/networkInfo");
|
|
729
|
+
assert(res.status === 200, "Failed to fetch network info");
|
|
730
|
+
return res.body;
|
|
731
|
+
};
|
|
732
|
+
var openSwapDepositChannel = async (baseUrl, body) => {
|
|
733
|
+
const res = await backendRequest(baseUrl, "POST", "/api/openSwapDepositChannel", body);
|
|
734
|
+
assert(res.status === 201, "Failed to open swap deposit channel");
|
|
735
|
+
return res.body;
|
|
736
|
+
};
|
|
737
|
+
var encodeVaultSwapData = async (baseUrl, body) => {
|
|
738
|
+
const res = await backendRequest(baseUrl, "POST", "/api/encodeVaultSwapData", body);
|
|
739
|
+
if (res.status !== 200) {
|
|
740
|
+
throw new Error("Failed to encode vault swap data", { cause: res });
|
|
741
|
+
}
|
|
742
|
+
return res.body;
|
|
743
|
+
};
|
|
744
|
+
var encodeCfParameters = async (baseUrl, body) => {
|
|
745
|
+
const res = await backendRequest(baseUrl, "POST", "/api/encodeCfParameters", body);
|
|
746
|
+
if (res.status !== 200) {
|
|
747
|
+
throw new Error("Failed to encode cf parameters", { cause: res });
|
|
748
|
+
}
|
|
749
|
+
return res.body;
|
|
750
|
+
};
|
|
751
|
+
var openAccountCreationDepositChannel = async (baseUrl, body) => {
|
|
752
|
+
const res = await backendRequest(baseUrl, "POST", "/api/openAccountCreationDepositChannel", body);
|
|
753
|
+
if (res.status !== 201) {
|
|
754
|
+
throw new Error("Failed to request account creation deposit channel", { cause: res });
|
|
755
|
+
}
|
|
756
|
+
return res.body;
|
|
757
|
+
};
|
|
875
758
|
|
|
876
759
|
// src/swap/sdk.ts
|
|
877
760
|
var assertQuoteValid = (quote) => {
|
|
@@ -888,7 +771,6 @@ var assertQuoteValid = (quote) => {
|
|
|
888
771
|
var SwapSDK = class {
|
|
889
772
|
options;
|
|
890
773
|
rpcConfig;
|
|
891
|
-
apiClient;
|
|
892
774
|
cache;
|
|
893
775
|
dcaV2Enabled = false;
|
|
894
776
|
constructor(options = {}) {
|
|
@@ -899,12 +781,6 @@ var SwapSDK = class {
|
|
|
899
781
|
backendUrl: options.backendUrl ?? BACKEND_SERVICE_URLS[network]
|
|
900
782
|
};
|
|
901
783
|
this.rpcConfig = options.rpcUrl ? { rpcUrl: options.rpcUrl } : { network };
|
|
902
|
-
this.apiClient = initClient(createApiContract(this.options.network), {
|
|
903
|
-
// remove trailing slashes. this bug has been fixed in `@ts-rest/core`
|
|
904
|
-
// but it hasn't been released yet
|
|
905
|
-
baseUrl: this.options.backendUrl.replace(/\/+$/, ""),
|
|
906
|
-
baseHeaders: CF_SDK_VERSION_HEADERS
|
|
907
|
-
});
|
|
908
784
|
this.dcaV2Enabled = options.enabledFeatures?.dcaV2 ?? false;
|
|
909
785
|
this.cache = new MultiCache({
|
|
910
786
|
environment: {
|
|
@@ -912,11 +788,7 @@ var SwapSDK = class {
|
|
|
912
788
|
ttl: 6e4
|
|
913
789
|
},
|
|
914
790
|
networkInfo: {
|
|
915
|
-
fetch:
|
|
916
|
-
const res = await this.apiClient.networkInfo();
|
|
917
|
-
assert(res.status === 200, "Failed to fetch network info");
|
|
918
|
-
return res.body;
|
|
919
|
-
},
|
|
791
|
+
fetch: () => getNetworkInfo(this.options.backendUrl),
|
|
920
792
|
ttl: 6e4
|
|
921
793
|
}
|
|
922
794
|
});
|
|
@@ -937,8 +809,8 @@ var SwapSDK = class {
|
|
|
937
809
|
return this.cache.read("environment");
|
|
938
810
|
}
|
|
939
811
|
async getSupportedAssets(type) {
|
|
940
|
-
const
|
|
941
|
-
return
|
|
812
|
+
const assets = await this.cache.read("networkInfo");
|
|
813
|
+
return assets.assets.filter((a) => isChainflipAsset(a.asset)).filter((a) => {
|
|
942
814
|
switch (type) {
|
|
943
815
|
case "all":
|
|
944
816
|
return true;
|
|
@@ -1120,15 +992,11 @@ var SwapSDK = class {
|
|
|
1120
992
|
!affiliates?.length,
|
|
1121
993
|
"Affiliate brokers are supported only when initializing the SDK with a brokerUrl"
|
|
1122
994
|
);
|
|
1123
|
-
|
|
1124
|
-
|
|
1125
|
-
|
|
1126
|
-
|
|
1127
|
-
takeCommission: this.shouldTakeCommission()
|
|
1128
|
-
}
|
|
995
|
+
response = await openSwapDepositChannel(this.options.backendUrl, {
|
|
996
|
+
...depositAddressRequest,
|
|
997
|
+
quote,
|
|
998
|
+
takeCommission: this.shouldTakeCommission()
|
|
1129
999
|
});
|
|
1130
|
-
assert(res.status === 201, "Failed to open swap deposit channel");
|
|
1131
|
-
response = res.body;
|
|
1132
1000
|
}
|
|
1133
1001
|
return {
|
|
1134
1002
|
...depositAddressRequest,
|
|
@@ -1201,18 +1069,15 @@ var SwapSDK = class {
|
|
|
1201
1069
|
!vaultSwapRequest.affiliates?.length || vaultSwapRequest.brokerAccount,
|
|
1202
1070
|
"Affiliate brokers are supported only when setting a broker account"
|
|
1203
1071
|
);
|
|
1204
|
-
const
|
|
1205
|
-
|
|
1206
|
-
throw new Error("Failed to encode vault swap data", { cause: res });
|
|
1207
|
-
}
|
|
1208
|
-
switch (res.body.chain) {
|
|
1072
|
+
const body = await encodeVaultSwapData(this.options.backendUrl, vaultSwapRequest);
|
|
1073
|
+
switch (body.chain) {
|
|
1209
1074
|
case "Arbitrum":
|
|
1210
1075
|
case "Ethereum":
|
|
1211
1076
|
case "Tron":
|
|
1212
1077
|
case "Bsc":
|
|
1213
|
-
return { ...
|
|
1078
|
+
return { ...body, value: BigInt(body.value) };
|
|
1214
1079
|
default:
|
|
1215
|
-
return
|
|
1080
|
+
return body;
|
|
1216
1081
|
}
|
|
1217
1082
|
}
|
|
1218
1083
|
async encodeCfParameters({
|
|
@@ -1264,32 +1129,23 @@ var SwapSDK = class {
|
|
|
1264
1129
|
!requestParams.affiliates?.length || brokerAccount,
|
|
1265
1130
|
"Affiliate brokers are supported only when setting a broker account"
|
|
1266
1131
|
);
|
|
1267
|
-
|
|
1268
|
-
|
|
1132
|
+
return encodeCfParameters(this.options.backendUrl, {
|
|
1133
|
+
...requestParams,
|
|
1134
|
+
brokerAccount
|
|
1269
1135
|
});
|
|
1270
|
-
if (res.status !== 200) {
|
|
1271
|
-
throw new Error("Failed to encode cf parameters", { cause: res });
|
|
1272
|
-
}
|
|
1273
|
-
return res.body;
|
|
1274
1136
|
}
|
|
1275
1137
|
async checkBoostEnabled() {
|
|
1276
|
-
const { assets
|
|
1277
|
-
return
|
|
1138
|
+
const { assets } = await this.cache.read("networkInfo");
|
|
1139
|
+
return assets.find((a) => a.asset === "Btc")?.boostDepositsEnabled ?? true;
|
|
1278
1140
|
}
|
|
1279
1141
|
async requestAccountCreationDepositAddress(asset2, refundAddress, signatureData, transactionMetadata, boostFeeBps = 0) {
|
|
1280
|
-
|
|
1281
|
-
|
|
1282
|
-
|
|
1283
|
-
|
|
1284
|
-
|
|
1285
|
-
|
|
1286
|
-
boostFeeBps
|
|
1287
|
-
}
|
|
1142
|
+
return openAccountCreationDepositChannel(this.options.backendUrl, {
|
|
1143
|
+
asset: internalAssetToRpcAsset[asset2],
|
|
1144
|
+
refundAddress,
|
|
1145
|
+
signatureData,
|
|
1146
|
+
transactionMetadata,
|
|
1147
|
+
boostFeeBps
|
|
1288
1148
|
});
|
|
1289
|
-
if (res.status !== 201) {
|
|
1290
|
-
throw new Error("Failed to request account creation deposit channel", { cause: res });
|
|
1291
|
-
}
|
|
1292
|
-
return res.body;
|
|
1293
1149
|
}
|
|
1294
1150
|
};
|
|
1295
1151
|
var arrayToMap = (array) => Object.fromEntries(array.map((item) => [item, item]));
|