@chainflip/sdk 2.3.1 → 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 +283 -418
- package/dist/swap.d.cts +39 -183
- package/dist/swap.d.ts +39 -183
- package/dist/swap.js +222 -357
- package/package.json +7 -8
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]*$/);
|
|
@@ -29,17 +46,31 @@ var hexStringWithMaxByteSize = (maxByteSize) => hexString.refine((val) => val.le
|
|
|
29
46
|
var basisPoints = z.number().int({ message: "must be in basis points" });
|
|
30
47
|
var DOT_PREFIX = 0;
|
|
31
48
|
var chainflipAddress = z.string().refine(
|
|
32
|
-
(address) =>
|
|
33
|
-
|
|
49
|
+
(address) => {
|
|
50
|
+
if (!address.startsWith("cF")) return false;
|
|
51
|
+
try {
|
|
52
|
+
ss58.decode(address);
|
|
53
|
+
return true;
|
|
54
|
+
} catch {
|
|
55
|
+
return false;
|
|
56
|
+
}
|
|
57
|
+
},
|
|
58
|
+
{ error: (issue) => `${issue.input} is not a valid Chainflip address` }
|
|
34
59
|
);
|
|
35
|
-
z.string().refine(isValidSolanaAddress,
|
|
36
|
-
|
|
37
|
-
})
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
})
|
|
41
|
-
var
|
|
42
|
-
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;
|
|
43
74
|
var chain = z.enum(chainflipChains);
|
|
44
75
|
var asset = z.enum(assetSymbols);
|
|
45
76
|
var uncheckedAssetAndChain = z.object({
|
|
@@ -47,175 +78,31 @@ var uncheckedAssetAndChain = z.object({
|
|
|
47
78
|
chain: z.string()
|
|
48
79
|
});
|
|
49
80
|
var assetAndChain = uncheckedAssetAndChain.refine(
|
|
50
|
-
(value) => isValidAssetAndChain(value)
|
|
81
|
+
(value) => chain.safeParse(value.chain).success && asset.safeParse(value.asset).success && isValidAssetAndChain(value)
|
|
51
82
|
);
|
|
52
|
-
|
|
53
|
-
// ../shared/src/api/encodeVaultSwapData.ts
|
|
54
|
-
var EncodedVaultSwapData = z.discriminatedUnion("chain", [
|
|
55
|
-
z.object({
|
|
56
|
-
chain: z.literal("Bitcoin"),
|
|
57
|
-
nulldataPayload: hexString,
|
|
58
|
-
depositAddress: z.string()
|
|
59
|
-
}),
|
|
60
|
-
z.object({
|
|
61
|
-
chain: z.enum(["Ethereum", "Arbitrum", "Bsc"]),
|
|
62
|
-
value: z.string(),
|
|
63
|
-
to: hexString,
|
|
64
|
-
calldata: hexString,
|
|
65
|
-
sourceTokenAddress: hexString.optional()
|
|
66
|
-
}),
|
|
67
|
-
z.object({
|
|
68
|
-
chain: z.literal("Tron"),
|
|
69
|
-
calldata: hexString,
|
|
70
|
-
value: z.string(),
|
|
71
|
-
to: tronAddress,
|
|
72
|
-
note: hexString,
|
|
73
|
-
sourceTokenAddress: tronAddress.optional()
|
|
74
|
-
}),
|
|
75
|
-
z.object({
|
|
76
|
-
chain: z.literal("Solana"),
|
|
77
|
-
programId: z.string(),
|
|
78
|
-
data: hexString,
|
|
79
|
-
accounts: z.array(
|
|
80
|
-
z.object({
|
|
81
|
-
pubkey: z.string(),
|
|
82
|
-
isSigner: z.boolean(),
|
|
83
|
-
isWritable: z.boolean()
|
|
84
|
-
})
|
|
85
|
-
)
|
|
86
|
-
})
|
|
87
|
-
]);
|
|
88
|
-
var NetworkInfo = z3.object({
|
|
89
|
-
assets: z3.array(
|
|
90
|
-
z3.object({
|
|
91
|
-
asset: z3.enum(chainflipAssets),
|
|
92
|
-
vaultSwapDepositsEnabled: z3.boolean(),
|
|
93
|
-
depositChannelDepositsEnabled: z3.boolean(),
|
|
94
|
-
depositChannelCreationEnabled: z3.boolean(),
|
|
95
|
-
egressEnabled: z3.boolean(),
|
|
96
|
-
boostDepositsEnabled: z3.boolean(),
|
|
97
|
-
livePriceProtectionEnabled: z3.boolean()
|
|
98
|
-
})
|
|
99
|
-
),
|
|
100
|
-
cfBrokerCommissionBps: z3.number()
|
|
101
|
-
});
|
|
102
|
-
var validatePolkadotAddress = (address) => {
|
|
103
|
-
if (isHex(address)) return address.length === 66;
|
|
104
|
-
try {
|
|
105
|
-
ss58.decode(address);
|
|
106
|
-
return true;
|
|
107
|
-
} catch {
|
|
108
|
-
return false;
|
|
109
|
-
}
|
|
110
|
-
};
|
|
111
|
-
var validateEvmAddress = (address) => ethers.isAddress(address);
|
|
112
|
-
var validateBitcoinMainnetAddress = (address) => bitcoin.isValidAddressForNetwork(address, "mainnet");
|
|
113
|
-
var validateBitcoinTestnetAddress = (address) => bitcoin.isValidAddressForNetwork(address, "testnet");
|
|
114
|
-
var validateBitcoinRegtestAddress = (address) => bitcoin.isValidAddressForNetwork(address, "regtest");
|
|
115
|
-
var validateSolanaAddress = isValidSolanaAddress;
|
|
116
|
-
var validateTronAddress = isValidTronAddress;
|
|
117
|
-
var validators = {
|
|
118
|
-
mainnet: {
|
|
119
|
-
Bitcoin: validateBitcoinMainnetAddress,
|
|
120
|
-
Ethereum: validateEvmAddress,
|
|
121
|
-
Arbitrum: validateEvmAddress,
|
|
122
|
-
Solana: validateSolanaAddress,
|
|
123
|
-
Assethub: validatePolkadotAddress,
|
|
124
|
-
Tron: validateTronAddress,
|
|
125
|
-
Bsc: validateEvmAddress
|
|
126
|
-
},
|
|
127
|
-
perseverance: {
|
|
128
|
-
Bitcoin: validateBitcoinTestnetAddress,
|
|
129
|
-
Ethereum: validateEvmAddress,
|
|
130
|
-
Arbitrum: validateEvmAddress,
|
|
131
|
-
Solana: validateSolanaAddress,
|
|
132
|
-
Assethub: validatePolkadotAddress,
|
|
133
|
-
Tron: validateTronAddress,
|
|
134
|
-
Bsc: validateEvmAddress
|
|
135
|
-
},
|
|
136
|
-
sisyphos: {
|
|
137
|
-
Bitcoin: validateBitcoinTestnetAddress,
|
|
138
|
-
Ethereum: validateEvmAddress,
|
|
139
|
-
Arbitrum: validateEvmAddress,
|
|
140
|
-
Solana: validateSolanaAddress,
|
|
141
|
-
Assethub: validatePolkadotAddress,
|
|
142
|
-
Tron: validateTronAddress,
|
|
143
|
-
Bsc: validateEvmAddress
|
|
144
|
-
},
|
|
145
|
-
backspin: {
|
|
146
|
-
Bitcoin: validateBitcoinRegtestAddress,
|
|
147
|
-
Ethereum: validateEvmAddress,
|
|
148
|
-
Arbitrum: validateEvmAddress,
|
|
149
|
-
Solana: validateSolanaAddress,
|
|
150
|
-
Assethub: validatePolkadotAddress,
|
|
151
|
-
Tron: validateTronAddress,
|
|
152
|
-
Bsc: validateEvmAddress
|
|
153
|
-
},
|
|
154
|
-
localnet: {
|
|
155
|
-
Bitcoin: validateBitcoinRegtestAddress,
|
|
156
|
-
Ethereum: validateEvmAddress,
|
|
157
|
-
Arbitrum: validateEvmAddress,
|
|
158
|
-
Solana: validateSolanaAddress,
|
|
159
|
-
Assethub: validatePolkadotAddress,
|
|
160
|
-
Tron: validateTronAddress,
|
|
161
|
-
Bsc: validateEvmAddress
|
|
162
|
-
}
|
|
163
|
-
};
|
|
164
|
-
var validateAddress = (chain2, address, network) => validators[network][chain2](address);
|
|
165
|
-
|
|
166
|
-
// ../shared/src/api/openAccountCreationDepositChannel.ts
|
|
167
|
-
var getAccountCreationDepositChannelSchema = (network) => z.object({
|
|
168
|
-
signatureData: z.object({
|
|
169
|
-
Ethereum: z.object({
|
|
170
|
-
signature: hexString,
|
|
171
|
-
signer: hexString,
|
|
172
|
-
sigType: z.literal("Eip712")
|
|
173
|
-
}).transform(({ sigType, ...rest }) => ({
|
|
174
|
-
sig_type: sigType,
|
|
175
|
-
...rest
|
|
176
|
-
}))
|
|
177
|
-
}),
|
|
178
|
-
transactionMetadata: z.object({
|
|
179
|
-
nonce: z.number().gte(0),
|
|
180
|
-
expiryBlock: z.number().positive()
|
|
181
|
-
}).transform(({ nonce, expiryBlock }) => ({
|
|
182
|
-
nonce,
|
|
183
|
-
expiry_block: expiryBlock
|
|
184
|
-
})),
|
|
185
|
-
asset: assetAndChain,
|
|
186
|
-
refundAddress: z.string(),
|
|
187
|
-
boostFeeBps: z.number().optional().default(0)
|
|
188
|
-
}).superRefine(({ asset: asset2, refundAddress }, ctx) => {
|
|
189
|
-
if (!validateAddress(asset2.chain, refundAddress, network)) {
|
|
190
|
-
ctx.addIssue({
|
|
191
|
-
message: `Address "${refundAddress}" is not a valid "${asset2.chain}" address for "${network}"`,
|
|
192
|
-
code: z.ZodIssueCode.custom
|
|
193
|
-
});
|
|
194
|
-
}
|
|
195
|
-
});
|
|
196
83
|
z.object({
|
|
197
84
|
srcChain: chain,
|
|
198
85
|
srcAsset: asset,
|
|
199
86
|
destChain: chain,
|
|
200
87
|
destAsset: asset,
|
|
201
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" }),
|
|
202
|
-
brokerCommissionBps: numericOrEmptyString.transform((v) => Number(v)).optional(),
|
|
89
|
+
brokerCommissionBps: numericOrEmptyString.transform((v) => Number(v)).pipe(u16).optional(),
|
|
203
90
|
ccmGasBudget: z.union([
|
|
204
|
-
numericString.transform((v) => BigInt(v)),
|
|
91
|
+
numericString.transform((v) => BigInt(v)).refine((v) => v < 2n ** 128n, { message: "ccm gas budget must be less than 2^128" }),
|
|
205
92
|
z.literal("undefined").transform(() => void 0)
|
|
206
93
|
// sdk version 1.8.2 sends undefined string if not set
|
|
207
94
|
]).optional(),
|
|
208
95
|
ccmMessageLengthBytes: z.union([
|
|
209
|
-
numericString.transform((v) => Number(v)),
|
|
96
|
+
numericString.transform((v) => Number(v)).pipe(u32),
|
|
210
97
|
z.literal("undefined").transform(() => void 0)
|
|
211
98
|
// sdk version 1.8.2 sends undefined string if not set
|
|
212
99
|
]).optional(),
|
|
213
|
-
dcaV2Enabled: booleanString.
|
|
100
|
+
dcaV2Enabled: booleanString.prefault("false"),
|
|
214
101
|
isVaultSwap: booleanString.optional(),
|
|
215
102
|
isOnChain: booleanString.optional(),
|
|
216
103
|
brokerAccount: chainflipAddress.optional(),
|
|
217
104
|
brokerIdSs58: chainflipAddress.optional(),
|
|
218
|
-
expectedResponseTimeMs: numericString.transform((v) => Number(v)).optional()
|
|
105
|
+
expectedResponseTimeMs: numericString.transform((v) => Number(v)).pipe(u32).optional()
|
|
219
106
|
}).transform((args, ctx) => {
|
|
220
107
|
const { srcAsset, destAsset } = getInternalAssets(args, false);
|
|
221
108
|
let hadError = false;
|
|
@@ -284,7 +171,7 @@ z.object({
|
|
|
284
171
|
};
|
|
285
172
|
});
|
|
286
173
|
var ccmParamsSchema = z.object({
|
|
287
|
-
gasBudget: z.union([numericString, hexString]).transform((n) =>
|
|
174
|
+
gasBudget: z.union([numericString, hexString]).transform((n) => BigInt(n)).refine((n) => n < 2n ** 128n, { message: "ccm gas budget must be less than 2^128" }).transform((n) => hexEncodeNumber(n)),
|
|
288
175
|
// https://github.com/chainflip-io/chainflip-backend/blob/415aa9e20ec4046c68892cd34798e5d831c5b83f/state-chain/chains/src/lib.rs#L709
|
|
289
176
|
message: hexStringWithMaxByteSize(15e3),
|
|
290
177
|
// https://github.com/chainflip-io/chainflip-backend/blob/415aa9e20ec4046c68892cd34798e5d831c5b83f/state-chain/chains/src/lib.rs#L710
|
|
@@ -296,90 +183,82 @@ var ccmParamsSchema = z.object({
|
|
|
296
183
|
}));
|
|
297
184
|
var affiliateBroker = z.object({
|
|
298
185
|
account: chainflipAddress,
|
|
299
|
-
commissionBps:
|
|
186
|
+
commissionBps: u16
|
|
300
187
|
}).transform(({ account, commissionBps: bps }) => ({ account, bps }));
|
|
301
188
|
var dcaParams = z.object({
|
|
302
|
-
numberOfChunks:
|
|
303
|
-
chunkIntervalBlocks:
|
|
189
|
+
numberOfChunks: u32.min(1, { message: "number of chunks must be greater than 0" }),
|
|
190
|
+
chunkIntervalBlocks: u32
|
|
304
191
|
});
|
|
305
|
-
|
|
306
|
-
retryDurationBlocks:
|
|
192
|
+
z.object({
|
|
193
|
+
retryDurationBlocks: u32,
|
|
307
194
|
refundAddress: z.string(),
|
|
308
195
|
minPriceX128: numericString,
|
|
309
196
|
maxOraclePriceSlippage: basisPoints.nullish().transform((v) => v ?? null),
|
|
310
197
|
refundCcmMetadata: ccmParamsSchema.nullish().optional().default(null)
|
|
311
198
|
});
|
|
312
|
-
|
|
313
|
-
|
|
314
|
-
|
|
315
|
-
|
|
316
|
-
|
|
317
|
-
}
|
|
318
|
-
|
|
319
|
-
assets,
|
|
320
|
-
z.object({
|
|
321
|
-
destAddress: z.string(),
|
|
322
|
-
amount: numericString,
|
|
323
|
-
ccmParams: ccmParamsSchema.optional(),
|
|
324
|
-
maxBoostFeeBps: z.number().optional(),
|
|
325
|
-
srcAddress: z.string().optional(),
|
|
326
|
-
fillOrKillParams,
|
|
327
|
-
dcaParams: dcaParams.optional(),
|
|
328
|
-
quote: z.object({
|
|
329
|
-
intermediateAmount: z.string().optional(),
|
|
330
|
-
egressAmount: z.string(),
|
|
331
|
-
estimatedPrice: z.string(),
|
|
332
|
-
recommendedSlippageTolerancePercent: z.number().optional(),
|
|
333
|
-
recommendedLivePriceSlippageTolerancePercent: z.number().optional()
|
|
334
|
-
}).optional(),
|
|
335
|
-
takeCommission: z.boolean().optional()
|
|
336
|
-
})
|
|
337
|
-
).superRefine(({ ...val }, ctx) => {
|
|
338
|
-
if (!validateAddress(val.destAsset.chain, val.destAddress, network)) {
|
|
339
|
-
ctx.addIssue({
|
|
340
|
-
message: `Address "${val.destAddress}" is not a valid "${val.destAsset.chain}" address for "${network}"`,
|
|
341
|
-
code: z.ZodIssueCode.custom
|
|
342
|
-
});
|
|
343
|
-
}
|
|
344
|
-
if (!validateAddress(val.srcAsset.chain, val.fillOrKillParams.refundAddress, network)) {
|
|
345
|
-
ctx.addIssue({
|
|
346
|
-
message: `Address "${val.fillOrKillParams.refundAddress}" is not a valid "${val.srcAsset.chain}" address for "${network}"`,
|
|
347
|
-
code: z.ZodIssueCode.custom
|
|
348
|
-
});
|
|
349
|
-
}
|
|
350
|
-
}).transform(({ amount, ...rest }) => ({
|
|
351
|
-
...rest,
|
|
352
|
-
expectedDepositAmount: amount
|
|
353
|
-
}));
|
|
354
|
-
var DepositChannelInfo = z.object({
|
|
355
|
-
id: z.string(),
|
|
356
|
-
depositAddress: z.string(),
|
|
357
|
-
brokerCommissionBps: z.number(),
|
|
358
|
-
maxBoostFeeBps: z.number(),
|
|
359
|
-
issuedBlock: z.number(),
|
|
360
|
-
srcChainExpiryBlock: z.string(),
|
|
361
|
-
estimatedExpiryTime: z.number().optional(),
|
|
362
|
-
channelOpeningFee: z.string()
|
|
363
|
-
});
|
|
364
|
-
|
|
365
|
-
// ../shared/src/strings.ts
|
|
366
|
-
var toCamelCase = (str) => str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
|
|
367
|
-
|
|
368
|
-
// ../shared/src/objects.ts
|
|
369
|
-
var transformKeysToCamelCase = (obj) => {
|
|
370
|
-
if (Array.isArray(obj)) {
|
|
371
|
-
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;
|
|
372
206
|
}
|
|
373
|
-
|
|
374
|
-
|
|
375
|
-
|
|
376
|
-
|
|
377
|
-
|
|
378
|
-
|
|
379
|
-
|
|
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
|
|
380
259
|
}
|
|
381
|
-
return obj;
|
|
382
260
|
};
|
|
261
|
+
var validateAddress = (chain2, address, network) => Object.hasOwn(validators, network) && Object.hasOwn(validators[network], chain2) && validators[network][chain2](address);
|
|
383
262
|
|
|
384
263
|
// ../shared/src/broker.ts
|
|
385
264
|
var transformedDcaParamsSchema = dcaParams.transform(
|
|
@@ -396,7 +275,7 @@ var transformedCcmParamsSchema = ccmParamsSchema.transform(
|
|
|
396
275
|
})
|
|
397
276
|
);
|
|
398
277
|
var transformedFokSchema = z.object({
|
|
399
|
-
retryDurationBlocks:
|
|
278
|
+
retryDurationBlocks: u32,
|
|
400
279
|
refundAddress: z.string(),
|
|
401
280
|
minPriceX128: numericString,
|
|
402
281
|
maxOraclePriceSlippage: basisPoints.nullish().transform((v) => v ?? null),
|
|
@@ -420,9 +299,9 @@ var getDepositAddressRequestSchema = (network) => z.object({
|
|
|
420
299
|
srcAsset: assetAndChain,
|
|
421
300
|
destAsset: assetAndChain,
|
|
422
301
|
destAddress: z.string(),
|
|
423
|
-
commissionBps:
|
|
302
|
+
commissionBps: u16.optional().default(0),
|
|
424
303
|
ccmParams: transformedCcmParamsSchema.optional(),
|
|
425
|
-
maxBoostFeeBps:
|
|
304
|
+
maxBoostFeeBps: u16.optional(),
|
|
426
305
|
affiliates: z.array(affiliateBroker).optional(),
|
|
427
306
|
fillOrKillParams: transformedFokSchema,
|
|
428
307
|
dcaParams: transformedDcaParamsSchema.optional()
|
|
@@ -446,9 +325,9 @@ var getVaultSwapParameterEncodingRequestSchema = (network) => z.object({
|
|
|
446
325
|
destAsset: assetAndChain,
|
|
447
326
|
destAddress: z.string(),
|
|
448
327
|
amount: unsignedInteger,
|
|
449
|
-
commissionBps:
|
|
328
|
+
commissionBps: u16.optional().default(0),
|
|
450
329
|
ccmParams: transformedCcmParamsSchema.optional(),
|
|
451
|
-
maxBoostFeeBps:
|
|
330
|
+
maxBoostFeeBps: u16.optional(),
|
|
452
331
|
affiliates: z.array(affiliateBroker).optional(),
|
|
453
332
|
fillOrKillParams: transformedFokSchema,
|
|
454
333
|
dcaParams: transformedDcaParamsSchema.optional(),
|
|
@@ -476,7 +355,7 @@ var getVaultSwapParameterEncodingRequestSchema = (network) => z.object({
|
|
|
476
355
|
if (val.extraParams?.seed && val.extraParams.seed.length !== 66) {
|
|
477
356
|
ctx.addIssue({ message: "Seed must be 32 bytes", code: z.ZodIssueCode.custom });
|
|
478
357
|
}
|
|
479
|
-
}).transform((data) => {
|
|
358
|
+
}).transform((data, ctx) => {
|
|
480
359
|
let extraParams;
|
|
481
360
|
if (data.srcAsset.chain === "Bitcoin") {
|
|
482
361
|
const minOutputAmount = BigNumber2(data.amount.toString()).multipliedBy(priceX128ToPrice(data.fillOrKillParams.min_price)).toFixed(0);
|
|
@@ -493,7 +372,13 @@ var getVaultSwapParameterEncodingRequestSchema = (network) => z.object({
|
|
|
493
372
|
refund_parameters: data.fillOrKillParams
|
|
494
373
|
};
|
|
495
374
|
} else if (data.srcAsset.chain === "Solana") {
|
|
496
|
-
|
|
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
|
+
}
|
|
497
382
|
extraParams = {
|
|
498
383
|
chain: "Solana",
|
|
499
384
|
from: data.srcAddress,
|
|
@@ -502,7 +387,11 @@ var getVaultSwapParameterEncodingRequestSchema = (network) => z.object({
|
|
|
502
387
|
refund_parameters: data.fillOrKillParams
|
|
503
388
|
};
|
|
504
389
|
} else {
|
|
505
|
-
|
|
390
|
+
ctx.addIssue({
|
|
391
|
+
message: `parameter encoding is not supported for ${data.srcAsset.chain}`,
|
|
392
|
+
code: z.ZodIssueCode.custom
|
|
393
|
+
});
|
|
394
|
+
return z.NEVER;
|
|
506
395
|
}
|
|
507
396
|
return { ...data, extraParams };
|
|
508
397
|
});
|
|
@@ -562,9 +451,9 @@ var getParameterEncodingRequestSchema = (network) => z.object({
|
|
|
562
451
|
destAsset: assetAndChain,
|
|
563
452
|
destAddress: z.string(),
|
|
564
453
|
amount: unsignedInteger,
|
|
565
|
-
commissionBps:
|
|
454
|
+
commissionBps: u16.optional().default(0),
|
|
566
455
|
ccmParams: transformedCcmParamsSchema.optional(),
|
|
567
|
-
maxBoostFeeBps:
|
|
456
|
+
maxBoostFeeBps: u16.optional(),
|
|
568
457
|
affiliates: z.array(affiliateBroker).optional(),
|
|
569
458
|
fillOrKillParams: transformedFokSchema,
|
|
570
459
|
dcaParams: transformedDcaParamsSchema.optional(),
|
|
@@ -606,68 +495,18 @@ async function requestCfParametersEncoding(request, opts, network) {
|
|
|
606
495
|
);
|
|
607
496
|
return response;
|
|
608
497
|
}
|
|
609
|
-
|
|
610
|
-
// ../shared/src/api/contract.ts
|
|
611
|
-
var c = initContract();
|
|
612
|
-
var createApiContract = (network) => c.router(
|
|
613
|
-
{
|
|
614
|
-
networkInfo: {
|
|
615
|
-
method: "GET",
|
|
616
|
-
path: "/networkInfo",
|
|
617
|
-
responses: {
|
|
618
|
-
200: NetworkInfo
|
|
619
|
-
},
|
|
620
|
-
summary: "Get information about the Chainflip network"
|
|
621
|
-
},
|
|
622
|
-
encodeCfParameters: {
|
|
623
|
-
method: "POST",
|
|
624
|
-
path: "/encodeCfParameters",
|
|
625
|
-
body: getParameterEncodingRequestSchema(network),
|
|
626
|
-
responses: {
|
|
627
|
-
200: hexString
|
|
628
|
-
}
|
|
629
|
-
},
|
|
630
|
-
encodeVaultSwapData: {
|
|
631
|
-
method: "POST",
|
|
632
|
-
path: "/encodeVaultSwapData",
|
|
633
|
-
body: getVaultSwapParameterEncodingRequestSchema(network),
|
|
634
|
-
responses: {
|
|
635
|
-
200: EncodedVaultSwapData
|
|
636
|
-
}
|
|
637
|
-
},
|
|
638
|
-
openSwapDepositChannel: {
|
|
639
|
-
method: "POST",
|
|
640
|
-
path: "/openSwapDepositChannel",
|
|
641
|
-
body: getOpenSwapDepositChannelSchema(network),
|
|
642
|
-
responses: {
|
|
643
|
-
201: DepositChannelInfo
|
|
644
|
-
}
|
|
645
|
-
},
|
|
646
|
-
openAccountCreationDepositChannel: {
|
|
647
|
-
method: "POST",
|
|
648
|
-
path: "/openAccountCreationDepositChannel",
|
|
649
|
-
body: getAccountCreationDepositChannelSchema(network),
|
|
650
|
-
responses: {
|
|
651
|
-
201: DepositChannelInfo
|
|
652
|
-
}
|
|
653
|
-
}
|
|
654
|
-
},
|
|
655
|
-
{
|
|
656
|
-
pathPrefix: "/api"
|
|
657
|
-
}
|
|
658
|
-
);
|
|
659
498
|
var MultiCache = class {
|
|
660
499
|
constructor(fetchers) {
|
|
661
500
|
this.fetchers = fetchers;
|
|
662
501
|
}
|
|
663
502
|
values = {};
|
|
664
503
|
read(type) {
|
|
665
|
-
const { fetch, ttl } = this.fetchers[type];
|
|
504
|
+
const { fetch: fetch2, ttl } = this.fetchers[type];
|
|
666
505
|
let cached = this.values[type];
|
|
667
506
|
if (!cached || cached.timestamp + ttl < Date.now()) {
|
|
668
507
|
cached = {
|
|
669
508
|
timestamp: Date.now(),
|
|
670
|
-
value:
|
|
509
|
+
value: fetch2().catch((err) => {
|
|
671
510
|
this.values[type] = void 0;
|
|
672
511
|
throw err;
|
|
673
512
|
})
|
|
@@ -815,7 +654,7 @@ var getChainData = (chain2, network, env) => ({
|
|
|
815
654
|
|
|
816
655
|
// package.json
|
|
817
656
|
var package_default = {
|
|
818
|
-
version: "2.3.
|
|
657
|
+
version: "2.3.3"};
|
|
819
658
|
|
|
820
659
|
// src/swap/consts.ts
|
|
821
660
|
var CF_SDK_VERSION_HEADERS = { "X-Chainflip-Sdk-Version": package_default.version };
|
|
@@ -863,6 +702,59 @@ var getStatusV2 = async (baseUrl, { id }, { signal }) => {
|
|
|
863
702
|
});
|
|
864
703
|
return data;
|
|
865
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
|
+
};
|
|
866
758
|
|
|
867
759
|
// src/swap/sdk.ts
|
|
868
760
|
var assertQuoteValid = (quote) => {
|
|
@@ -879,7 +771,6 @@ var assertQuoteValid = (quote) => {
|
|
|
879
771
|
var SwapSDK = class {
|
|
880
772
|
options;
|
|
881
773
|
rpcConfig;
|
|
882
|
-
apiClient;
|
|
883
774
|
cache;
|
|
884
775
|
dcaV2Enabled = false;
|
|
885
776
|
constructor(options = {}) {
|
|
@@ -890,12 +781,6 @@ var SwapSDK = class {
|
|
|
890
781
|
backendUrl: options.backendUrl ?? BACKEND_SERVICE_URLS[network]
|
|
891
782
|
};
|
|
892
783
|
this.rpcConfig = options.rpcUrl ? { rpcUrl: options.rpcUrl } : { network };
|
|
893
|
-
this.apiClient = initClient(createApiContract(this.options.network), {
|
|
894
|
-
// remove trailing slashes. this bug has been fixed in `@ts-rest/core`
|
|
895
|
-
// but it hasn't been released yet
|
|
896
|
-
baseUrl: this.options.backendUrl.replace(/\/+$/, ""),
|
|
897
|
-
baseHeaders: CF_SDK_VERSION_HEADERS
|
|
898
|
-
});
|
|
899
784
|
this.dcaV2Enabled = options.enabledFeatures?.dcaV2 ?? false;
|
|
900
785
|
this.cache = new MultiCache({
|
|
901
786
|
environment: {
|
|
@@ -903,11 +788,7 @@ var SwapSDK = class {
|
|
|
903
788
|
ttl: 6e4
|
|
904
789
|
},
|
|
905
790
|
networkInfo: {
|
|
906
|
-
fetch:
|
|
907
|
-
const res = await this.apiClient.networkInfo();
|
|
908
|
-
assert(res.status === 200, "Failed to fetch network info");
|
|
909
|
-
return res.body;
|
|
910
|
-
},
|
|
791
|
+
fetch: () => getNetworkInfo(this.options.backendUrl),
|
|
911
792
|
ttl: 6e4
|
|
912
793
|
}
|
|
913
794
|
});
|
|
@@ -928,8 +809,8 @@ var SwapSDK = class {
|
|
|
928
809
|
return this.cache.read("environment");
|
|
929
810
|
}
|
|
930
811
|
async getSupportedAssets(type) {
|
|
931
|
-
const
|
|
932
|
-
return
|
|
812
|
+
const assets = await this.cache.read("networkInfo");
|
|
813
|
+
return assets.assets.filter((a) => isChainflipAsset(a.asset)).filter((a) => {
|
|
933
814
|
switch (type) {
|
|
934
815
|
case "all":
|
|
935
816
|
return true;
|
|
@@ -1111,15 +992,11 @@ var SwapSDK = class {
|
|
|
1111
992
|
!affiliates?.length,
|
|
1112
993
|
"Affiliate brokers are supported only when initializing the SDK with a brokerUrl"
|
|
1113
994
|
);
|
|
1114
|
-
|
|
1115
|
-
|
|
1116
|
-
|
|
1117
|
-
|
|
1118
|
-
takeCommission: this.shouldTakeCommission()
|
|
1119
|
-
}
|
|
995
|
+
response = await openSwapDepositChannel(this.options.backendUrl, {
|
|
996
|
+
...depositAddressRequest,
|
|
997
|
+
quote,
|
|
998
|
+
takeCommission: this.shouldTakeCommission()
|
|
1120
999
|
});
|
|
1121
|
-
assert(res.status === 201, "Failed to open swap deposit channel");
|
|
1122
|
-
response = res.body;
|
|
1123
1000
|
}
|
|
1124
1001
|
return {
|
|
1125
1002
|
...depositAddressRequest,
|
|
@@ -1192,18 +1069,15 @@ var SwapSDK = class {
|
|
|
1192
1069
|
!vaultSwapRequest.affiliates?.length || vaultSwapRequest.brokerAccount,
|
|
1193
1070
|
"Affiliate brokers are supported only when setting a broker account"
|
|
1194
1071
|
);
|
|
1195
|
-
const
|
|
1196
|
-
|
|
1197
|
-
throw new Error("Failed to encode vault swap data", { cause: res });
|
|
1198
|
-
}
|
|
1199
|
-
switch (res.body.chain) {
|
|
1072
|
+
const body = await encodeVaultSwapData(this.options.backendUrl, vaultSwapRequest);
|
|
1073
|
+
switch (body.chain) {
|
|
1200
1074
|
case "Arbitrum":
|
|
1201
1075
|
case "Ethereum":
|
|
1202
1076
|
case "Tron":
|
|
1203
1077
|
case "Bsc":
|
|
1204
|
-
return { ...
|
|
1078
|
+
return { ...body, value: BigInt(body.value) };
|
|
1205
1079
|
default:
|
|
1206
|
-
return
|
|
1080
|
+
return body;
|
|
1207
1081
|
}
|
|
1208
1082
|
}
|
|
1209
1083
|
async encodeCfParameters({
|
|
@@ -1255,32 +1129,23 @@ var SwapSDK = class {
|
|
|
1255
1129
|
!requestParams.affiliates?.length || brokerAccount,
|
|
1256
1130
|
"Affiliate brokers are supported only when setting a broker account"
|
|
1257
1131
|
);
|
|
1258
|
-
|
|
1259
|
-
|
|
1132
|
+
return encodeCfParameters(this.options.backendUrl, {
|
|
1133
|
+
...requestParams,
|
|
1134
|
+
brokerAccount
|
|
1260
1135
|
});
|
|
1261
|
-
if (res.status !== 200) {
|
|
1262
|
-
throw new Error("Failed to encode cf parameters", { cause: res });
|
|
1263
|
-
}
|
|
1264
|
-
return res.body;
|
|
1265
1136
|
}
|
|
1266
1137
|
async checkBoostEnabled() {
|
|
1267
|
-
const { assets
|
|
1268
|
-
return
|
|
1138
|
+
const { assets } = await this.cache.read("networkInfo");
|
|
1139
|
+
return assets.find((a) => a.asset === "Btc")?.boostDepositsEnabled ?? true;
|
|
1269
1140
|
}
|
|
1270
1141
|
async requestAccountCreationDepositAddress(asset2, refundAddress, signatureData, transactionMetadata, boostFeeBps = 0) {
|
|
1271
|
-
|
|
1272
|
-
|
|
1273
|
-
|
|
1274
|
-
|
|
1275
|
-
|
|
1276
|
-
|
|
1277
|
-
boostFeeBps
|
|
1278
|
-
}
|
|
1142
|
+
return openAccountCreationDepositChannel(this.options.backendUrl, {
|
|
1143
|
+
asset: internalAssetToRpcAsset[asset2],
|
|
1144
|
+
refundAddress,
|
|
1145
|
+
signatureData,
|
|
1146
|
+
transactionMetadata,
|
|
1147
|
+
boostFeeBps
|
|
1279
1148
|
});
|
|
1280
|
-
if (res.status !== 201) {
|
|
1281
|
-
throw new Error("Failed to request account creation deposit channel", { cause: res });
|
|
1282
|
-
}
|
|
1283
|
-
return res.body;
|
|
1284
1149
|
}
|
|
1285
1150
|
};
|
|
1286
1151
|
var arrayToMap = (array) => Object.fromEntries(array.map((item) => [item, item]));
|