@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.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,277 +38,152 @@ 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 =
|
|
60
|
-
(address) =>
|
|
61
|
-
|
|
76
|
+
var chainflipAddress = zod.z.string().refine(
|
|
77
|
+
(address) => {
|
|
78
|
+
if (!address.startsWith("cF")) return false;
|
|
79
|
+
try {
|
|
80
|
+
ss58__namespace.decode(address);
|
|
81
|
+
return true;
|
|
82
|
+
} catch {
|
|
83
|
+
return false;
|
|
84
|
+
}
|
|
85
|
+
},
|
|
86
|
+
{ error: (issue) => `${issue.input} is not a valid Chainflip address` }
|
|
62
87
|
);
|
|
63
|
-
|
|
64
|
-
|
|
65
|
-
}));
|
|
66
|
-
var tronAddress = z3.z.string().refine(tron.isValidTronAddress, (address) => ({
|
|
67
|
-
message: `${address} is not a valid Tron address`
|
|
68
|
-
}));
|
|
69
|
-
var u128 = z3.z.union([z3.z.number(), numericString, hexString]).transform((arg) => BigInt(arg));
|
|
70
|
-
var unsignedInteger = z3.z.union([u128, z3.z.number().transform((n) => BigInt(n))]);
|
|
71
|
-
var chain = z3.z.enum(chainflip.chainflipChains);
|
|
72
|
-
var asset = z3.z.enum(chainflip.assetSymbols);
|
|
73
|
-
var uncheckedAssetAndChain = z3.z.object({
|
|
74
|
-
asset: z3.z.string(),
|
|
75
|
-
chain: z3.z.string()
|
|
88
|
+
zod.z.string().refine(solana.isValidSolanaAddress, {
|
|
89
|
+
error: (issue) => `${issue.input} is not a valid Solana address`
|
|
76
90
|
});
|
|
77
|
-
|
|
78
|
-
(
|
|
79
|
-
);
|
|
80
|
-
|
|
81
|
-
// ../shared/src/api/encodeVaultSwapData.ts
|
|
82
|
-
var EncodedVaultSwapData = z3.z.discriminatedUnion("chain", [
|
|
83
|
-
z3.z.object({
|
|
84
|
-
chain: z3.z.literal("Bitcoin"),
|
|
85
|
-
nulldataPayload: hexString,
|
|
86
|
-
depositAddress: z3.z.string()
|
|
87
|
-
}),
|
|
88
|
-
z3.z.object({
|
|
89
|
-
chain: z3.z.enum(["Ethereum", "Arbitrum", "Bsc"]),
|
|
90
|
-
value: z3.z.string(),
|
|
91
|
-
to: hexString,
|
|
92
|
-
calldata: hexString,
|
|
93
|
-
sourceTokenAddress: hexString.optional()
|
|
94
|
-
}),
|
|
95
|
-
z3.z.object({
|
|
96
|
-
chain: z3.z.literal("Tron"),
|
|
97
|
-
calldata: hexString,
|
|
98
|
-
value: z3.z.string(),
|
|
99
|
-
to: tronAddress,
|
|
100
|
-
note: hexString,
|
|
101
|
-
sourceTokenAddress: tronAddress.optional()
|
|
102
|
-
}),
|
|
103
|
-
z3.z.object({
|
|
104
|
-
chain: z3.z.literal("Solana"),
|
|
105
|
-
programId: z3.z.string(),
|
|
106
|
-
data: hexString,
|
|
107
|
-
accounts: z3.z.array(
|
|
108
|
-
z3.z.object({
|
|
109
|
-
pubkey: z3.z.string(),
|
|
110
|
-
isSigner: z3.z.boolean(),
|
|
111
|
-
isWritable: z3.z.boolean()
|
|
112
|
-
})
|
|
113
|
-
)
|
|
114
|
-
})
|
|
115
|
-
]);
|
|
116
|
-
var NetworkInfo = z3__default.default.object({
|
|
117
|
-
assets: z3__default.default.array(
|
|
118
|
-
z3__default.default.object({
|
|
119
|
-
asset: z3__default.default.enum(chainflip.chainflipAssets),
|
|
120
|
-
vaultSwapDepositsEnabled: z3__default.default.boolean(),
|
|
121
|
-
depositChannelDepositsEnabled: z3__default.default.boolean(),
|
|
122
|
-
depositChannelCreationEnabled: z3__default.default.boolean(),
|
|
123
|
-
egressEnabled: z3__default.default.boolean(),
|
|
124
|
-
boostDepositsEnabled: z3__default.default.boolean(),
|
|
125
|
-
livePriceProtectionEnabled: z3__default.default.boolean()
|
|
126
|
-
})
|
|
127
|
-
),
|
|
128
|
-
cfBrokerCommissionBps: z3__default.default.number()
|
|
91
|
+
zod.z.string().refine(tron.isValidTronAddress, {
|
|
92
|
+
error: (issue) => `${issue.input} is not a valid Tron address`
|
|
129
93
|
});
|
|
130
|
-
|
|
131
|
-
|
|
132
|
-
var
|
|
133
|
-
|
|
134
|
-
|
|
135
|
-
|
|
136
|
-
|
|
137
|
-
|
|
138
|
-
|
|
139
|
-
|
|
140
|
-
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
var validatePolkadotAddress = (address) => {
|
|
144
|
-
if (string.isHex(address)) return address.length === 66;
|
|
145
|
-
try {
|
|
146
|
-
ss58__namespace.decode(address);
|
|
147
|
-
return true;
|
|
148
|
-
} catch {
|
|
149
|
-
return false;
|
|
150
|
-
}
|
|
151
|
-
};
|
|
152
|
-
var validateEvmAddress = (address) => ethers__namespace.isAddress(address);
|
|
153
|
-
var validateBitcoinMainnetAddress = (address) => bitcoin__namespace.isValidAddressForNetwork(address, "mainnet");
|
|
154
|
-
var validateBitcoinTestnetAddress = (address) => bitcoin__namespace.isValidAddressForNetwork(address, "testnet");
|
|
155
|
-
var validateBitcoinRegtestAddress = (address) => bitcoin__namespace.isValidAddressForNetwork(address, "regtest");
|
|
156
|
-
var validateSolanaAddress = solana.isValidSolanaAddress;
|
|
157
|
-
var validateTronAddress = tron.isValidTronAddress;
|
|
158
|
-
var validators = {
|
|
159
|
-
mainnet: {
|
|
160
|
-
Bitcoin: validateBitcoinMainnetAddress,
|
|
161
|
-
Ethereum: validateEvmAddress,
|
|
162
|
-
Arbitrum: validateEvmAddress,
|
|
163
|
-
Solana: validateSolanaAddress,
|
|
164
|
-
Assethub: validatePolkadotAddress,
|
|
165
|
-
Tron: validateTronAddress,
|
|
166
|
-
Bsc: validateEvmAddress
|
|
167
|
-
},
|
|
168
|
-
perseverance: {
|
|
169
|
-
Bitcoin: validateBitcoinTestnetAddress,
|
|
170
|
-
Ethereum: validateEvmAddress,
|
|
171
|
-
Arbitrum: validateEvmAddress,
|
|
172
|
-
Solana: validateSolanaAddress,
|
|
173
|
-
Assethub: validatePolkadotAddress,
|
|
174
|
-
Tron: validateTronAddress,
|
|
175
|
-
Bsc: validateEvmAddress
|
|
176
|
-
},
|
|
177
|
-
sisyphos: {
|
|
178
|
-
Bitcoin: validateBitcoinTestnetAddress,
|
|
179
|
-
Ethereum: validateEvmAddress,
|
|
180
|
-
Arbitrum: validateEvmAddress,
|
|
181
|
-
Solana: validateSolanaAddress,
|
|
182
|
-
Assethub: validatePolkadotAddress,
|
|
183
|
-
Tron: validateTronAddress,
|
|
184
|
-
Bsc: validateEvmAddress
|
|
185
|
-
},
|
|
186
|
-
backspin: {
|
|
187
|
-
Bitcoin: validateBitcoinRegtestAddress,
|
|
188
|
-
Ethereum: validateEvmAddress,
|
|
189
|
-
Arbitrum: validateEvmAddress,
|
|
190
|
-
Solana: validateSolanaAddress,
|
|
191
|
-
Assethub: validatePolkadotAddress,
|
|
192
|
-
Tron: validateTronAddress,
|
|
193
|
-
Bsc: validateEvmAddress
|
|
194
|
-
},
|
|
195
|
-
localnet: {
|
|
196
|
-
Bitcoin: validateBitcoinRegtestAddress,
|
|
197
|
-
Ethereum: validateEvmAddress,
|
|
198
|
-
Arbitrum: validateEvmAddress,
|
|
199
|
-
Solana: validateSolanaAddress,
|
|
200
|
-
Assethub: validatePolkadotAddress,
|
|
201
|
-
Tron: validateTronAddress,
|
|
202
|
-
Bsc: validateEvmAddress
|
|
203
|
-
}
|
|
204
|
-
};
|
|
205
|
-
var validateAddress = (chain2, address, network) => validators[network][chain2](address);
|
|
206
|
-
|
|
207
|
-
// ../shared/src/api/openAccountCreationDepositChannel.ts
|
|
208
|
-
var getAccountCreationDepositChannelSchema = (network) => z3.z.object({
|
|
209
|
-
signatureData: z3.z.object({
|
|
210
|
-
Ethereum: z3.z.object({
|
|
211
|
-
signature: hexString,
|
|
212
|
-
signer: hexString,
|
|
213
|
-
sigType: z3.z.literal("Eip712")
|
|
214
|
-
}).transform(({ sigType, ...rest }) => ({
|
|
215
|
-
sig_type: sigType,
|
|
216
|
-
...rest
|
|
217
|
-
}))
|
|
218
|
-
}),
|
|
219
|
-
transactionMetadata: z3.z.object({
|
|
220
|
-
nonce: z3.z.number().gte(0),
|
|
221
|
-
expiryBlock: z3.z.number().positive()
|
|
222
|
-
}).transform(({ nonce, expiryBlock }) => ({
|
|
223
|
-
nonce,
|
|
224
|
-
expiry_block: expiryBlock
|
|
225
|
-
})),
|
|
226
|
-
asset: assetAndChain,
|
|
227
|
-
refundAddress: z3.z.string(),
|
|
228
|
-
boostFeeBps: z3.z.number().optional().default(0)
|
|
229
|
-
}).superRefine(({ asset: asset2, refundAddress }, ctx) => {
|
|
230
|
-
if (!validateAddress(asset2.chain, refundAddress, network)) {
|
|
231
|
-
ctx.addIssue({
|
|
232
|
-
message: `Address "${refundAddress}" is not a valid "${asset2.chain}" address for "${network}"`,
|
|
233
|
-
code: z3.z.ZodIssueCode.custom
|
|
234
|
-
});
|
|
235
|
-
}
|
|
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()
|
|
236
107
|
});
|
|
237
|
-
|
|
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({
|
|
238
112
|
srcChain: chain,
|
|
239
113
|
srcAsset: asset,
|
|
240
114
|
destChain: chain,
|
|
241
115
|
destAsset: asset,
|
|
242
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" }),
|
|
243
|
-
brokerCommissionBps: numericOrEmptyString.transform((v) => Number(v)).optional(),
|
|
244
|
-
ccmGasBudget:
|
|
245
|
-
numericString.transform((v) => BigInt(v)),
|
|
246
|
-
|
|
117
|
+
brokerCommissionBps: numericOrEmptyString.transform((v) => Number(v)).pipe(u16).optional(),
|
|
118
|
+
ccmGasBudget: zod.z.union([
|
|
119
|
+
numericString.transform((v) => BigInt(v)).refine((v) => v < 2n ** 128n, { message: "ccm gas budget must be less than 2^128" }),
|
|
120
|
+
zod.z.literal("undefined").transform(() => void 0)
|
|
247
121
|
// sdk version 1.8.2 sends undefined string if not set
|
|
248
122
|
]).optional(),
|
|
249
|
-
ccmMessageLengthBytes:
|
|
250
|
-
numericString.transform((v) => Number(v)),
|
|
251
|
-
|
|
123
|
+
ccmMessageLengthBytes: zod.z.union([
|
|
124
|
+
numericString.transform((v) => Number(v)).pipe(u32),
|
|
125
|
+
zod.z.literal("undefined").transform(() => void 0)
|
|
252
126
|
// sdk version 1.8.2 sends undefined string if not set
|
|
253
127
|
]).optional(),
|
|
254
|
-
dcaV2Enabled: booleanString.
|
|
128
|
+
dcaV2Enabled: booleanString.prefault("false"),
|
|
255
129
|
isVaultSwap: booleanString.optional(),
|
|
256
130
|
isOnChain: booleanString.optional(),
|
|
257
131
|
brokerAccount: chainflipAddress.optional(),
|
|
258
132
|
brokerIdSs58: chainflipAddress.optional(),
|
|
259
|
-
expectedResponseTimeMs: numericString.transform((v) => Number(v)).optional()
|
|
133
|
+
expectedResponseTimeMs: numericString.transform((v) => Number(v)).pipe(u32).optional()
|
|
260
134
|
}).transform((args, ctx) => {
|
|
261
135
|
const { srcAsset, destAsset } = chainflip.getInternalAssets(args, false);
|
|
262
136
|
let hadError = false;
|
|
263
137
|
if (srcAsset === null) {
|
|
264
138
|
ctx.addIssue({
|
|
265
139
|
message: `invalid asset and chain combination: ${JSON.stringify({ asset: args.srcAsset, chain: args.srcChain })}`,
|
|
266
|
-
code:
|
|
140
|
+
code: zod.z.ZodIssueCode.custom
|
|
267
141
|
});
|
|
268
142
|
hadError = true;
|
|
269
143
|
}
|
|
270
144
|
if (destAsset === null) {
|
|
271
145
|
ctx.addIssue({
|
|
272
146
|
message: `invalid asset and chain combination: ${JSON.stringify({ asset: args.destAsset, chain: args.destChain })}`,
|
|
273
|
-
code:
|
|
147
|
+
code: zod.z.ZodIssueCode.custom
|
|
274
148
|
});
|
|
275
149
|
hadError = true;
|
|
276
150
|
}
|
|
277
151
|
if (args.ccmGasBudget !== void 0 && args.ccmMessageLengthBytes === void 0) {
|
|
278
152
|
ctx.addIssue({
|
|
279
153
|
message: `ccmMessageLengthBytes must be set if ccmGasBudget is set`,
|
|
280
|
-
code:
|
|
154
|
+
code: zod.z.ZodIssueCode.custom
|
|
281
155
|
});
|
|
282
156
|
hadError = true;
|
|
283
157
|
}
|
|
284
158
|
if (args.ccmGasBudget === void 0 && args.ccmMessageLengthBytes !== void 0) {
|
|
285
159
|
ctx.addIssue({
|
|
286
160
|
message: `ccmGasBudget must be set if ccmMessageLengthBytes is set`,
|
|
287
|
-
code:
|
|
161
|
+
code: zod.z.ZodIssueCode.custom
|
|
288
162
|
});
|
|
289
163
|
hadError = true;
|
|
290
164
|
}
|
|
291
165
|
if (args.isOnChain && args.isVaultSwap) {
|
|
292
166
|
ctx.addIssue({
|
|
293
167
|
message: "isOnChain and isVaultSwap cannot be set at the same time",
|
|
294
|
-
code:
|
|
168
|
+
code: zod.z.ZodIssueCode.custom
|
|
295
169
|
});
|
|
296
170
|
hadError = true;
|
|
297
171
|
}
|
|
298
172
|
if (args.isVaultSwap && args.srcChain === "Assethub") {
|
|
299
173
|
ctx.addIssue({
|
|
300
174
|
message: "Vault swaps are not supported on Assethub",
|
|
301
|
-
code:
|
|
175
|
+
code: zod.z.ZodIssueCode.custom
|
|
302
176
|
});
|
|
303
177
|
hadError = true;
|
|
304
178
|
}
|
|
305
179
|
if (args.isOnChain && args.brokerCommissionBps !== void 0 && args.brokerCommissionBps > 0) {
|
|
306
180
|
ctx.addIssue({
|
|
307
181
|
message: "isOnChain cannot be set with a non-zero broker commission",
|
|
308
|
-
code:
|
|
182
|
+
code: zod.z.ZodIssueCode.custom
|
|
309
183
|
});
|
|
310
184
|
hadError = true;
|
|
311
185
|
}
|
|
312
|
-
if (hadError) return
|
|
186
|
+
if (hadError) return zod.z.NEVER;
|
|
313
187
|
const ccmParams = args.ccmGasBudget !== void 0 && args.ccmMessageLengthBytes !== void 0 ? { gasBudget: args.ccmGasBudget, messageLengthBytes: args.ccmMessageLengthBytes } : void 0;
|
|
314
188
|
return {
|
|
315
189
|
srcAsset,
|
|
@@ -324,8 +198,8 @@ z3.z.object({
|
|
|
324
198
|
expectedResponseTimeMs: args.expectedResponseTimeMs
|
|
325
199
|
};
|
|
326
200
|
});
|
|
327
|
-
var ccmParamsSchema =
|
|
328
|
-
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)),
|
|
329
203
|
// https://github.com/chainflip-io/chainflip-backend/blob/415aa9e20ec4046c68892cd34798e5d831c5b83f/state-chain/chains/src/lib.rs#L709
|
|
330
204
|
message: hexStringWithMaxByteSize(15e3),
|
|
331
205
|
// https://github.com/chainflip-io/chainflip-backend/blob/415aa9e20ec4046c68892cd34798e5d831c5b83f/state-chain/chains/src/lib.rs#L710
|
|
@@ -335,92 +209,97 @@ var ccmParamsSchema = z3.z.object({
|
|
|
335
209
|
message,
|
|
336
210
|
ccmAdditionalData: ccmAdditionalData ?? "0x"
|
|
337
211
|
}));
|
|
338
|
-
var affiliateBroker =
|
|
212
|
+
var affiliateBroker = zod.z.object({
|
|
339
213
|
account: chainflipAddress,
|
|
340
|
-
commissionBps:
|
|
214
|
+
commissionBps: u16
|
|
341
215
|
}).transform(({ account, commissionBps: bps }) => ({ account, bps }));
|
|
342
|
-
var dcaParams =
|
|
343
|
-
numberOfChunks:
|
|
344
|
-
chunkIntervalBlocks:
|
|
216
|
+
var dcaParams = zod.z.object({
|
|
217
|
+
numberOfChunks: u32.min(1, { message: "number of chunks must be greater than 0" }),
|
|
218
|
+
chunkIntervalBlocks: u32
|
|
345
219
|
});
|
|
346
|
-
|
|
347
|
-
retryDurationBlocks:
|
|
348
|
-
refundAddress:
|
|
220
|
+
zod.z.object({
|
|
221
|
+
retryDurationBlocks: u32,
|
|
222
|
+
refundAddress: zod.z.string(),
|
|
349
223
|
minPriceX128: numericString,
|
|
350
224
|
maxOraclePriceSlippage: basisPoints.nullish().transform((v) => v ?? null),
|
|
351
225
|
refundCcmMetadata: ccmParamsSchema.nullish().optional().default(null)
|
|
352
226
|
});
|
|
353
227
|
|
|
354
|
-
// ../shared/src/
|
|
355
|
-
var
|
|
356
|
-
|
|
357
|
-
|
|
358
|
-
|
|
359
|
-
|
|
360
|
-
|
|
361
|
-
z3.z.object({
|
|
362
|
-
destAddress: z3.z.string(),
|
|
363
|
-
amount: numericString,
|
|
364
|
-
ccmParams: ccmParamsSchema.optional(),
|
|
365
|
-
maxBoostFeeBps: z3.z.number().optional(),
|
|
366
|
-
srcAddress: z3.z.string().optional(),
|
|
367
|
-
fillOrKillParams,
|
|
368
|
-
dcaParams: dcaParams.optional(),
|
|
369
|
-
quote: z3.z.object({
|
|
370
|
-
intermediateAmount: z3.z.string().optional(),
|
|
371
|
-
egressAmount: z3.z.string(),
|
|
372
|
-
estimatedPrice: z3.z.string(),
|
|
373
|
-
recommendedSlippageTolerancePercent: z3.z.number().optional(),
|
|
374
|
-
recommendedLivePriceSlippageTolerancePercent: z3.z.number().optional()
|
|
375
|
-
}).optional(),
|
|
376
|
-
takeCommission: z3.z.boolean().optional()
|
|
377
|
-
})
|
|
378
|
-
).superRefine(({ ...val }, ctx) => {
|
|
379
|
-
if (!validateAddress(val.destAsset.chain, val.destAddress, network)) {
|
|
380
|
-
ctx.addIssue({
|
|
381
|
-
message: `Address "${val.destAddress}" is not a valid "${val.destAsset.chain}" address for "${network}"`,
|
|
382
|
-
code: z3.z.ZodIssueCode.custom
|
|
383
|
-
});
|
|
384
|
-
}
|
|
385
|
-
if (!validateAddress(val.srcAsset.chain, val.fillOrKillParams.refundAddress, network)) {
|
|
386
|
-
ctx.addIssue({
|
|
387
|
-
message: `Address "${val.fillOrKillParams.refundAddress}" is not a valid "${val.srcAsset.chain}" address for "${network}"`,
|
|
388
|
-
code: z3.z.ZodIssueCode.custom
|
|
389
|
-
});
|
|
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");
|
|
390
235
|
}
|
|
391
|
-
|
|
392
|
-
|
|
393
|
-
expectedDepositAmount: amount
|
|
394
|
-
}));
|
|
395
|
-
var DepositChannelInfo = z3.z.object({
|
|
396
|
-
id: z3.z.string(),
|
|
397
|
-
depositAddress: z3.z.string(),
|
|
398
|
-
brokerCommissionBps: z3.z.number(),
|
|
399
|
-
maxBoostFeeBps: z3.z.number(),
|
|
400
|
-
issuedBlock: z3.z.number(),
|
|
401
|
-
srcChainExpiryBlock: z3.z.string(),
|
|
402
|
-
estimatedExpiryTime: z3.z.number().optional(),
|
|
403
|
-
channelOpeningFee: z3.z.string()
|
|
404
|
-
});
|
|
405
|
-
|
|
406
|
-
// ../shared/src/strings.ts
|
|
407
|
-
var toCamelCase = (str) => str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
|
|
236
|
+
throw error;
|
|
237
|
+
}
|
|
408
238
|
|
|
409
|
-
// ../shared/src/
|
|
410
|
-
var
|
|
411
|
-
if (
|
|
412
|
-
|
|
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;
|
|
413
247
|
}
|
|
414
|
-
|
|
415
|
-
|
|
416
|
-
|
|
417
|
-
|
|
418
|
-
|
|
419
|
-
|
|
420
|
-
|
|
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
|
|
421
300
|
}
|
|
422
|
-
return obj;
|
|
423
301
|
};
|
|
302
|
+
var validateAddress = (chain2, address, network) => Object.hasOwn(validators, network) && Object.hasOwn(validators[network], chain2) && validators[network][chain2](address);
|
|
424
303
|
|
|
425
304
|
// ../shared/src/broker.ts
|
|
426
305
|
var transformedDcaParamsSchema = dcaParams.transform(
|
|
@@ -436,9 +315,9 @@ var transformedCcmParamsSchema = ccmParamsSchema.transform(
|
|
|
436
315
|
ccm_additional_data: ccmAdditionalData
|
|
437
316
|
})
|
|
438
317
|
);
|
|
439
|
-
var transformedFokSchema =
|
|
440
|
-
retryDurationBlocks:
|
|
441
|
-
refundAddress:
|
|
318
|
+
var transformedFokSchema = zod.z.object({
|
|
319
|
+
retryDurationBlocks: u32,
|
|
320
|
+
refundAddress: zod.z.string(),
|
|
442
321
|
minPriceX128: numericString,
|
|
443
322
|
maxOraclePriceSlippage: basisPoints.nullish().transform((v) => v ?? null),
|
|
444
323
|
refundCcmMetadata: transformedCcmParamsSchema.nullable().optional().default(null)
|
|
@@ -457,67 +336,67 @@ var transformedFokSchema = z3.z.object({
|
|
|
457
336
|
refund_ccm_metadata: refundCcmMetadata
|
|
458
337
|
})
|
|
459
338
|
);
|
|
460
|
-
var getDepositAddressRequestSchema = (network) =>
|
|
339
|
+
var getDepositAddressRequestSchema = (network) => zod.z.object({
|
|
461
340
|
srcAsset: assetAndChain,
|
|
462
341
|
destAsset: assetAndChain,
|
|
463
|
-
destAddress:
|
|
464
|
-
commissionBps:
|
|
342
|
+
destAddress: zod.z.string(),
|
|
343
|
+
commissionBps: u16.optional().default(0),
|
|
465
344
|
ccmParams: transformedCcmParamsSchema.optional(),
|
|
466
|
-
maxBoostFeeBps:
|
|
467
|
-
affiliates:
|
|
345
|
+
maxBoostFeeBps: u16.optional(),
|
|
346
|
+
affiliates: zod.z.array(affiliateBroker).optional(),
|
|
468
347
|
fillOrKillParams: transformedFokSchema,
|
|
469
348
|
dcaParams: transformedDcaParamsSchema.optional()
|
|
470
349
|
}).superRefine((val, ctx) => {
|
|
471
350
|
if (!validateAddress(val.destAsset.chain, val.destAddress, network)) {
|
|
472
351
|
ctx.addIssue({
|
|
473
352
|
message: `Address "${val.destAddress}" is not a valid "${val.destAsset.chain}" address for "${network}"`,
|
|
474
|
-
code:
|
|
353
|
+
code: zod.z.ZodIssueCode.custom
|
|
475
354
|
});
|
|
476
355
|
}
|
|
477
356
|
if (!validateAddress(val.srcAsset.chain, val.fillOrKillParams.refund_address, network)) {
|
|
478
357
|
ctx.addIssue({
|
|
479
358
|
message: `Address "${val.fillOrKillParams.refund_address}" is not a valid "${val.srcAsset.chain}" address for "${network}"`,
|
|
480
|
-
code:
|
|
359
|
+
code: zod.z.ZodIssueCode.custom
|
|
481
360
|
});
|
|
482
361
|
}
|
|
483
362
|
});
|
|
484
|
-
var getVaultSwapParameterEncodingRequestSchema = (network) =>
|
|
363
|
+
var getVaultSwapParameterEncodingRequestSchema = (network) => zod.z.object({
|
|
485
364
|
srcAsset: assetAndChain,
|
|
486
|
-
srcAddress:
|
|
365
|
+
srcAddress: zod.z.string().optional(),
|
|
487
366
|
destAsset: assetAndChain,
|
|
488
|
-
destAddress:
|
|
367
|
+
destAddress: zod.z.string(),
|
|
489
368
|
amount: unsignedInteger,
|
|
490
|
-
commissionBps:
|
|
369
|
+
commissionBps: u16.optional().default(0),
|
|
491
370
|
ccmParams: transformedCcmParamsSchema.optional(),
|
|
492
|
-
maxBoostFeeBps:
|
|
493
|
-
affiliates:
|
|
371
|
+
maxBoostFeeBps: u16.optional(),
|
|
372
|
+
affiliates: zod.z.array(affiliateBroker).optional(),
|
|
494
373
|
fillOrKillParams: transformedFokSchema,
|
|
495
374
|
dcaParams: transformedDcaParamsSchema.optional(),
|
|
496
|
-
extraParams:
|
|
375
|
+
extraParams: zod.z.object({ seed: hexString.optional() }).optional(),
|
|
497
376
|
brokerAccount: chainflipAddress.optional()
|
|
498
377
|
}).superRefine((val, ctx) => {
|
|
499
378
|
if (val.srcAddress && !validateAddress(val.srcAsset.chain, val.srcAddress, network)) {
|
|
500
379
|
ctx.addIssue({
|
|
501
380
|
message: `Address "${val.srcAddress}" is not a valid "${val.srcAsset.chain}" address for "${network}"`,
|
|
502
|
-
code:
|
|
381
|
+
code: zod.z.ZodIssueCode.custom
|
|
503
382
|
});
|
|
504
383
|
}
|
|
505
384
|
if (!validateAddress(val.destAsset.chain, val.destAddress, network)) {
|
|
506
385
|
ctx.addIssue({
|
|
507
386
|
message: `Address "${val.destAddress}" is not a valid "${val.destAsset.chain}" address for "${network}"`,
|
|
508
|
-
code:
|
|
387
|
+
code: zod.z.ZodIssueCode.custom
|
|
509
388
|
});
|
|
510
389
|
}
|
|
511
390
|
if (!validateAddress(val.srcAsset.chain, val.fillOrKillParams.refund_address, network)) {
|
|
512
391
|
ctx.addIssue({
|
|
513
392
|
message: `Address "${val.fillOrKillParams.refund_address}" is not a valid "${val.srcAsset.chain}" address for "${network}"`,
|
|
514
|
-
code:
|
|
393
|
+
code: zod.z.ZodIssueCode.custom
|
|
515
394
|
});
|
|
516
395
|
}
|
|
517
396
|
if (val.extraParams?.seed && val.extraParams.seed.length !== 66) {
|
|
518
|
-
ctx.addIssue({ message: "Seed must be 32 bytes", code:
|
|
397
|
+
ctx.addIssue({ message: "Seed must be 32 bytes", code: zod.z.ZodIssueCode.custom });
|
|
519
398
|
}
|
|
520
|
-
}).transform((data) => {
|
|
399
|
+
}).transform((data, ctx) => {
|
|
521
400
|
let extraParams;
|
|
522
401
|
if (data.srcAsset.chain === "Bitcoin") {
|
|
523
402
|
const minOutputAmount = BigNumber2__default.default(data.amount.toString()).multipliedBy(tickMath.priceX128ToPrice(data.fillOrKillParams.min_price)).toFixed(0);
|
|
@@ -534,7 +413,13 @@ var getVaultSwapParameterEncodingRequestSchema = (network) => z3.z.object({
|
|
|
534
413
|
refund_parameters: data.fillOrKillParams
|
|
535
414
|
};
|
|
536
415
|
} else if (data.srcAsset.chain === "Solana") {
|
|
537
|
-
|
|
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
|
+
}
|
|
538
423
|
extraParams = {
|
|
539
424
|
chain: "Solana",
|
|
540
425
|
from: data.srcAddress,
|
|
@@ -543,7 +428,11 @@ var getVaultSwapParameterEncodingRequestSchema = (network) => z3.z.object({
|
|
|
543
428
|
refund_parameters: data.fillOrKillParams
|
|
544
429
|
};
|
|
545
430
|
} else {
|
|
546
|
-
|
|
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;
|
|
547
436
|
}
|
|
548
437
|
return { ...data, extraParams };
|
|
549
438
|
});
|
|
@@ -597,16 +486,16 @@ async function requestSwapParameterEncoding(request, opts, chainflipNetwork) {
|
|
|
597
486
|
);
|
|
598
487
|
return transformKeysToCamelCase(response);
|
|
599
488
|
}
|
|
600
|
-
var getParameterEncodingRequestSchema = (network) =>
|
|
489
|
+
var getParameterEncodingRequestSchema = (network) => zod.z.object({
|
|
601
490
|
srcAsset: assetAndChain,
|
|
602
|
-
srcAddress:
|
|
491
|
+
srcAddress: zod.z.string().optional(),
|
|
603
492
|
destAsset: assetAndChain,
|
|
604
|
-
destAddress:
|
|
493
|
+
destAddress: zod.z.string(),
|
|
605
494
|
amount: unsignedInteger,
|
|
606
|
-
commissionBps:
|
|
495
|
+
commissionBps: u16.optional().default(0),
|
|
607
496
|
ccmParams: transformedCcmParamsSchema.optional(),
|
|
608
|
-
maxBoostFeeBps:
|
|
609
|
-
affiliates:
|
|
497
|
+
maxBoostFeeBps: u16.optional(),
|
|
498
|
+
affiliates: zod.z.array(affiliateBroker).optional(),
|
|
610
499
|
fillOrKillParams: transformedFokSchema,
|
|
611
500
|
dcaParams: transformedDcaParamsSchema.optional(),
|
|
612
501
|
brokerAccount: chainflipAddress.optional()
|
|
@@ -614,19 +503,19 @@ var getParameterEncodingRequestSchema = (network) => z3.z.object({
|
|
|
614
503
|
if (val.srcAddress && !validateAddress(val.srcAsset.chain, val.srcAddress, network)) {
|
|
615
504
|
ctx.addIssue({
|
|
616
505
|
message: `Address "${val.srcAddress}" is not a valid "${val.srcAsset.chain}" address for "${network}"`,
|
|
617
|
-
code:
|
|
506
|
+
code: zod.z.ZodIssueCode.custom
|
|
618
507
|
});
|
|
619
508
|
}
|
|
620
509
|
if (!validateAddress(val.destAsset.chain, val.destAddress, network)) {
|
|
621
510
|
ctx.addIssue({
|
|
622
511
|
message: `Address "${val.destAddress}" is not a valid "${val.destAsset.chain}" address for "${network}"`,
|
|
623
|
-
code:
|
|
512
|
+
code: zod.z.ZodIssueCode.custom
|
|
624
513
|
});
|
|
625
514
|
}
|
|
626
515
|
if (!validateAddress(val.srcAsset.chain, val.fillOrKillParams.refund_address, network)) {
|
|
627
516
|
ctx.addIssue({
|
|
628
517
|
message: `Address "${val.fillOrKillParams.refund_address}" is not a valid "${val.srcAsset.chain}" address for "${network}"`,
|
|
629
|
-
code:
|
|
518
|
+
code: zod.z.ZodIssueCode.custom
|
|
630
519
|
});
|
|
631
520
|
}
|
|
632
521
|
}).transform(({ ...rest }) => rest);
|
|
@@ -648,56 +537,6 @@ async function requestCfParametersEncoding(request, opts, network) {
|
|
|
648
537
|
return response;
|
|
649
538
|
}
|
|
650
539
|
|
|
651
|
-
// ../shared/src/api/contract.ts
|
|
652
|
-
var c = core.initContract();
|
|
653
|
-
var createApiContract = (network) => c.router(
|
|
654
|
-
{
|
|
655
|
-
networkInfo: {
|
|
656
|
-
method: "GET",
|
|
657
|
-
path: "/networkInfo",
|
|
658
|
-
responses: {
|
|
659
|
-
200: NetworkInfo
|
|
660
|
-
},
|
|
661
|
-
summary: "Get information about the Chainflip network"
|
|
662
|
-
},
|
|
663
|
-
encodeCfParameters: {
|
|
664
|
-
method: "POST",
|
|
665
|
-
path: "/encodeCfParameters",
|
|
666
|
-
body: getParameterEncodingRequestSchema(network),
|
|
667
|
-
responses: {
|
|
668
|
-
200: hexString
|
|
669
|
-
}
|
|
670
|
-
},
|
|
671
|
-
encodeVaultSwapData: {
|
|
672
|
-
method: "POST",
|
|
673
|
-
path: "/encodeVaultSwapData",
|
|
674
|
-
body: getVaultSwapParameterEncodingRequestSchema(network),
|
|
675
|
-
responses: {
|
|
676
|
-
200: EncodedVaultSwapData
|
|
677
|
-
}
|
|
678
|
-
},
|
|
679
|
-
openSwapDepositChannel: {
|
|
680
|
-
method: "POST",
|
|
681
|
-
path: "/openSwapDepositChannel",
|
|
682
|
-
body: getOpenSwapDepositChannelSchema(network),
|
|
683
|
-
responses: {
|
|
684
|
-
201: DepositChannelInfo
|
|
685
|
-
}
|
|
686
|
-
},
|
|
687
|
-
openAccountCreationDepositChannel: {
|
|
688
|
-
method: "POST",
|
|
689
|
-
path: "/openAccountCreationDepositChannel",
|
|
690
|
-
body: getAccountCreationDepositChannelSchema(network),
|
|
691
|
-
responses: {
|
|
692
|
-
201: DepositChannelInfo
|
|
693
|
-
}
|
|
694
|
-
}
|
|
695
|
-
},
|
|
696
|
-
{
|
|
697
|
-
pathPrefix: "/api"
|
|
698
|
-
}
|
|
699
|
-
);
|
|
700
|
-
|
|
701
540
|
// ../shared/src/consts.ts
|
|
702
541
|
var ETHEREUM_EVM_CHAIN_ID = {
|
|
703
542
|
backspin: 10997,
|
|
@@ -824,12 +663,12 @@ var MultiCache = class {
|
|
|
824
663
|
}
|
|
825
664
|
values = {};
|
|
826
665
|
read(type) {
|
|
827
|
-
const { fetch, ttl } = this.fetchers[type];
|
|
666
|
+
const { fetch: fetch2, ttl } = this.fetchers[type];
|
|
828
667
|
let cached = this.values[type];
|
|
829
668
|
if (!cached || cached.timestamp + ttl < Date.now()) {
|
|
830
669
|
cached = {
|
|
831
670
|
timestamp: Date.now(),
|
|
832
|
-
value:
|
|
671
|
+
value: fetch2().catch((err) => {
|
|
833
672
|
this.values[type] = void 0;
|
|
834
673
|
throw err;
|
|
835
674
|
})
|
|
@@ -1000,7 +839,7 @@ var getChainData = (chain2, network, env) => ({
|
|
|
1000
839
|
|
|
1001
840
|
// package.json
|
|
1002
841
|
var package_default = {
|
|
1003
|
-
version: "2.3.
|
|
842
|
+
version: "2.3.3"};
|
|
1004
843
|
|
|
1005
844
|
// src/swap/consts.ts
|
|
1006
845
|
var CF_SDK_VERSION_HEADERS = { "X-Chainflip-Sdk-Version": package_default.version };
|
|
@@ -1048,6 +887,59 @@ var getStatusV2 = async (baseUrl, { id }, { signal }) => {
|
|
|
1048
887
|
});
|
|
1049
888
|
return data;
|
|
1050
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
|
+
};
|
|
1051
943
|
|
|
1052
944
|
// src/swap/sdk.ts
|
|
1053
945
|
var assertQuoteValid = (quote) => {
|
|
@@ -1064,7 +956,6 @@ var assertQuoteValid = (quote) => {
|
|
|
1064
956
|
var SwapSDK = class {
|
|
1065
957
|
options;
|
|
1066
958
|
rpcConfig;
|
|
1067
|
-
apiClient;
|
|
1068
959
|
cache;
|
|
1069
960
|
dcaV2Enabled = false;
|
|
1070
961
|
constructor(options = {}) {
|
|
@@ -1075,12 +966,6 @@ var SwapSDK = class {
|
|
|
1075
966
|
backendUrl: options.backendUrl ?? BACKEND_SERVICE_URLS[network]
|
|
1076
967
|
};
|
|
1077
968
|
this.rpcConfig = options.rpcUrl ? { rpcUrl: options.rpcUrl } : { network };
|
|
1078
|
-
this.apiClient = core.initClient(createApiContract(this.options.network), {
|
|
1079
|
-
// remove trailing slashes. this bug has been fixed in `@ts-rest/core`
|
|
1080
|
-
// but it hasn't been released yet
|
|
1081
|
-
baseUrl: this.options.backendUrl.replace(/\/+$/, ""),
|
|
1082
|
-
baseHeaders: CF_SDK_VERSION_HEADERS
|
|
1083
|
-
});
|
|
1084
969
|
this.dcaV2Enabled = options.enabledFeatures?.dcaV2 ?? false;
|
|
1085
970
|
this.cache = new MultiCache({
|
|
1086
971
|
environment: {
|
|
@@ -1088,11 +973,7 @@ var SwapSDK = class {
|
|
|
1088
973
|
ttl: 6e4
|
|
1089
974
|
},
|
|
1090
975
|
networkInfo: {
|
|
1091
|
-
fetch:
|
|
1092
|
-
const res = await this.apiClient.networkInfo();
|
|
1093
|
-
assert(res.status === 200, "Failed to fetch network info");
|
|
1094
|
-
return res.body;
|
|
1095
|
-
},
|
|
976
|
+
fetch: () => getNetworkInfo(this.options.backendUrl),
|
|
1096
977
|
ttl: 6e4
|
|
1097
978
|
}
|
|
1098
979
|
});
|
|
@@ -1113,8 +994,8 @@ var SwapSDK = class {
|
|
|
1113
994
|
return this.cache.read("environment");
|
|
1114
995
|
}
|
|
1115
996
|
async getSupportedAssets(type) {
|
|
1116
|
-
const
|
|
1117
|
-
return
|
|
997
|
+
const assets = await this.cache.read("networkInfo");
|
|
998
|
+
return assets.assets.filter((a) => chainflip.isChainflipAsset(a.asset)).filter((a) => {
|
|
1118
999
|
switch (type) {
|
|
1119
1000
|
case "all":
|
|
1120
1001
|
return true;
|
|
@@ -1296,15 +1177,11 @@ var SwapSDK = class {
|
|
|
1296
1177
|
!affiliates?.length,
|
|
1297
1178
|
"Affiliate brokers are supported only when initializing the SDK with a brokerUrl"
|
|
1298
1179
|
);
|
|
1299
|
-
|
|
1300
|
-
|
|
1301
|
-
|
|
1302
|
-
|
|
1303
|
-
takeCommission: this.shouldTakeCommission()
|
|
1304
|
-
}
|
|
1180
|
+
response = await openSwapDepositChannel(this.options.backendUrl, {
|
|
1181
|
+
...depositAddressRequest,
|
|
1182
|
+
quote,
|
|
1183
|
+
takeCommission: this.shouldTakeCommission()
|
|
1305
1184
|
});
|
|
1306
|
-
assert(res.status === 201, "Failed to open swap deposit channel");
|
|
1307
|
-
response = res.body;
|
|
1308
1185
|
}
|
|
1309
1186
|
return {
|
|
1310
1187
|
...depositAddressRequest,
|
|
@@ -1377,18 +1254,15 @@ var SwapSDK = class {
|
|
|
1377
1254
|
!vaultSwapRequest.affiliates?.length || vaultSwapRequest.brokerAccount,
|
|
1378
1255
|
"Affiliate brokers are supported only when setting a broker account"
|
|
1379
1256
|
);
|
|
1380
|
-
const
|
|
1381
|
-
|
|
1382
|
-
throw new Error("Failed to encode vault swap data", { cause: res });
|
|
1383
|
-
}
|
|
1384
|
-
switch (res.body.chain) {
|
|
1257
|
+
const body = await encodeVaultSwapData(this.options.backendUrl, vaultSwapRequest);
|
|
1258
|
+
switch (body.chain) {
|
|
1385
1259
|
case "Arbitrum":
|
|
1386
1260
|
case "Ethereum":
|
|
1387
1261
|
case "Tron":
|
|
1388
1262
|
case "Bsc":
|
|
1389
|
-
return { ...
|
|
1263
|
+
return { ...body, value: BigInt(body.value) };
|
|
1390
1264
|
default:
|
|
1391
|
-
return
|
|
1265
|
+
return body;
|
|
1392
1266
|
}
|
|
1393
1267
|
}
|
|
1394
1268
|
async encodeCfParameters({
|
|
@@ -1440,32 +1314,23 @@ var SwapSDK = class {
|
|
|
1440
1314
|
!requestParams.affiliates?.length || brokerAccount,
|
|
1441
1315
|
"Affiliate brokers are supported only when setting a broker account"
|
|
1442
1316
|
);
|
|
1443
|
-
|
|
1444
|
-
|
|
1317
|
+
return encodeCfParameters(this.options.backendUrl, {
|
|
1318
|
+
...requestParams,
|
|
1319
|
+
brokerAccount
|
|
1445
1320
|
});
|
|
1446
|
-
if (res.status !== 200) {
|
|
1447
|
-
throw new Error("Failed to encode cf parameters", { cause: res });
|
|
1448
|
-
}
|
|
1449
|
-
return res.body;
|
|
1450
1321
|
}
|
|
1451
1322
|
async checkBoostEnabled() {
|
|
1452
|
-
const { assets
|
|
1453
|
-
return
|
|
1323
|
+
const { assets } = await this.cache.read("networkInfo");
|
|
1324
|
+
return assets.find((a) => a.asset === "Btc")?.boostDepositsEnabled ?? true;
|
|
1454
1325
|
}
|
|
1455
1326
|
async requestAccountCreationDepositAddress(asset2, refundAddress, signatureData, transactionMetadata, boostFeeBps = 0) {
|
|
1456
|
-
|
|
1457
|
-
|
|
1458
|
-
|
|
1459
|
-
|
|
1460
|
-
|
|
1461
|
-
|
|
1462
|
-
boostFeeBps
|
|
1463
|
-
}
|
|
1327
|
+
return openAccountCreationDepositChannel(this.options.backendUrl, {
|
|
1328
|
+
asset: chainflip.internalAssetToRpcAsset[asset2],
|
|
1329
|
+
refundAddress,
|
|
1330
|
+
signatureData,
|
|
1331
|
+
transactionMetadata,
|
|
1332
|
+
boostFeeBps
|
|
1464
1333
|
});
|
|
1465
|
-
if (res.status !== 201) {
|
|
1466
|
-
throw new Error("Failed to request account creation deposit channel", { cause: res });
|
|
1467
|
-
}
|
|
1468
|
-
return res.body;
|
|
1469
1334
|
}
|
|
1470
1335
|
};
|
|
1471
1336
|
var arrayToMap = (array) => Object.fromEntries(array.map((item) => [item, item]));
|