@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.cjs
CHANGED
|
@@ -3,19 +3,18 @@
|
|
|
3
3
|
var assertion = require('@chainflip/utils/assertion');
|
|
4
4
|
var chainflip = require('@chainflip/utils/chainflip');
|
|
5
5
|
var lending = require('@chainflip/utils/lending');
|
|
6
|
-
var core = require('@ts-rest/core');
|
|
7
|
-
var z3 = require('zod');
|
|
8
|
-
var solana = require('@chainflip/solana');
|
|
9
|
-
var ss58 = require('@chainflip/utils/ss58');
|
|
10
|
-
var tron = require('@chainflip/utils/tron');
|
|
11
|
-
var bitcoin = require('@chainflip/bitcoin');
|
|
12
|
-
var string = require('@chainflip/utils/string');
|
|
13
|
-
var ethers = require('ethers');
|
|
14
|
-
var number = require('@chainflip/utils/number');
|
|
15
6
|
var rpc = require('@chainflip/rpc');
|
|
16
7
|
var bytes = require('@chainflip/utils/bytes');
|
|
8
|
+
var ss58 = require('@chainflip/utils/ss58');
|
|
9
|
+
var string = require('@chainflip/utils/string');
|
|
17
10
|
var tickMath = require('@chainflip/utils/tickMath');
|
|
18
11
|
var BigNumber2 = require('bignumber.js');
|
|
12
|
+
var zod = require('zod');
|
|
13
|
+
var solana = require('@chainflip/solana');
|
|
14
|
+
var tron = require('@chainflip/utils/tron');
|
|
15
|
+
var number = require('@chainflip/utils/number');
|
|
16
|
+
var bitcoin = require('@chainflip/bitcoin');
|
|
17
|
+
var ethers = require('ethers');
|
|
19
18
|
var consts = require('@chainflip/utils/consts');
|
|
20
19
|
var axios = require('axios');
|
|
21
20
|
|
|
@@ -39,24 +38,42 @@ function _interopNamespace(e) {
|
|
|
39
38
|
return Object.freeze(n);
|
|
40
39
|
}
|
|
41
40
|
|
|
42
|
-
var z3__default = /*#__PURE__*/_interopDefault(z3);
|
|
43
41
|
var ss58__namespace = /*#__PURE__*/_interopNamespace(ss58);
|
|
42
|
+
var BigNumber2__default = /*#__PURE__*/_interopDefault(BigNumber2);
|
|
44
43
|
var bitcoin__namespace = /*#__PURE__*/_interopNamespace(bitcoin);
|
|
45
44
|
var ethers__namespace = /*#__PURE__*/_interopNamespace(ethers);
|
|
46
|
-
var BigNumber2__default = /*#__PURE__*/_interopDefault(BigNumber2);
|
|
47
45
|
var axios__default = /*#__PURE__*/_interopDefault(axios);
|
|
48
46
|
|
|
49
47
|
// src/swap/sdk.ts
|
|
50
|
-
|
|
51
|
-
|
|
52
|
-
var
|
|
53
|
-
|
|
48
|
+
|
|
49
|
+
// ../shared/src/strings.ts
|
|
50
|
+
var toCamelCase = (str) => str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
|
|
51
|
+
|
|
52
|
+
// ../shared/src/objects.ts
|
|
53
|
+
var transformKeysToCamelCase = (obj) => {
|
|
54
|
+
if (Array.isArray(obj)) {
|
|
55
|
+
return obj.map(transformKeysToCamelCase);
|
|
56
|
+
}
|
|
57
|
+
if (obj !== null && typeof obj === "object") {
|
|
58
|
+
return Object.fromEntries(
|
|
59
|
+
Object.entries(obj).map(([key, value]) => [
|
|
60
|
+
toCamelCase(key),
|
|
61
|
+
transformKeysToCamelCase(value)
|
|
62
|
+
])
|
|
63
|
+
);
|
|
64
|
+
}
|
|
65
|
+
return obj;
|
|
66
|
+
};
|
|
67
|
+
var booleanString = zod.z.string().regex(/^(true|false)$/i).transform((v) => v.toLowerCase() === "true");
|
|
68
|
+
var numericString = zod.z.string().regex(/^[0-9]+$/);
|
|
69
|
+
var numericOrEmptyString = zod.z.string().regex(/^[0-9]*$/);
|
|
70
|
+
var hexString = zod.z.string().refine((v) => /^0x[0-9a-f]*$/i.test(v));
|
|
54
71
|
var hexStringWithMaxByteSize = (maxByteSize) => hexString.refine((val) => val.length / 2 <= maxByteSize + 1, {
|
|
55
72
|
message: `String must be less than or equal to ${maxByteSize} bytes`
|
|
56
73
|
});
|
|
57
|
-
var basisPoints =
|
|
74
|
+
var basisPoints = zod.z.number().int({ message: "must be in basis points" });
|
|
58
75
|
var DOT_PREFIX = 0;
|
|
59
|
-
var chainflipAddress =
|
|
76
|
+
var chainflipAddress = zod.z.string().refine(
|
|
60
77
|
(address) => {
|
|
61
78
|
if (!address.startsWith("cF")) return false;
|
|
62
79
|
try {
|
|
@@ -66,258 +83,107 @@ var chainflipAddress = z3.z.string().refine(
|
|
|
66
83
|
return false;
|
|
67
84
|
}
|
|
68
85
|
},
|
|
69
|
-
(
|
|
86
|
+
{ error: (issue) => `${issue.input} is not a valid Chainflip address` }
|
|
70
87
|
);
|
|
71
|
-
|
|
72
|
-
|
|
73
|
-
}));
|
|
74
|
-
var tronAddress = z3.z.string().refine(tron.isValidTronAddress, (address) => ({
|
|
75
|
-
message: `${address} is not a valid Tron address`
|
|
76
|
-
}));
|
|
77
|
-
var u128 = z3.z.union([z3.z.number(), numericString, hexString]).transform((arg) => BigInt(arg));
|
|
78
|
-
var unsignedInteger = z3.z.union([u128, z3.z.number().transform((n) => BigInt(n))]);
|
|
79
|
-
var chain = z3.z.enum(chainflip.chainflipChains);
|
|
80
|
-
var asset = z3.z.enum(chainflip.assetSymbols);
|
|
81
|
-
var uncheckedAssetAndChain = z3.z.object({
|
|
82
|
-
asset: z3.z.string(),
|
|
83
|
-
chain: z3.z.string()
|
|
88
|
+
zod.z.string().refine(solana.isValidSolanaAddress, {
|
|
89
|
+
error: (issue) => `${issue.input} is not a valid Solana address`
|
|
84
90
|
});
|
|
85
|
-
|
|
86
|
-
(
|
|
87
|
-
);
|
|
88
|
-
|
|
89
|
-
// ../shared/src/api/encodeVaultSwapData.ts
|
|
90
|
-
var EncodedVaultSwapData = z3.z.discriminatedUnion("chain", [
|
|
91
|
-
z3.z.object({
|
|
92
|
-
chain: z3.z.literal("Bitcoin"),
|
|
93
|
-
nulldataPayload: hexString,
|
|
94
|
-
depositAddress: z3.z.string()
|
|
95
|
-
}),
|
|
96
|
-
z3.z.object({
|
|
97
|
-
chain: z3.z.enum(["Ethereum", "Arbitrum", "Bsc"]),
|
|
98
|
-
value: z3.z.string(),
|
|
99
|
-
to: hexString,
|
|
100
|
-
calldata: hexString,
|
|
101
|
-
sourceTokenAddress: hexString.optional()
|
|
102
|
-
}),
|
|
103
|
-
z3.z.object({
|
|
104
|
-
chain: z3.z.literal("Tron"),
|
|
105
|
-
calldata: hexString,
|
|
106
|
-
value: z3.z.string(),
|
|
107
|
-
to: tronAddress,
|
|
108
|
-
note: hexString,
|
|
109
|
-
sourceTokenAddress: tronAddress.optional()
|
|
110
|
-
}),
|
|
111
|
-
z3.z.object({
|
|
112
|
-
chain: z3.z.literal("Solana"),
|
|
113
|
-
programId: z3.z.string(),
|
|
114
|
-
data: hexString,
|
|
115
|
-
accounts: z3.z.array(
|
|
116
|
-
z3.z.object({
|
|
117
|
-
pubkey: z3.z.string(),
|
|
118
|
-
isSigner: z3.z.boolean(),
|
|
119
|
-
isWritable: z3.z.boolean()
|
|
120
|
-
})
|
|
121
|
-
)
|
|
122
|
-
})
|
|
123
|
-
]);
|
|
124
|
-
var NetworkInfo = z3__default.default.object({
|
|
125
|
-
assets: z3__default.default.array(
|
|
126
|
-
z3__default.default.object({
|
|
127
|
-
asset: z3__default.default.enum(chainflip.chainflipAssets),
|
|
128
|
-
vaultSwapDepositsEnabled: z3__default.default.boolean(),
|
|
129
|
-
depositChannelDepositsEnabled: z3__default.default.boolean(),
|
|
130
|
-
depositChannelCreationEnabled: z3__default.default.boolean(),
|
|
131
|
-
egressEnabled: z3__default.default.boolean(),
|
|
132
|
-
boostDepositsEnabled: z3__default.default.boolean(),
|
|
133
|
-
livePriceProtectionEnabled: z3__default.default.boolean()
|
|
134
|
-
})
|
|
135
|
-
),
|
|
136
|
-
cfBrokerCommissionBps: z3__default.default.number()
|
|
91
|
+
zod.z.string().refine(tron.isValidTronAddress, {
|
|
92
|
+
error: (issue) => `${issue.input} is not a valid Tron address`
|
|
137
93
|
});
|
|
138
|
-
|
|
139
|
-
|
|
140
|
-
var
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
|
|
144
|
-
|
|
145
|
-
|
|
146
|
-
|
|
147
|
-
|
|
148
|
-
|
|
149
|
-
|
|
150
|
-
|
|
151
|
-
var validatePolkadotAddress = (address) => {
|
|
152
|
-
if (string.isHex(address)) return address.length === 66;
|
|
153
|
-
try {
|
|
154
|
-
ss58__namespace.decode(address);
|
|
155
|
-
return true;
|
|
156
|
-
} catch {
|
|
157
|
-
return false;
|
|
158
|
-
}
|
|
159
|
-
};
|
|
160
|
-
var validateEvmAddress = (address) => ethers__namespace.isAddress(address);
|
|
161
|
-
var validateBitcoinMainnetAddress = (address) => bitcoin__namespace.isValidAddressForNetwork(address, "mainnet");
|
|
162
|
-
var validateBitcoinTestnetAddress = (address) => bitcoin__namespace.isValidAddressForNetwork(address, "testnet");
|
|
163
|
-
var validateBitcoinRegtestAddress = (address) => bitcoin__namespace.isValidAddressForNetwork(address, "regtest");
|
|
164
|
-
var validateSolanaAddress = solana.isValidSolanaAddress;
|
|
165
|
-
var validateTronAddress = tron.isValidTronAddress;
|
|
166
|
-
var validators = {
|
|
167
|
-
mainnet: {
|
|
168
|
-
Bitcoin: validateBitcoinMainnetAddress,
|
|
169
|
-
Ethereum: validateEvmAddress,
|
|
170
|
-
Arbitrum: validateEvmAddress,
|
|
171
|
-
Solana: validateSolanaAddress,
|
|
172
|
-
Assethub: validatePolkadotAddress,
|
|
173
|
-
Tron: validateTronAddress,
|
|
174
|
-
Bsc: validateEvmAddress
|
|
175
|
-
},
|
|
176
|
-
perseverance: {
|
|
177
|
-
Bitcoin: validateBitcoinTestnetAddress,
|
|
178
|
-
Ethereum: validateEvmAddress,
|
|
179
|
-
Arbitrum: validateEvmAddress,
|
|
180
|
-
Solana: validateSolanaAddress,
|
|
181
|
-
Assethub: validatePolkadotAddress,
|
|
182
|
-
Tron: validateTronAddress,
|
|
183
|
-
Bsc: validateEvmAddress
|
|
184
|
-
},
|
|
185
|
-
sisyphos: {
|
|
186
|
-
Bitcoin: validateBitcoinTestnetAddress,
|
|
187
|
-
Ethereum: validateEvmAddress,
|
|
188
|
-
Arbitrum: validateEvmAddress,
|
|
189
|
-
Solana: validateSolanaAddress,
|
|
190
|
-
Assethub: validatePolkadotAddress,
|
|
191
|
-
Tron: validateTronAddress,
|
|
192
|
-
Bsc: validateEvmAddress
|
|
193
|
-
},
|
|
194
|
-
backspin: {
|
|
195
|
-
Bitcoin: validateBitcoinRegtestAddress,
|
|
196
|
-
Ethereum: validateEvmAddress,
|
|
197
|
-
Arbitrum: validateEvmAddress,
|
|
198
|
-
Solana: validateSolanaAddress,
|
|
199
|
-
Assethub: validatePolkadotAddress,
|
|
200
|
-
Tron: validateTronAddress,
|
|
201
|
-
Bsc: validateEvmAddress
|
|
202
|
-
},
|
|
203
|
-
localnet: {
|
|
204
|
-
Bitcoin: validateBitcoinRegtestAddress,
|
|
205
|
-
Ethereum: validateEvmAddress,
|
|
206
|
-
Arbitrum: validateEvmAddress,
|
|
207
|
-
Solana: validateSolanaAddress,
|
|
208
|
-
Assethub: validatePolkadotAddress,
|
|
209
|
-
Tron: validateTronAddress,
|
|
210
|
-
Bsc: validateEvmAddress
|
|
211
|
-
}
|
|
212
|
-
};
|
|
213
|
-
var validateAddress = (chain2, address, network) => validators[network][chain2](address);
|
|
214
|
-
|
|
215
|
-
// ../shared/src/api/openAccountCreationDepositChannel.ts
|
|
216
|
-
var getAccountCreationDepositChannelSchema = (network) => z3.z.object({
|
|
217
|
-
signatureData: z3.z.object({
|
|
218
|
-
Ethereum: z3.z.object({
|
|
219
|
-
signature: hexString,
|
|
220
|
-
signer: hexString,
|
|
221
|
-
sigType: z3.z.literal("Eip712")
|
|
222
|
-
}).transform(({ sigType, ...rest }) => ({
|
|
223
|
-
sig_type: sigType,
|
|
224
|
-
...rest
|
|
225
|
-
}))
|
|
226
|
-
}),
|
|
227
|
-
transactionMetadata: z3.z.object({
|
|
228
|
-
nonce: z3.z.number().gte(0),
|
|
229
|
-
expiryBlock: z3.z.number().positive()
|
|
230
|
-
}).transform(({ nonce, expiryBlock }) => ({
|
|
231
|
-
nonce,
|
|
232
|
-
expiry_block: expiryBlock
|
|
233
|
-
})),
|
|
234
|
-
asset: assetAndChain,
|
|
235
|
-
refundAddress: z3.z.string(),
|
|
236
|
-
boostFeeBps: z3.z.number().optional().default(0)
|
|
237
|
-
}).superRefine(({ asset: asset2, refundAddress }, ctx) => {
|
|
238
|
-
if (!validateAddress(asset2.chain, refundAddress, network)) {
|
|
239
|
-
ctx.addIssue({
|
|
240
|
-
message: `Address "${refundAddress}" is not a valid "${asset2.chain}" address for "${network}"`,
|
|
241
|
-
code: z3.z.ZodIssueCode.custom
|
|
242
|
-
});
|
|
243
|
-
}
|
|
94
|
+
var u16 = zod.z.number().int().nonnegative().max(65535);
|
|
95
|
+
var u32 = zod.z.number().int().nonnegative().max(4294967295);
|
|
96
|
+
var u128 = zod.z.union([
|
|
97
|
+
zod.z.number().int().nonnegative().safe(),
|
|
98
|
+
numericString,
|
|
99
|
+
hexString.refine((v) => v.length > 2, { message: "hex string must not be empty" })
|
|
100
|
+
]).transform((arg) => BigInt(arg)).refine((n) => n < 2n ** 128n, { message: "must be less than 2^128" });
|
|
101
|
+
var unsignedInteger = u128;
|
|
102
|
+
var chain = zod.z.enum(chainflip.chainflipChains);
|
|
103
|
+
var asset = zod.z.enum(chainflip.assetSymbols);
|
|
104
|
+
var uncheckedAssetAndChain = zod.z.object({
|
|
105
|
+
asset: zod.z.string(),
|
|
106
|
+
chain: zod.z.string()
|
|
244
107
|
});
|
|
245
|
-
|
|
108
|
+
var assetAndChain = uncheckedAssetAndChain.refine(
|
|
109
|
+
(value) => chain.safeParse(value.chain).success && asset.safeParse(value.asset).success && chainflip.isValidAssetAndChain(value)
|
|
110
|
+
);
|
|
111
|
+
zod.z.object({
|
|
246
112
|
srcChain: chain,
|
|
247
113
|
srcAsset: asset,
|
|
248
114
|
destChain: chain,
|
|
249
115
|
destAsset: asset,
|
|
250
116
|
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" }),
|
|
251
|
-
brokerCommissionBps: numericOrEmptyString.transform((v) => Number(v)).optional(),
|
|
252
|
-
ccmGasBudget:
|
|
117
|
+
brokerCommissionBps: numericOrEmptyString.transform((v) => Number(v)).pipe(u16).optional(),
|
|
118
|
+
ccmGasBudget: zod.z.union([
|
|
253
119
|
numericString.transform((v) => BigInt(v)).refine((v) => v < 2n ** 128n, { message: "ccm gas budget must be less than 2^128" }),
|
|
254
|
-
|
|
120
|
+
zod.z.literal("undefined").transform(() => void 0)
|
|
255
121
|
// sdk version 1.8.2 sends undefined string if not set
|
|
256
122
|
]).optional(),
|
|
257
|
-
ccmMessageLengthBytes:
|
|
258
|
-
numericString.transform((v) => Number(v)),
|
|
259
|
-
|
|
123
|
+
ccmMessageLengthBytes: zod.z.union([
|
|
124
|
+
numericString.transform((v) => Number(v)).pipe(u32),
|
|
125
|
+
zod.z.literal("undefined").transform(() => void 0)
|
|
260
126
|
// sdk version 1.8.2 sends undefined string if not set
|
|
261
127
|
]).optional(),
|
|
262
|
-
dcaV2Enabled: booleanString.
|
|
128
|
+
dcaV2Enabled: booleanString.prefault("false"),
|
|
263
129
|
isVaultSwap: booleanString.optional(),
|
|
264
130
|
isOnChain: booleanString.optional(),
|
|
265
131
|
brokerAccount: chainflipAddress.optional(),
|
|
266
132
|
brokerIdSs58: chainflipAddress.optional(),
|
|
267
|
-
expectedResponseTimeMs: numericString.transform((v) => Number(v)).optional()
|
|
133
|
+
expectedResponseTimeMs: numericString.transform((v) => Number(v)).pipe(u32).optional()
|
|
268
134
|
}).transform((args, ctx) => {
|
|
269
135
|
const { srcAsset, destAsset } = chainflip.getInternalAssets(args, false);
|
|
270
136
|
let hadError = false;
|
|
271
137
|
if (srcAsset === null) {
|
|
272
138
|
ctx.addIssue({
|
|
273
139
|
message: `invalid asset and chain combination: ${JSON.stringify({ asset: args.srcAsset, chain: args.srcChain })}`,
|
|
274
|
-
code:
|
|
140
|
+
code: zod.z.ZodIssueCode.custom
|
|
275
141
|
});
|
|
276
142
|
hadError = true;
|
|
277
143
|
}
|
|
278
144
|
if (destAsset === null) {
|
|
279
145
|
ctx.addIssue({
|
|
280
146
|
message: `invalid asset and chain combination: ${JSON.stringify({ asset: args.destAsset, chain: args.destChain })}`,
|
|
281
|
-
code:
|
|
147
|
+
code: zod.z.ZodIssueCode.custom
|
|
282
148
|
});
|
|
283
149
|
hadError = true;
|
|
284
150
|
}
|
|
285
151
|
if (args.ccmGasBudget !== void 0 && args.ccmMessageLengthBytes === void 0) {
|
|
286
152
|
ctx.addIssue({
|
|
287
153
|
message: `ccmMessageLengthBytes must be set if ccmGasBudget is set`,
|
|
288
|
-
code:
|
|
154
|
+
code: zod.z.ZodIssueCode.custom
|
|
289
155
|
});
|
|
290
156
|
hadError = true;
|
|
291
157
|
}
|
|
292
158
|
if (args.ccmGasBudget === void 0 && args.ccmMessageLengthBytes !== void 0) {
|
|
293
159
|
ctx.addIssue({
|
|
294
160
|
message: `ccmGasBudget must be set if ccmMessageLengthBytes is set`,
|
|
295
|
-
code:
|
|
161
|
+
code: zod.z.ZodIssueCode.custom
|
|
296
162
|
});
|
|
297
163
|
hadError = true;
|
|
298
164
|
}
|
|
299
165
|
if (args.isOnChain && args.isVaultSwap) {
|
|
300
166
|
ctx.addIssue({
|
|
301
167
|
message: "isOnChain and isVaultSwap cannot be set at the same time",
|
|
302
|
-
code:
|
|
168
|
+
code: zod.z.ZodIssueCode.custom
|
|
303
169
|
});
|
|
304
170
|
hadError = true;
|
|
305
171
|
}
|
|
306
172
|
if (args.isVaultSwap && args.srcChain === "Assethub") {
|
|
307
173
|
ctx.addIssue({
|
|
308
174
|
message: "Vault swaps are not supported on Assethub",
|
|
309
|
-
code:
|
|
175
|
+
code: zod.z.ZodIssueCode.custom
|
|
310
176
|
});
|
|
311
177
|
hadError = true;
|
|
312
178
|
}
|
|
313
179
|
if (args.isOnChain && args.brokerCommissionBps !== void 0 && args.brokerCommissionBps > 0) {
|
|
314
180
|
ctx.addIssue({
|
|
315
181
|
message: "isOnChain cannot be set with a non-zero broker commission",
|
|
316
|
-
code:
|
|
182
|
+
code: zod.z.ZodIssueCode.custom
|
|
317
183
|
});
|
|
318
184
|
hadError = true;
|
|
319
185
|
}
|
|
320
|
-
if (hadError) return
|
|
186
|
+
if (hadError) return zod.z.NEVER;
|
|
321
187
|
const ccmParams = args.ccmGasBudget !== void 0 && args.ccmMessageLengthBytes !== void 0 ? { gasBudget: args.ccmGasBudget, messageLengthBytes: args.ccmMessageLengthBytes } : void 0;
|
|
322
188
|
return {
|
|
323
189
|
srcAsset,
|
|
@@ -332,8 +198,8 @@ z3.z.object({
|
|
|
332
198
|
expectedResponseTimeMs: args.expectedResponseTimeMs
|
|
333
199
|
};
|
|
334
200
|
});
|
|
335
|
-
var ccmParamsSchema =
|
|
336
|
-
gasBudget:
|
|
201
|
+
var ccmParamsSchema = zod.z.object({
|
|
202
|
+
gasBudget: zod.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) => number.hexEncodeNumber(n)),
|
|
337
203
|
// https://github.com/chainflip-io/chainflip-backend/blob/415aa9e20ec4046c68892cd34798e5d831c5b83f/state-chain/chains/src/lib.rs#L709
|
|
338
204
|
message: hexStringWithMaxByteSize(15e3),
|
|
339
205
|
// https://github.com/chainflip-io/chainflip-backend/blob/415aa9e20ec4046c68892cd34798e5d831c5b83f/state-chain/chains/src/lib.rs#L710
|
|
@@ -343,93 +209,97 @@ var ccmParamsSchema = z3.z.object({
|
|
|
343
209
|
message,
|
|
344
210
|
ccmAdditionalData: ccmAdditionalData ?? "0x"
|
|
345
211
|
}));
|
|
346
|
-
var affiliateBroker =
|
|
212
|
+
var affiliateBroker = zod.z.object({
|
|
347
213
|
account: chainflipAddress,
|
|
348
|
-
commissionBps:
|
|
214
|
+
commissionBps: u16
|
|
349
215
|
}).transform(({ account, commissionBps: bps }) => ({ account, bps }));
|
|
350
|
-
var dcaParams =
|
|
351
|
-
numberOfChunks:
|
|
352
|
-
chunkIntervalBlocks:
|
|
216
|
+
var dcaParams = zod.z.object({
|
|
217
|
+
numberOfChunks: u32.min(1, { message: "number of chunks must be greater than 0" }),
|
|
218
|
+
chunkIntervalBlocks: u32
|
|
353
219
|
});
|
|
354
|
-
|
|
355
|
-
retryDurationBlocks:
|
|
356
|
-
refundAddress:
|
|
220
|
+
zod.z.object({
|
|
221
|
+
retryDurationBlocks: u32,
|
|
222
|
+
refundAddress: zod.z.string(),
|
|
357
223
|
minPriceX128: numericString,
|
|
358
224
|
maxOraclePriceSlippage: basisPoints.nullish().transform((v) => v ?? null),
|
|
359
225
|
refundCcmMetadata: ccmParamsSchema.nullish().optional().default(null)
|
|
360
226
|
});
|
|
361
227
|
|
|
362
|
-
// ../shared/src/
|
|
363
|
-
var
|
|
364
|
-
|
|
365
|
-
|
|
366
|
-
|
|
367
|
-
|
|
368
|
-
|
|
369
|
-
assets,
|
|
370
|
-
z3.z.object({
|
|
371
|
-
destAddress: z3.z.string(),
|
|
372
|
-
amount: amountString,
|
|
373
|
-
ccmParams: ccmParamsSchema.optional(),
|
|
374
|
-
maxBoostFeeBps: z3.z.number().optional(),
|
|
375
|
-
srcAddress: z3.z.string().optional(),
|
|
376
|
-
fillOrKillParams,
|
|
377
|
-
dcaParams: dcaParams.optional(),
|
|
378
|
-
quote: z3.z.object({
|
|
379
|
-
intermediateAmount: amountString.optional(),
|
|
380
|
-
egressAmount: amountString,
|
|
381
|
-
estimatedPrice: z3.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" }),
|
|
382
|
-
recommendedSlippageTolerancePercent: z3.z.number().optional(),
|
|
383
|
-
recommendedLivePriceSlippageTolerancePercent: z3.z.number().optional()
|
|
384
|
-
}).optional(),
|
|
385
|
-
takeCommission: z3.z.boolean().optional()
|
|
386
|
-
})
|
|
387
|
-
).superRefine(({ ...val }, ctx) => {
|
|
388
|
-
if (!validateAddress(val.destAsset.chain, val.destAddress, network)) {
|
|
389
|
-
ctx.addIssue({
|
|
390
|
-
message: `Address "${val.destAddress}" is not a valid "${val.destAsset.chain}" address for "${network}"`,
|
|
391
|
-
code: z3.z.ZodIssueCode.custom
|
|
392
|
-
});
|
|
393
|
-
}
|
|
394
|
-
if (!validateAddress(val.srcAsset.chain, val.fillOrKillParams.refundAddress, network)) {
|
|
395
|
-
ctx.addIssue({
|
|
396
|
-
message: `Address "${val.fillOrKillParams.refundAddress}" is not a valid "${val.srcAsset.chain}" address for "${network}"`,
|
|
397
|
-
code: z3.z.ZodIssueCode.custom
|
|
398
|
-
});
|
|
228
|
+
// ../shared/src/guards.ts
|
|
229
|
+
var isNotNullish = (value) => value !== null && value !== void 0;
|
|
230
|
+
function assert(condition, message, Constructor = Error) {
|
|
231
|
+
if (condition) return;
|
|
232
|
+
const error = new Constructor(message);
|
|
233
|
+
if (error.stack) {
|
|
234
|
+
error.stack = error.stack.replace(/\n.+/, "\n");
|
|
399
235
|
}
|
|
400
|
-
|
|
401
|
-
|
|
402
|
-
expectedDepositAmount: amount
|
|
403
|
-
}));
|
|
404
|
-
var DepositChannelInfo = z3.z.object({
|
|
405
|
-
id: z3.z.string(),
|
|
406
|
-
depositAddress: z3.z.string(),
|
|
407
|
-
brokerCommissionBps: z3.z.number(),
|
|
408
|
-
maxBoostFeeBps: z3.z.number(),
|
|
409
|
-
issuedBlock: z3.z.number(),
|
|
410
|
-
srcChainExpiryBlock: z3.z.string(),
|
|
411
|
-
estimatedExpiryTime: z3.z.number().optional(),
|
|
412
|
-
channelOpeningFee: z3.z.string()
|
|
413
|
-
});
|
|
414
|
-
|
|
415
|
-
// ../shared/src/strings.ts
|
|
416
|
-
var toCamelCase = (str) => str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
|
|
236
|
+
throw error;
|
|
237
|
+
}
|
|
417
238
|
|
|
418
|
-
// ../shared/src/
|
|
419
|
-
var
|
|
420
|
-
if (
|
|
421
|
-
|
|
239
|
+
// ../shared/src/validation/addressValidation.ts
|
|
240
|
+
var validatePolkadotAddress = (address) => {
|
|
241
|
+
if (string.isHex(address)) return address.length === 66;
|
|
242
|
+
try {
|
|
243
|
+
ss58__namespace.decode(address);
|
|
244
|
+
return true;
|
|
245
|
+
} catch {
|
|
246
|
+
return false;
|
|
422
247
|
}
|
|
423
|
-
|
|
424
|
-
|
|
425
|
-
|
|
426
|
-
|
|
427
|
-
|
|
428
|
-
|
|
429
|
-
|
|
248
|
+
};
|
|
249
|
+
var validateEvmAddress = (address) => ethers__namespace.isAddress(address);
|
|
250
|
+
var validateBitcoinMainnetAddress = (address) => bitcoin__namespace.isValidAddressForNetwork(address, "mainnet");
|
|
251
|
+
var validateBitcoinTestnetAddress = (address) => bitcoin__namespace.isValidAddressForNetwork(address, "testnet");
|
|
252
|
+
var validateBitcoinRegtestAddress = (address) => bitcoin__namespace.isValidAddressForNetwork(address, "regtest");
|
|
253
|
+
var validateSolanaAddress = solana.isValidSolanaAddress;
|
|
254
|
+
var validateTronAddress = tron.isValidTronAddress;
|
|
255
|
+
var validators = {
|
|
256
|
+
mainnet: {
|
|
257
|
+
Bitcoin: validateBitcoinMainnetAddress,
|
|
258
|
+
Ethereum: validateEvmAddress,
|
|
259
|
+
Arbitrum: validateEvmAddress,
|
|
260
|
+
Solana: validateSolanaAddress,
|
|
261
|
+
Assethub: validatePolkadotAddress,
|
|
262
|
+
Tron: validateTronAddress,
|
|
263
|
+
Bsc: validateEvmAddress
|
|
264
|
+
},
|
|
265
|
+
perseverance: {
|
|
266
|
+
Bitcoin: validateBitcoinTestnetAddress,
|
|
267
|
+
Ethereum: validateEvmAddress,
|
|
268
|
+
Arbitrum: validateEvmAddress,
|
|
269
|
+
Solana: validateSolanaAddress,
|
|
270
|
+
Assethub: validatePolkadotAddress,
|
|
271
|
+
Tron: validateTronAddress,
|
|
272
|
+
Bsc: validateEvmAddress
|
|
273
|
+
},
|
|
274
|
+
sisyphos: {
|
|
275
|
+
Bitcoin: validateBitcoinTestnetAddress,
|
|
276
|
+
Ethereum: validateEvmAddress,
|
|
277
|
+
Arbitrum: validateEvmAddress,
|
|
278
|
+
Solana: validateSolanaAddress,
|
|
279
|
+
Assethub: validatePolkadotAddress,
|
|
280
|
+
Tron: validateTronAddress,
|
|
281
|
+
Bsc: validateEvmAddress
|
|
282
|
+
},
|
|
283
|
+
backspin: {
|
|
284
|
+
Bitcoin: validateBitcoinRegtestAddress,
|
|
285
|
+
Ethereum: validateEvmAddress,
|
|
286
|
+
Arbitrum: validateEvmAddress,
|
|
287
|
+
Solana: validateSolanaAddress,
|
|
288
|
+
Assethub: validatePolkadotAddress,
|
|
289
|
+
Tron: validateTronAddress,
|
|
290
|
+
Bsc: validateEvmAddress
|
|
291
|
+
},
|
|
292
|
+
localnet: {
|
|
293
|
+
Bitcoin: validateBitcoinRegtestAddress,
|
|
294
|
+
Ethereum: validateEvmAddress,
|
|
295
|
+
Arbitrum: validateEvmAddress,
|
|
296
|
+
Solana: validateSolanaAddress,
|
|
297
|
+
Assethub: validatePolkadotAddress,
|
|
298
|
+
Tron: validateTronAddress,
|
|
299
|
+
Bsc: validateEvmAddress
|
|
430
300
|
}
|
|
431
|
-
return obj;
|
|
432
301
|
};
|
|
302
|
+
var validateAddress = (chain2, address, network) => Object.hasOwn(validators, network) && Object.hasOwn(validators[network], chain2) && validators[network][chain2](address);
|
|
433
303
|
|
|
434
304
|
// ../shared/src/broker.ts
|
|
435
305
|
var transformedDcaParamsSchema = dcaParams.transform(
|
|
@@ -445,9 +315,9 @@ var transformedCcmParamsSchema = ccmParamsSchema.transform(
|
|
|
445
315
|
ccm_additional_data: ccmAdditionalData
|
|
446
316
|
})
|
|
447
317
|
);
|
|
448
|
-
var transformedFokSchema =
|
|
449
|
-
retryDurationBlocks:
|
|
450
|
-
refundAddress:
|
|
318
|
+
var transformedFokSchema = zod.z.object({
|
|
319
|
+
retryDurationBlocks: u32,
|
|
320
|
+
refundAddress: zod.z.string(),
|
|
451
321
|
minPriceX128: numericString,
|
|
452
322
|
maxOraclePriceSlippage: basisPoints.nullish().transform((v) => v ?? null),
|
|
453
323
|
refundCcmMetadata: transformedCcmParamsSchema.nullable().optional().default(null)
|
|
@@ -466,67 +336,67 @@ var transformedFokSchema = z3.z.object({
|
|
|
466
336
|
refund_ccm_metadata: refundCcmMetadata
|
|
467
337
|
})
|
|
468
338
|
);
|
|
469
|
-
var getDepositAddressRequestSchema = (network) =>
|
|
339
|
+
var getDepositAddressRequestSchema = (network) => zod.z.object({
|
|
470
340
|
srcAsset: assetAndChain,
|
|
471
341
|
destAsset: assetAndChain,
|
|
472
|
-
destAddress:
|
|
473
|
-
commissionBps:
|
|
342
|
+
destAddress: zod.z.string(),
|
|
343
|
+
commissionBps: u16.optional().default(0),
|
|
474
344
|
ccmParams: transformedCcmParamsSchema.optional(),
|
|
475
|
-
maxBoostFeeBps:
|
|
476
|
-
affiliates:
|
|
345
|
+
maxBoostFeeBps: u16.optional(),
|
|
346
|
+
affiliates: zod.z.array(affiliateBroker).optional(),
|
|
477
347
|
fillOrKillParams: transformedFokSchema,
|
|
478
348
|
dcaParams: transformedDcaParamsSchema.optional()
|
|
479
349
|
}).superRefine((val, ctx) => {
|
|
480
350
|
if (!validateAddress(val.destAsset.chain, val.destAddress, network)) {
|
|
481
351
|
ctx.addIssue({
|
|
482
352
|
message: `Address "${val.destAddress}" is not a valid "${val.destAsset.chain}" address for "${network}"`,
|
|
483
|
-
code:
|
|
353
|
+
code: zod.z.ZodIssueCode.custom
|
|
484
354
|
});
|
|
485
355
|
}
|
|
486
356
|
if (!validateAddress(val.srcAsset.chain, val.fillOrKillParams.refund_address, network)) {
|
|
487
357
|
ctx.addIssue({
|
|
488
358
|
message: `Address "${val.fillOrKillParams.refund_address}" is not a valid "${val.srcAsset.chain}" address for "${network}"`,
|
|
489
|
-
code:
|
|
359
|
+
code: zod.z.ZodIssueCode.custom
|
|
490
360
|
});
|
|
491
361
|
}
|
|
492
362
|
});
|
|
493
|
-
var getVaultSwapParameterEncodingRequestSchema = (network) =>
|
|
363
|
+
var getVaultSwapParameterEncodingRequestSchema = (network) => zod.z.object({
|
|
494
364
|
srcAsset: assetAndChain,
|
|
495
|
-
srcAddress:
|
|
365
|
+
srcAddress: zod.z.string().optional(),
|
|
496
366
|
destAsset: assetAndChain,
|
|
497
|
-
destAddress:
|
|
367
|
+
destAddress: zod.z.string(),
|
|
498
368
|
amount: unsignedInteger,
|
|
499
|
-
commissionBps:
|
|
369
|
+
commissionBps: u16.optional().default(0),
|
|
500
370
|
ccmParams: transformedCcmParamsSchema.optional(),
|
|
501
|
-
maxBoostFeeBps:
|
|
502
|
-
affiliates:
|
|
371
|
+
maxBoostFeeBps: u16.optional(),
|
|
372
|
+
affiliates: zod.z.array(affiliateBroker).optional(),
|
|
503
373
|
fillOrKillParams: transformedFokSchema,
|
|
504
374
|
dcaParams: transformedDcaParamsSchema.optional(),
|
|
505
|
-
extraParams:
|
|
375
|
+
extraParams: zod.z.object({ seed: hexString.optional() }).optional(),
|
|
506
376
|
brokerAccount: chainflipAddress.optional()
|
|
507
377
|
}).superRefine((val, ctx) => {
|
|
508
378
|
if (val.srcAddress && !validateAddress(val.srcAsset.chain, val.srcAddress, network)) {
|
|
509
379
|
ctx.addIssue({
|
|
510
380
|
message: `Address "${val.srcAddress}" is not a valid "${val.srcAsset.chain}" address for "${network}"`,
|
|
511
|
-
code:
|
|
381
|
+
code: zod.z.ZodIssueCode.custom
|
|
512
382
|
});
|
|
513
383
|
}
|
|
514
384
|
if (!validateAddress(val.destAsset.chain, val.destAddress, network)) {
|
|
515
385
|
ctx.addIssue({
|
|
516
386
|
message: `Address "${val.destAddress}" is not a valid "${val.destAsset.chain}" address for "${network}"`,
|
|
517
|
-
code:
|
|
387
|
+
code: zod.z.ZodIssueCode.custom
|
|
518
388
|
});
|
|
519
389
|
}
|
|
520
390
|
if (!validateAddress(val.srcAsset.chain, val.fillOrKillParams.refund_address, network)) {
|
|
521
391
|
ctx.addIssue({
|
|
522
392
|
message: `Address "${val.fillOrKillParams.refund_address}" is not a valid "${val.srcAsset.chain}" address for "${network}"`,
|
|
523
|
-
code:
|
|
393
|
+
code: zod.z.ZodIssueCode.custom
|
|
524
394
|
});
|
|
525
395
|
}
|
|
526
396
|
if (val.extraParams?.seed && val.extraParams.seed.length !== 66) {
|
|
527
|
-
ctx.addIssue({ message: "Seed must be 32 bytes", code:
|
|
397
|
+
ctx.addIssue({ message: "Seed must be 32 bytes", code: zod.z.ZodIssueCode.custom });
|
|
528
398
|
}
|
|
529
|
-
}).transform((data) => {
|
|
399
|
+
}).transform((data, ctx) => {
|
|
530
400
|
let extraParams;
|
|
531
401
|
if (data.srcAsset.chain === "Bitcoin") {
|
|
532
402
|
const minOutputAmount = BigNumber2__default.default(data.amount.toString()).multipliedBy(tickMath.priceX128ToPrice(data.fillOrKillParams.min_price)).toFixed(0);
|
|
@@ -543,7 +413,13 @@ var getVaultSwapParameterEncodingRequestSchema = (network) => z3.z.object({
|
|
|
543
413
|
refund_parameters: data.fillOrKillParams
|
|
544
414
|
};
|
|
545
415
|
} else if (data.srcAsset.chain === "Solana") {
|
|
546
|
-
|
|
416
|
+
if (!data.srcAddress) {
|
|
417
|
+
ctx.addIssue({
|
|
418
|
+
message: "srcAddress is required for Solana",
|
|
419
|
+
code: zod.z.ZodIssueCode.custom
|
|
420
|
+
});
|
|
421
|
+
return zod.z.NEVER;
|
|
422
|
+
}
|
|
547
423
|
extraParams = {
|
|
548
424
|
chain: "Solana",
|
|
549
425
|
from: data.srcAddress,
|
|
@@ -552,7 +428,11 @@ var getVaultSwapParameterEncodingRequestSchema = (network) => z3.z.object({
|
|
|
552
428
|
refund_parameters: data.fillOrKillParams
|
|
553
429
|
};
|
|
554
430
|
} else {
|
|
555
|
-
|
|
431
|
+
ctx.addIssue({
|
|
432
|
+
message: `parameter encoding is not supported for ${data.srcAsset.chain}`,
|
|
433
|
+
code: zod.z.ZodIssueCode.custom
|
|
434
|
+
});
|
|
435
|
+
return zod.z.NEVER;
|
|
556
436
|
}
|
|
557
437
|
return { ...data, extraParams };
|
|
558
438
|
});
|
|
@@ -606,16 +486,16 @@ async function requestSwapParameterEncoding(request, opts, chainflipNetwork) {
|
|
|
606
486
|
);
|
|
607
487
|
return transformKeysToCamelCase(response);
|
|
608
488
|
}
|
|
609
|
-
var getParameterEncodingRequestSchema = (network) =>
|
|
489
|
+
var getParameterEncodingRequestSchema = (network) => zod.z.object({
|
|
610
490
|
srcAsset: assetAndChain,
|
|
611
|
-
srcAddress:
|
|
491
|
+
srcAddress: zod.z.string().optional(),
|
|
612
492
|
destAsset: assetAndChain,
|
|
613
|
-
destAddress:
|
|
493
|
+
destAddress: zod.z.string(),
|
|
614
494
|
amount: unsignedInteger,
|
|
615
|
-
commissionBps:
|
|
495
|
+
commissionBps: u16.optional().default(0),
|
|
616
496
|
ccmParams: transformedCcmParamsSchema.optional(),
|
|
617
|
-
maxBoostFeeBps:
|
|
618
|
-
affiliates:
|
|
497
|
+
maxBoostFeeBps: u16.optional(),
|
|
498
|
+
affiliates: zod.z.array(affiliateBroker).optional(),
|
|
619
499
|
fillOrKillParams: transformedFokSchema,
|
|
620
500
|
dcaParams: transformedDcaParamsSchema.optional(),
|
|
621
501
|
brokerAccount: chainflipAddress.optional()
|
|
@@ -623,19 +503,19 @@ var getParameterEncodingRequestSchema = (network) => z3.z.object({
|
|
|
623
503
|
if (val.srcAddress && !validateAddress(val.srcAsset.chain, val.srcAddress, network)) {
|
|
624
504
|
ctx.addIssue({
|
|
625
505
|
message: `Address "${val.srcAddress}" is not a valid "${val.srcAsset.chain}" address for "${network}"`,
|
|
626
|
-
code:
|
|
506
|
+
code: zod.z.ZodIssueCode.custom
|
|
627
507
|
});
|
|
628
508
|
}
|
|
629
509
|
if (!validateAddress(val.destAsset.chain, val.destAddress, network)) {
|
|
630
510
|
ctx.addIssue({
|
|
631
511
|
message: `Address "${val.destAddress}" is not a valid "${val.destAsset.chain}" address for "${network}"`,
|
|
632
|
-
code:
|
|
512
|
+
code: zod.z.ZodIssueCode.custom
|
|
633
513
|
});
|
|
634
514
|
}
|
|
635
515
|
if (!validateAddress(val.srcAsset.chain, val.fillOrKillParams.refund_address, network)) {
|
|
636
516
|
ctx.addIssue({
|
|
637
517
|
message: `Address "${val.fillOrKillParams.refund_address}" is not a valid "${val.srcAsset.chain}" address for "${network}"`,
|
|
638
|
-
code:
|
|
518
|
+
code: zod.z.ZodIssueCode.custom
|
|
639
519
|
});
|
|
640
520
|
}
|
|
641
521
|
}).transform(({ ...rest }) => rest);
|
|
@@ -657,56 +537,6 @@ async function requestCfParametersEncoding(request, opts, network) {
|
|
|
657
537
|
return response;
|
|
658
538
|
}
|
|
659
539
|
|
|
660
|
-
// ../shared/src/api/contract.ts
|
|
661
|
-
var c = core.initContract();
|
|
662
|
-
var createApiContract = (network) => c.router(
|
|
663
|
-
{
|
|
664
|
-
networkInfo: {
|
|
665
|
-
method: "GET",
|
|
666
|
-
path: "/networkInfo",
|
|
667
|
-
responses: {
|
|
668
|
-
200: NetworkInfo
|
|
669
|
-
},
|
|
670
|
-
summary: "Get information about the Chainflip network"
|
|
671
|
-
},
|
|
672
|
-
encodeCfParameters: {
|
|
673
|
-
method: "POST",
|
|
674
|
-
path: "/encodeCfParameters",
|
|
675
|
-
body: getParameterEncodingRequestSchema(network),
|
|
676
|
-
responses: {
|
|
677
|
-
200: hexString
|
|
678
|
-
}
|
|
679
|
-
},
|
|
680
|
-
encodeVaultSwapData: {
|
|
681
|
-
method: "POST",
|
|
682
|
-
path: "/encodeVaultSwapData",
|
|
683
|
-
body: getVaultSwapParameterEncodingRequestSchema(network),
|
|
684
|
-
responses: {
|
|
685
|
-
200: EncodedVaultSwapData
|
|
686
|
-
}
|
|
687
|
-
},
|
|
688
|
-
openSwapDepositChannel: {
|
|
689
|
-
method: "POST",
|
|
690
|
-
path: "/openSwapDepositChannel",
|
|
691
|
-
body: getOpenSwapDepositChannelSchema(network),
|
|
692
|
-
responses: {
|
|
693
|
-
201: DepositChannelInfo
|
|
694
|
-
}
|
|
695
|
-
},
|
|
696
|
-
openAccountCreationDepositChannel: {
|
|
697
|
-
method: "POST",
|
|
698
|
-
path: "/openAccountCreationDepositChannel",
|
|
699
|
-
body: getAccountCreationDepositChannelSchema(network),
|
|
700
|
-
responses: {
|
|
701
|
-
201: DepositChannelInfo
|
|
702
|
-
}
|
|
703
|
-
}
|
|
704
|
-
},
|
|
705
|
-
{
|
|
706
|
-
pathPrefix: "/api"
|
|
707
|
-
}
|
|
708
|
-
);
|
|
709
|
-
|
|
710
540
|
// ../shared/src/consts.ts
|
|
711
541
|
var ETHEREUM_EVM_CHAIN_ID = {
|
|
712
542
|
backspin: 10997,
|
|
@@ -833,12 +663,12 @@ var MultiCache = class {
|
|
|
833
663
|
}
|
|
834
664
|
values = {};
|
|
835
665
|
read(type) {
|
|
836
|
-
const { fetch, ttl } = this.fetchers[type];
|
|
666
|
+
const { fetch: fetch2, ttl } = this.fetchers[type];
|
|
837
667
|
let cached = this.values[type];
|
|
838
668
|
if (!cached || cached.timestamp + ttl < Date.now()) {
|
|
839
669
|
cached = {
|
|
840
670
|
timestamp: Date.now(),
|
|
841
|
-
value:
|
|
671
|
+
value: fetch2().catch((err) => {
|
|
842
672
|
this.values[type] = void 0;
|
|
843
673
|
throw err;
|
|
844
674
|
})
|
|
@@ -1009,7 +839,7 @@ var getChainData = (chain2, network, env) => ({
|
|
|
1009
839
|
|
|
1010
840
|
// package.json
|
|
1011
841
|
var package_default = {
|
|
1012
|
-
version: "2.3.
|
|
842
|
+
version: "2.3.3"};
|
|
1013
843
|
|
|
1014
844
|
// src/swap/consts.ts
|
|
1015
845
|
var CF_SDK_VERSION_HEADERS = { "X-Chainflip-Sdk-Version": package_default.version };
|
|
@@ -1057,6 +887,59 @@ var getStatusV2 = async (baseUrl, { id }, { signal }) => {
|
|
|
1057
887
|
});
|
|
1058
888
|
return data;
|
|
1059
889
|
};
|
|
890
|
+
var lowercaseKeys = (headers) => Object.fromEntries(Object.entries(headers).map(([key, value]) => [key.toLowerCase(), value]));
|
|
891
|
+
var backendRequest = async (baseUrl, method, path, body) => {
|
|
892
|
+
const headers = lowercaseKeys(CF_SDK_VERSION_HEADERS);
|
|
893
|
+
let serializedBody;
|
|
894
|
+
if (method !== "GET" && body != null) {
|
|
895
|
+
headers["content-type"] = "application/json";
|
|
896
|
+
serializedBody = JSON.stringify(body);
|
|
897
|
+
}
|
|
898
|
+
const res = await fetch(`${baseUrl.replace(/\/+$/, "")}${path}`, {
|
|
899
|
+
method,
|
|
900
|
+
headers,
|
|
901
|
+
body: serializedBody
|
|
902
|
+
});
|
|
903
|
+
const contentType = res.headers.get("content-type") ?? "";
|
|
904
|
+
if (contentType.includes("application/") && contentType.includes("json")) {
|
|
905
|
+
return { status: res.status, body: await res.json(), headers: res.headers };
|
|
906
|
+
}
|
|
907
|
+
if (contentType.includes("text/")) {
|
|
908
|
+
return { status: res.status, body: await res.text(), headers: res.headers };
|
|
909
|
+
}
|
|
910
|
+
return { status: res.status, body: await res.blob(), headers: res.headers };
|
|
911
|
+
};
|
|
912
|
+
var getNetworkInfo = async (baseUrl) => {
|
|
913
|
+
const res = await backendRequest(baseUrl, "GET", "/api/networkInfo");
|
|
914
|
+
assert(res.status === 200, "Failed to fetch network info");
|
|
915
|
+
return res.body;
|
|
916
|
+
};
|
|
917
|
+
var openSwapDepositChannel = async (baseUrl, body) => {
|
|
918
|
+
const res = await backendRequest(baseUrl, "POST", "/api/openSwapDepositChannel", body);
|
|
919
|
+
assert(res.status === 201, "Failed to open swap deposit channel");
|
|
920
|
+
return res.body;
|
|
921
|
+
};
|
|
922
|
+
var encodeVaultSwapData = async (baseUrl, body) => {
|
|
923
|
+
const res = await backendRequest(baseUrl, "POST", "/api/encodeVaultSwapData", body);
|
|
924
|
+
if (res.status !== 200) {
|
|
925
|
+
throw new Error("Failed to encode vault swap data", { cause: res });
|
|
926
|
+
}
|
|
927
|
+
return res.body;
|
|
928
|
+
};
|
|
929
|
+
var encodeCfParameters = async (baseUrl, body) => {
|
|
930
|
+
const res = await backendRequest(baseUrl, "POST", "/api/encodeCfParameters", body);
|
|
931
|
+
if (res.status !== 200) {
|
|
932
|
+
throw new Error("Failed to encode cf parameters", { cause: res });
|
|
933
|
+
}
|
|
934
|
+
return res.body;
|
|
935
|
+
};
|
|
936
|
+
var openAccountCreationDepositChannel = async (baseUrl, body) => {
|
|
937
|
+
const res = await backendRequest(baseUrl, "POST", "/api/openAccountCreationDepositChannel", body);
|
|
938
|
+
if (res.status !== 201) {
|
|
939
|
+
throw new Error("Failed to request account creation deposit channel", { cause: res });
|
|
940
|
+
}
|
|
941
|
+
return res.body;
|
|
942
|
+
};
|
|
1060
943
|
|
|
1061
944
|
// src/swap/sdk.ts
|
|
1062
945
|
var assertQuoteValid = (quote) => {
|
|
@@ -1073,7 +956,6 @@ var assertQuoteValid = (quote) => {
|
|
|
1073
956
|
var SwapSDK = class {
|
|
1074
957
|
options;
|
|
1075
958
|
rpcConfig;
|
|
1076
|
-
apiClient;
|
|
1077
959
|
cache;
|
|
1078
960
|
dcaV2Enabled = false;
|
|
1079
961
|
constructor(options = {}) {
|
|
@@ -1084,12 +966,6 @@ var SwapSDK = class {
|
|
|
1084
966
|
backendUrl: options.backendUrl ?? BACKEND_SERVICE_URLS[network]
|
|
1085
967
|
};
|
|
1086
968
|
this.rpcConfig = options.rpcUrl ? { rpcUrl: options.rpcUrl } : { network };
|
|
1087
|
-
this.apiClient = core.initClient(createApiContract(this.options.network), {
|
|
1088
|
-
// remove trailing slashes. this bug has been fixed in `@ts-rest/core`
|
|
1089
|
-
// but it hasn't been released yet
|
|
1090
|
-
baseUrl: this.options.backendUrl.replace(/\/+$/, ""),
|
|
1091
|
-
baseHeaders: CF_SDK_VERSION_HEADERS
|
|
1092
|
-
});
|
|
1093
969
|
this.dcaV2Enabled = options.enabledFeatures?.dcaV2 ?? false;
|
|
1094
970
|
this.cache = new MultiCache({
|
|
1095
971
|
environment: {
|
|
@@ -1097,11 +973,7 @@ var SwapSDK = class {
|
|
|
1097
973
|
ttl: 6e4
|
|
1098
974
|
},
|
|
1099
975
|
networkInfo: {
|
|
1100
|
-
fetch:
|
|
1101
|
-
const res = await this.apiClient.networkInfo();
|
|
1102
|
-
assert(res.status === 200, "Failed to fetch network info");
|
|
1103
|
-
return res.body;
|
|
1104
|
-
},
|
|
976
|
+
fetch: () => getNetworkInfo(this.options.backendUrl),
|
|
1105
977
|
ttl: 6e4
|
|
1106
978
|
}
|
|
1107
979
|
});
|
|
@@ -1122,8 +994,8 @@ var SwapSDK = class {
|
|
|
1122
994
|
return this.cache.read("environment");
|
|
1123
995
|
}
|
|
1124
996
|
async getSupportedAssets(type) {
|
|
1125
|
-
const
|
|
1126
|
-
return
|
|
997
|
+
const assets = await this.cache.read("networkInfo");
|
|
998
|
+
return assets.assets.filter((a) => chainflip.isChainflipAsset(a.asset)).filter((a) => {
|
|
1127
999
|
switch (type) {
|
|
1128
1000
|
case "all":
|
|
1129
1001
|
return true;
|
|
@@ -1305,15 +1177,11 @@ var SwapSDK = class {
|
|
|
1305
1177
|
!affiliates?.length,
|
|
1306
1178
|
"Affiliate brokers are supported only when initializing the SDK with a brokerUrl"
|
|
1307
1179
|
);
|
|
1308
|
-
|
|
1309
|
-
|
|
1310
|
-
|
|
1311
|
-
|
|
1312
|
-
takeCommission: this.shouldTakeCommission()
|
|
1313
|
-
}
|
|
1180
|
+
response = await openSwapDepositChannel(this.options.backendUrl, {
|
|
1181
|
+
...depositAddressRequest,
|
|
1182
|
+
quote,
|
|
1183
|
+
takeCommission: this.shouldTakeCommission()
|
|
1314
1184
|
});
|
|
1315
|
-
assert(res.status === 201, "Failed to open swap deposit channel");
|
|
1316
|
-
response = res.body;
|
|
1317
1185
|
}
|
|
1318
1186
|
return {
|
|
1319
1187
|
...depositAddressRequest,
|
|
@@ -1386,18 +1254,15 @@ var SwapSDK = class {
|
|
|
1386
1254
|
!vaultSwapRequest.affiliates?.length || vaultSwapRequest.brokerAccount,
|
|
1387
1255
|
"Affiliate brokers are supported only when setting a broker account"
|
|
1388
1256
|
);
|
|
1389
|
-
const
|
|
1390
|
-
|
|
1391
|
-
throw new Error("Failed to encode vault swap data", { cause: res });
|
|
1392
|
-
}
|
|
1393
|
-
switch (res.body.chain) {
|
|
1257
|
+
const body = await encodeVaultSwapData(this.options.backendUrl, vaultSwapRequest);
|
|
1258
|
+
switch (body.chain) {
|
|
1394
1259
|
case "Arbitrum":
|
|
1395
1260
|
case "Ethereum":
|
|
1396
1261
|
case "Tron":
|
|
1397
1262
|
case "Bsc":
|
|
1398
|
-
return { ...
|
|
1263
|
+
return { ...body, value: BigInt(body.value) };
|
|
1399
1264
|
default:
|
|
1400
|
-
return
|
|
1265
|
+
return body;
|
|
1401
1266
|
}
|
|
1402
1267
|
}
|
|
1403
1268
|
async encodeCfParameters({
|
|
@@ -1449,32 +1314,23 @@ var SwapSDK = class {
|
|
|
1449
1314
|
!requestParams.affiliates?.length || brokerAccount,
|
|
1450
1315
|
"Affiliate brokers are supported only when setting a broker account"
|
|
1451
1316
|
);
|
|
1452
|
-
|
|
1453
|
-
|
|
1317
|
+
return encodeCfParameters(this.options.backendUrl, {
|
|
1318
|
+
...requestParams,
|
|
1319
|
+
brokerAccount
|
|
1454
1320
|
});
|
|
1455
|
-
if (res.status !== 200) {
|
|
1456
|
-
throw new Error("Failed to encode cf parameters", { cause: res });
|
|
1457
|
-
}
|
|
1458
|
-
return res.body;
|
|
1459
1321
|
}
|
|
1460
1322
|
async checkBoostEnabled() {
|
|
1461
|
-
const { assets
|
|
1462
|
-
return
|
|
1323
|
+
const { assets } = await this.cache.read("networkInfo");
|
|
1324
|
+
return assets.find((a) => a.asset === "Btc")?.boostDepositsEnabled ?? true;
|
|
1463
1325
|
}
|
|
1464
1326
|
async requestAccountCreationDepositAddress(asset2, refundAddress, signatureData, transactionMetadata, boostFeeBps = 0) {
|
|
1465
|
-
|
|
1466
|
-
|
|
1467
|
-
|
|
1468
|
-
|
|
1469
|
-
|
|
1470
|
-
|
|
1471
|
-
boostFeeBps
|
|
1472
|
-
}
|
|
1327
|
+
return openAccountCreationDepositChannel(this.options.backendUrl, {
|
|
1328
|
+
asset: chainflip.internalAssetToRpcAsset[asset2],
|
|
1329
|
+
refundAddress,
|
|
1330
|
+
signatureData,
|
|
1331
|
+
transactionMetadata,
|
|
1332
|
+
boostFeeBps
|
|
1473
1333
|
});
|
|
1474
|
-
if (res.status !== 201) {
|
|
1475
|
-
throw new Error("Failed to request account creation deposit channel", { cause: res });
|
|
1476
|
-
}
|
|
1477
|
-
return res.body;
|
|
1478
1334
|
}
|
|
1479
1335
|
};
|
|
1480
1336
|
var arrayToMap = (array) => Object.fromEntries(array.map((item) => [item, item]));
|