@chainflip/sdk 1.8.4-beta.0 → 1.9.0-beta.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/chunk-6IYYRTHK.js +106 -0
- package/dist/{funding.mjs → funding.cjs} +73 -8
- package/dist/{funding.d.mts → funding.d.cts} +1 -1
- package/dist/funding.d.ts +1 -1
- package/dist/funding.js +8 -89
- package/dist/{swap.mjs → swap.cjs} +396 -451
- package/dist/{swap.d.mts → swap.d.cts} +326 -206
- package/dist/swap.d.ts +326 -206
- package/dist/swap.js +249 -763
- package/package.json +24 -23
- package/dist/chunk-HBQFFIRA.mjs +0 -292
- package/dist/enums-_AFEOA70.d.mts +0 -69
- package/dist/enums-_AFEOA70.d.ts +0 -69
|
@@ -1,20 +1,59 @@
|
|
|
1
|
-
|
|
2
|
-
|
|
3
|
-
|
|
4
|
-
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
10
|
-
|
|
11
|
-
|
|
12
|
-
|
|
13
|
-
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
1
|
+
'use strict';
|
|
2
|
+
|
|
3
|
+
var chainflip = require('@chainflip/utils/chainflip');
|
|
4
|
+
var client = require('@trpc/client');
|
|
5
|
+
var superjson = require('superjson');
|
|
6
|
+
var rpc = require('@chainflip/rpc');
|
|
7
|
+
var ss58 = require('@chainflip/utils/ss58');
|
|
8
|
+
var string = require('@chainflip/utils/string');
|
|
9
|
+
var tickMath = require('@chainflip/utils/tickMath');
|
|
10
|
+
var BigNumber2 = require('bignumber.js');
|
|
11
|
+
var zod = require('zod');
|
|
12
|
+
var solana = require('@chainflip/solana');
|
|
13
|
+
var number = require('@chainflip/utils/number');
|
|
14
|
+
var bitcoin = require('@chainflip/bitcoin');
|
|
15
|
+
var ethers = require('ethers');
|
|
16
|
+
var axios = require('axios');
|
|
17
|
+
|
|
18
|
+
function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
|
|
19
|
+
|
|
20
|
+
function _interopNamespace(e) {
|
|
21
|
+
if (e && e.__esModule) return e;
|
|
22
|
+
var n = Object.create(null);
|
|
23
|
+
if (e) {
|
|
24
|
+
Object.keys(e).forEach(function (k) {
|
|
25
|
+
if (k !== 'default') {
|
|
26
|
+
var d = Object.getOwnPropertyDescriptor(e, k);
|
|
27
|
+
Object.defineProperty(n, k, d.get ? d : {
|
|
28
|
+
enumerable: true,
|
|
29
|
+
get: function () { return e[k]; }
|
|
30
|
+
});
|
|
31
|
+
}
|
|
32
|
+
});
|
|
33
|
+
}
|
|
34
|
+
n.default = e;
|
|
35
|
+
return Object.freeze(n);
|
|
36
|
+
}
|
|
37
|
+
|
|
38
|
+
var superjson__default = /*#__PURE__*/_interopDefault(superjson);
|
|
39
|
+
var ss58__namespace = /*#__PURE__*/_interopNamespace(ss58);
|
|
40
|
+
var BigNumber2__default = /*#__PURE__*/_interopDefault(BigNumber2);
|
|
41
|
+
var bitcoin__namespace = /*#__PURE__*/_interopNamespace(bitcoin);
|
|
42
|
+
var ethers__namespace = /*#__PURE__*/_interopNamespace(ethers);
|
|
43
|
+
var axios__default = /*#__PURE__*/_interopDefault(axios);
|
|
44
|
+
|
|
45
|
+
// src/swap/sdk.ts
|
|
46
|
+
|
|
47
|
+
// ../shared/src/guards.ts
|
|
48
|
+
var isNotNullish = (value) => value !== null && value !== void 0;
|
|
49
|
+
function assert(condition, message, Constructor = Error) {
|
|
50
|
+
if (condition) return;
|
|
51
|
+
const error = new Constructor(message);
|
|
52
|
+
if (error.stack) {
|
|
53
|
+
error.stack = error.stack.replace(/\n.+/, "\n");
|
|
54
|
+
}
|
|
55
|
+
throw error;
|
|
56
|
+
}
|
|
18
57
|
|
|
19
58
|
// ../shared/src/strings.ts
|
|
20
59
|
var toCamelCase = (str) => str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
|
|
@@ -34,187 +73,80 @@ var transformKeysToCamelCase = (obj) => {
|
|
|
34
73
|
}
|
|
35
74
|
return obj;
|
|
36
75
|
};
|
|
37
|
-
var
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
return true;
|
|
42
|
-
} catch {
|
|
43
|
-
return false;
|
|
44
|
-
}
|
|
45
|
-
};
|
|
46
|
-
var validateEvmAddress = (address) => ethers.isAddress(address);
|
|
47
|
-
var validateBitcoinMainnetAddress = (address) => bitcoin.isValidAddressForNetwork(address, "mainnet");
|
|
48
|
-
var validateBitcoinTestnetAddress = (address) => bitcoin.isValidAddressForNetwork(address, "testnet");
|
|
49
|
-
var validateBitcoinRegtestAddress = (address) => bitcoin.isValidAddressForNetwork(address, "regtest");
|
|
50
|
-
var validateSolanaAddress = isValidSolanaAddress;
|
|
51
|
-
var validators = {
|
|
52
|
-
mainnet: {
|
|
53
|
-
Bitcoin: validateBitcoinMainnetAddress,
|
|
54
|
-
Ethereum: validateEvmAddress,
|
|
55
|
-
Polkadot: validatePolkadotAddress,
|
|
56
|
-
Arbitrum: validateEvmAddress,
|
|
57
|
-
Solana: validateSolanaAddress
|
|
58
|
-
},
|
|
59
|
-
perseverance: {
|
|
60
|
-
Bitcoin: validateBitcoinTestnetAddress,
|
|
61
|
-
Ethereum: validateEvmAddress,
|
|
62
|
-
Polkadot: validatePolkadotAddress,
|
|
63
|
-
Arbitrum: validateEvmAddress,
|
|
64
|
-
Solana: validateSolanaAddress
|
|
65
|
-
},
|
|
66
|
-
sisyphos: {
|
|
67
|
-
Bitcoin: validateBitcoinTestnetAddress,
|
|
68
|
-
Ethereum: validateEvmAddress,
|
|
69
|
-
Polkadot: validatePolkadotAddress,
|
|
70
|
-
Arbitrum: validateEvmAddress,
|
|
71
|
-
Solana: validateSolanaAddress
|
|
72
|
-
},
|
|
73
|
-
backspin: {
|
|
74
|
-
Bitcoin: validateBitcoinRegtestAddress,
|
|
75
|
-
Ethereum: validateEvmAddress,
|
|
76
|
-
Polkadot: validatePolkadotAddress,
|
|
77
|
-
Arbitrum: validateEvmAddress,
|
|
78
|
-
Solana: validateSolanaAddress
|
|
79
|
-
},
|
|
80
|
-
localnet: {
|
|
81
|
-
Bitcoin: validateBitcoinRegtestAddress,
|
|
82
|
-
Ethereum: validateEvmAddress,
|
|
83
|
-
Polkadot: validatePolkadotAddress,
|
|
84
|
-
Arbitrum: validateEvmAddress,
|
|
85
|
-
Solana: validateSolanaAddress
|
|
86
|
-
}
|
|
87
|
-
};
|
|
88
|
-
var validateAddress = (chain2, address, network) => validators[network][chain2](address);
|
|
89
|
-
|
|
90
|
-
// ../shared/src/parsers.ts
|
|
91
|
-
var chainflipSS58Prefix = 2112;
|
|
92
|
-
var enumValues = Object.values;
|
|
93
|
-
var safeStringify = (obj) => JSON.stringify(obj, (key, value) => typeof value === "bigint" ? value.toString() : value);
|
|
94
|
-
var errorMap = (_issue, context) => ({
|
|
95
|
-
message: `received: ${safeStringify(context.data)}`
|
|
96
|
-
});
|
|
97
|
-
var string = z.string({ errorMap });
|
|
98
|
-
var number = z.number({ errorMap });
|
|
99
|
-
var booleanString = string.regex(/^(true|false)$/i).transform((v) => v.toLowerCase() === "true");
|
|
100
|
-
var numericString = string.regex(/^[0-9]+$/);
|
|
101
|
-
var numericOrEmptyString = string.regex(/^[0-9]*$/);
|
|
102
|
-
var hexString = string.refine((v) => /^0x[0-9a-f]*$/i.test(v));
|
|
76
|
+
var booleanString = zod.z.string().regex(/^(true|false)$/i).transform((v) => v.toLowerCase() === "true");
|
|
77
|
+
var numericString = zod.z.string().regex(/^[0-9]+$/);
|
|
78
|
+
var numericOrEmptyString = zod.z.string().regex(/^[0-9]*$/);
|
|
79
|
+
var hexString = zod.z.string().refine((v) => /^0x[0-9a-f]*$/i.test(v));
|
|
103
80
|
var hexStringWithMaxByteSize = (maxByteSize) => hexString.refine((val) => val.length / 2 <= maxByteSize + 1, {
|
|
104
81
|
message: `String must be less than or equal to ${maxByteSize} bytes`
|
|
105
82
|
});
|
|
106
83
|
var DOT_PREFIX = 0;
|
|
107
|
-
z.
|
|
108
|
-
|
|
109
|
-
if (arg.startsWith("0x")) {
|
|
110
|
-
return ss582.encode({ data: arg, ss58Format: DOT_PREFIX });
|
|
111
|
-
}
|
|
112
|
-
return ss582.encode({ data: ss582.decode(arg).data, ss58Format: DOT_PREFIX });
|
|
113
|
-
} catch {
|
|
114
|
-
return null;
|
|
115
|
-
}
|
|
116
|
-
}).refine(isString, {
|
|
117
|
-
message: `address is not a valid polkadot address`
|
|
118
|
-
});
|
|
119
|
-
hexString.refine(
|
|
120
|
-
(address) => ethers.isAddress(address),
|
|
121
|
-
(address) => ({ message: `${address} is not a valid Ethereum address` })
|
|
122
|
-
);
|
|
123
|
-
var chainflipAddress = string.refine(
|
|
124
|
-
(address) => address.startsWith("cF") && ss582.decode(address),
|
|
84
|
+
var chainflipAddress = zod.z.string().refine(
|
|
85
|
+
(address) => address.startsWith("cF") && ss58__namespace.decode(address),
|
|
125
86
|
(address) => ({ message: `${address} is not a valid Chainflip address` })
|
|
126
87
|
);
|
|
127
|
-
var solanaAddress = string.refine(isValidSolanaAddress, (address) => ({
|
|
88
|
+
var solanaAddress = zod.z.string().refine(solana.isValidSolanaAddress, (address) => ({
|
|
128
89
|
message: `${address} is not a valid Solana address`
|
|
129
90
|
}));
|
|
130
|
-
numericString.transform((arg) => BigInt(arg));
|
|
131
|
-
var
|
|
132
|
-
var
|
|
133
|
-
var
|
|
134
|
-
|
|
135
|
-
|
|
136
|
-
|
|
137
|
-
var asset = z.nativeEnum(Assets);
|
|
138
|
-
z.nativeEnum(ChainflipNetworks);
|
|
139
|
-
var uncheckedAssetAndChain = z.object({
|
|
140
|
-
asset: z.string(),
|
|
141
|
-
chain: z.string()
|
|
91
|
+
var u128 = zod.z.union([zod.z.number(), numericString, hexString]).transform((arg) => BigInt(arg));
|
|
92
|
+
var unsignedInteger = zod.z.union([u128, zod.z.number().transform((n) => BigInt(n))]);
|
|
93
|
+
var chain = zod.z.enum(chainflip.chainflipChains);
|
|
94
|
+
var asset = zod.z.enum(chainflip.assetSymbols);
|
|
95
|
+
var uncheckedAssetAndChain = zod.z.object({
|
|
96
|
+
asset: zod.z.string(),
|
|
97
|
+
chain: zod.z.string()
|
|
142
98
|
});
|
|
143
99
|
var assetAndChain = uncheckedAssetAndChain.refine(
|
|
144
|
-
(value) => isValidAssetAndChain(value)
|
|
145
|
-
);
|
|
146
|
-
z.union([
|
|
147
|
-
hexString,
|
|
148
|
-
//
|
|
149
|
-
string.regex(/^[a-f\d]$/i).transform((value) => `0x${value}`)
|
|
150
|
-
]).transform(
|
|
151
|
-
(value) => ss582.encode({ data: value, ss58Format: chainflipSS58Prefix })
|
|
100
|
+
(value) => chainflip.isValidAssetAndChain(value)
|
|
152
101
|
);
|
|
153
|
-
z.
|
|
154
|
-
z.object({ __kind: z.literal("Swap"), swapId: u128 }),
|
|
155
|
-
z.object({ __kind: z.literal("LiquidityProvision"), lpAccount: hexString }),
|
|
156
|
-
z.object({
|
|
157
|
-
__kind: z.literal("CcmTransfer"),
|
|
158
|
-
principalSwapId: u128.nullable().optional(),
|
|
159
|
-
gasSwapId: u128.nullable().optional()
|
|
160
|
-
}),
|
|
161
|
-
z.object({
|
|
162
|
-
__kind: z.literal("NoAction")
|
|
163
|
-
}),
|
|
164
|
-
z.object({
|
|
165
|
-
__kind: z.literal("BoostersCredited"),
|
|
166
|
-
prewitnessedDepositId: u128
|
|
167
|
-
})
|
|
168
|
-
]);
|
|
169
|
-
hexString.transform((value) => base58.encode(hexToBytes(value)));
|
|
170
|
-
z.object({
|
|
102
|
+
zod.z.object({
|
|
171
103
|
srcChain: chain,
|
|
172
104
|
srcAsset: asset,
|
|
173
105
|
destChain: chain,
|
|
174
106
|
destAsset: asset,
|
|
175
107
|
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" }),
|
|
176
108
|
brokerCommissionBps: numericOrEmptyString.transform((v) => Number(v)).optional(),
|
|
177
|
-
ccmGasBudget: z.union([
|
|
109
|
+
ccmGasBudget: zod.z.union([
|
|
178
110
|
numericString.transform((v) => BigInt(v)),
|
|
179
|
-
z.literal("undefined").transform(() => void 0)
|
|
111
|
+
zod.z.literal("undefined").transform(() => void 0)
|
|
180
112
|
// sdk version 1.8.2 sends undefined string if not set
|
|
181
113
|
]).optional(),
|
|
182
|
-
ccmMessageLengthBytes: z.union([
|
|
114
|
+
ccmMessageLengthBytes: zod.z.union([
|
|
183
115
|
numericString.transform((v) => Number(v)),
|
|
184
|
-
z.literal("undefined").transform(() => void 0)
|
|
116
|
+
zod.z.literal("undefined").transform(() => void 0)
|
|
185
117
|
// sdk version 1.8.2 sends undefined string if not set
|
|
186
118
|
]).optional(),
|
|
187
119
|
dcaEnabled: booleanString.default("false"),
|
|
188
120
|
isVaultSwap: booleanString.default("false")
|
|
189
121
|
}).transform((args, ctx) => {
|
|
190
|
-
const { srcAsset, destAsset } = getInternalAssets(args, false);
|
|
122
|
+
const { srcAsset, destAsset } = chainflip.getInternalAssets(args, false);
|
|
191
123
|
if (srcAsset === null) {
|
|
192
124
|
ctx.addIssue({
|
|
193
125
|
message: `invalid asset and chain combination: ${JSON.stringify({ asset: args.srcAsset, chain: args.srcChain })}`,
|
|
194
|
-
code: z.ZodIssueCode.custom
|
|
126
|
+
code: zod.z.ZodIssueCode.custom
|
|
195
127
|
});
|
|
196
|
-
return z.NEVER;
|
|
128
|
+
return zod.z.NEVER;
|
|
197
129
|
}
|
|
198
130
|
if (destAsset === null) {
|
|
199
131
|
ctx.addIssue({
|
|
200
132
|
message: `invalid asset and chain combination: ${JSON.stringify({ asset: args.destAsset, chain: args.destChain })}`,
|
|
201
|
-
code: z.ZodIssueCode.custom
|
|
133
|
+
code: zod.z.ZodIssueCode.custom
|
|
202
134
|
});
|
|
203
|
-
return z.NEVER;
|
|
135
|
+
return zod.z.NEVER;
|
|
204
136
|
}
|
|
205
137
|
if (args.ccmGasBudget !== void 0 && args.ccmMessageLengthBytes === void 0) {
|
|
206
138
|
ctx.addIssue({
|
|
207
139
|
message: `ccmMessageLengthBytes must be set if ccmGasBudget is set`,
|
|
208
|
-
code: z.ZodIssueCode.custom
|
|
140
|
+
code: zod.z.ZodIssueCode.custom
|
|
209
141
|
});
|
|
210
|
-
return z.NEVER;
|
|
142
|
+
return zod.z.NEVER;
|
|
211
143
|
}
|
|
212
144
|
if (args.ccmGasBudget === void 0 && args.ccmMessageLengthBytes !== void 0) {
|
|
213
145
|
ctx.addIssue({
|
|
214
146
|
message: `ccmGasBudget must be set if ccmMessageLengthBytes is set`,
|
|
215
|
-
code: z.ZodIssueCode.custom
|
|
147
|
+
code: zod.z.ZodIssueCode.custom
|
|
216
148
|
});
|
|
217
|
-
return z.NEVER;
|
|
149
|
+
return zod.z.NEVER;
|
|
218
150
|
}
|
|
219
151
|
const ccmParams = args.ccmGasBudget !== void 0 && args.ccmMessageLengthBytes !== void 0 ? { gasBudget: args.ccmGasBudget, messageLengthBytes: args.ccmMessageLengthBytes } : void 0;
|
|
220
152
|
return {
|
|
@@ -227,8 +159,8 @@ z.object({
|
|
|
227
159
|
isVaultSwap: args.isVaultSwap
|
|
228
160
|
};
|
|
229
161
|
});
|
|
230
|
-
var ccmParamsSchema = z.object({
|
|
231
|
-
gasBudget: z.union([numericString, hexString]).transform((n) => hexEncodeNumber(BigInt(n))),
|
|
162
|
+
var ccmParamsSchema = zod.z.object({
|
|
163
|
+
gasBudget: zod.z.union([numericString, hexString]).transform((n) => number.hexEncodeNumber(BigInt(n))),
|
|
232
164
|
// https://github.com/chainflip-io/chainflip-backend/blob/415aa9e20ec4046c68892cd34798e5d831c5b83f/state-chain/chains/src/lib.rs#L709
|
|
233
165
|
message: hexStringWithMaxByteSize(15e3),
|
|
234
166
|
// https://github.com/chainflip-io/chainflip-backend/blob/415aa9e20ec4046c68892cd34798e5d831c5b83f/state-chain/chains/src/lib.rs#L710
|
|
@@ -240,24 +172,81 @@ var ccmParamsSchema = z.object({
|
|
|
240
172
|
message,
|
|
241
173
|
ccmAdditionalData: ccmAdditionalData ?? cfParameters
|
|
242
174
|
}));
|
|
243
|
-
var affiliateBroker = z.object({
|
|
175
|
+
var affiliateBroker = zod.z.object({
|
|
244
176
|
account: chainflipAddress,
|
|
245
|
-
commissionBps: number
|
|
177
|
+
commissionBps: zod.z.number()
|
|
246
178
|
}).transform(({ account, commissionBps: bps }) => ({ account, bps }));
|
|
247
|
-
var dcaParams = z.object({
|
|
248
|
-
numberOfChunks: number,
|
|
249
|
-
chunkIntervalBlocks: number
|
|
179
|
+
var dcaParams = zod.z.object({
|
|
180
|
+
numberOfChunks: zod.z.number(),
|
|
181
|
+
chunkIntervalBlocks: zod.z.number()
|
|
250
182
|
});
|
|
251
|
-
z.object({
|
|
252
|
-
retryDurationBlocks: number,
|
|
253
|
-
refundAddress: z.string(),
|
|
183
|
+
zod.z.object({
|
|
184
|
+
retryDurationBlocks: zod.z.number(),
|
|
185
|
+
refundAddress: zod.z.string(),
|
|
254
186
|
minPriceX128: numericString
|
|
255
187
|
});
|
|
188
|
+
var validatePolkadotAddress = (address) => {
|
|
189
|
+
if (string.isHex(address)) return address.length === 66;
|
|
190
|
+
try {
|
|
191
|
+
ss58__namespace.decode(address);
|
|
192
|
+
return true;
|
|
193
|
+
} catch {
|
|
194
|
+
return false;
|
|
195
|
+
}
|
|
196
|
+
};
|
|
197
|
+
var validateEvmAddress = (address) => ethers__namespace.isAddress(address);
|
|
198
|
+
var validateBitcoinMainnetAddress = (address) => bitcoin__namespace.isValidAddressForNetwork(address, "mainnet");
|
|
199
|
+
var validateBitcoinTestnetAddress = (address) => bitcoin__namespace.isValidAddressForNetwork(address, "testnet");
|
|
200
|
+
var validateBitcoinRegtestAddress = (address) => bitcoin__namespace.isValidAddressForNetwork(address, "regtest");
|
|
201
|
+
var validateSolanaAddress = solana.isValidSolanaAddress;
|
|
202
|
+
var validators = {
|
|
203
|
+
mainnet: {
|
|
204
|
+
Bitcoin: validateBitcoinMainnetAddress,
|
|
205
|
+
Ethereum: validateEvmAddress,
|
|
206
|
+
Polkadot: validatePolkadotAddress,
|
|
207
|
+
Arbitrum: validateEvmAddress,
|
|
208
|
+
Solana: validateSolanaAddress,
|
|
209
|
+
Assethub: validatePolkadotAddress
|
|
210
|
+
},
|
|
211
|
+
perseverance: {
|
|
212
|
+
Bitcoin: validateBitcoinTestnetAddress,
|
|
213
|
+
Ethereum: validateEvmAddress,
|
|
214
|
+
Polkadot: validatePolkadotAddress,
|
|
215
|
+
Arbitrum: validateEvmAddress,
|
|
216
|
+
Solana: validateSolanaAddress,
|
|
217
|
+
Assethub: validatePolkadotAddress
|
|
218
|
+
},
|
|
219
|
+
sisyphos: {
|
|
220
|
+
Bitcoin: validateBitcoinTestnetAddress,
|
|
221
|
+
Ethereum: validateEvmAddress,
|
|
222
|
+
Polkadot: validatePolkadotAddress,
|
|
223
|
+
Arbitrum: validateEvmAddress,
|
|
224
|
+
Solana: validateSolanaAddress,
|
|
225
|
+
Assethub: validatePolkadotAddress
|
|
226
|
+
},
|
|
227
|
+
backspin: {
|
|
228
|
+
Bitcoin: validateBitcoinRegtestAddress,
|
|
229
|
+
Ethereum: validateEvmAddress,
|
|
230
|
+
Polkadot: validatePolkadotAddress,
|
|
231
|
+
Arbitrum: validateEvmAddress,
|
|
232
|
+
Solana: validateSolanaAddress,
|
|
233
|
+
Assethub: validatePolkadotAddress
|
|
234
|
+
},
|
|
235
|
+
localnet: {
|
|
236
|
+
Bitcoin: validateBitcoinRegtestAddress,
|
|
237
|
+
Ethereum: validateEvmAddress,
|
|
238
|
+
Polkadot: validatePolkadotAddress,
|
|
239
|
+
Arbitrum: validateEvmAddress,
|
|
240
|
+
Solana: validateSolanaAddress,
|
|
241
|
+
Assethub: validatePolkadotAddress
|
|
242
|
+
}
|
|
243
|
+
};
|
|
244
|
+
var validateAddress = (chain2, address, network) => validators[network][chain2](address);
|
|
256
245
|
|
|
257
246
|
// ../shared/src/broker.ts
|
|
258
|
-
var transformedFokSchema = z.object({
|
|
259
|
-
retryDurationBlocks: number,
|
|
260
|
-
refundAddress: z.string(),
|
|
247
|
+
var transformedFokSchema = zod.z.object({
|
|
248
|
+
retryDurationBlocks: zod.z.number(),
|
|
249
|
+
refundAddress: zod.z.string(),
|
|
261
250
|
minPriceX128: numericString
|
|
262
251
|
}).transform(({ retryDurationBlocks, refundAddress, minPriceX128 }) => ({
|
|
263
252
|
retry_duration: retryDurationBlocks,
|
|
@@ -279,69 +268,69 @@ var transformedCcmParamsSchema = ccmParamsSchema.transform(
|
|
|
279
268
|
cf_parameters: ccmAdditionalData
|
|
280
269
|
})
|
|
281
270
|
);
|
|
282
|
-
var getDepositAddressRequestSchema = (network) => z.object({
|
|
271
|
+
var getDepositAddressRequestSchema = (network) => zod.z.object({
|
|
283
272
|
srcAsset: assetAndChain,
|
|
284
273
|
destAsset: assetAndChain,
|
|
285
|
-
destAddress: z.string(),
|
|
286
|
-
commissionBps: z.number().optional().default(0),
|
|
274
|
+
destAddress: zod.z.string(),
|
|
275
|
+
commissionBps: zod.z.number().optional().default(0),
|
|
287
276
|
ccmParams: transformedCcmParamsSchema.optional(),
|
|
288
|
-
maxBoostFeeBps: z.number().optional(),
|
|
289
|
-
affiliates: z.array(affiliateBroker).optional(),
|
|
277
|
+
maxBoostFeeBps: zod.z.number().optional(),
|
|
278
|
+
affiliates: zod.z.array(affiliateBroker).optional(),
|
|
290
279
|
fillOrKillParams: transformedFokSchema,
|
|
291
280
|
dcaParams: transformedDcaParamsSchema.optional()
|
|
292
281
|
}).superRefine((val, ctx) => {
|
|
293
282
|
if (!validateAddress(val.destAsset.chain, val.destAddress, network)) {
|
|
294
283
|
ctx.addIssue({
|
|
295
284
|
message: `Address "${val.destAddress}" is not a valid "${val.destAsset.chain}" address for "${network}"`,
|
|
296
|
-
code: z.ZodIssueCode.custom
|
|
285
|
+
code: zod.z.ZodIssueCode.custom
|
|
297
286
|
});
|
|
298
287
|
}
|
|
299
288
|
}).superRefine((val, ctx) => {
|
|
300
289
|
if (!validateAddress(val.srcAsset.chain, val.fillOrKillParams.refund_address, network)) {
|
|
301
290
|
ctx.addIssue({
|
|
302
291
|
message: `Address "${val.fillOrKillParams.refund_address}" is not a valid "${val.srcAsset.chain}" address for "${network}"`,
|
|
303
|
-
code: z.ZodIssueCode.custom
|
|
292
|
+
code: zod.z.ZodIssueCode.custom
|
|
304
293
|
});
|
|
305
294
|
}
|
|
306
295
|
});
|
|
307
|
-
var getParameterEncodingRequestSchema = (network) => z.object({
|
|
296
|
+
var getParameterEncodingRequestSchema = (network) => zod.z.object({
|
|
308
297
|
srcAsset: assetAndChain,
|
|
309
|
-
srcAddress: z.string().optional(),
|
|
298
|
+
srcAddress: zod.z.string().optional(),
|
|
310
299
|
destAsset: assetAndChain,
|
|
311
|
-
destAddress: z.string(),
|
|
300
|
+
destAddress: zod.z.string(),
|
|
312
301
|
amount: unsignedInteger,
|
|
313
|
-
commissionBps: z.number().optional().default(0),
|
|
302
|
+
commissionBps: zod.z.number().optional().default(0),
|
|
314
303
|
ccmParams: transformedCcmParamsSchema.optional(),
|
|
315
|
-
maxBoostFeeBps: z.number().optional(),
|
|
316
|
-
affiliates: z.array(affiliateBroker).optional(),
|
|
304
|
+
maxBoostFeeBps: zod.z.number().optional(),
|
|
305
|
+
affiliates: zod.z.array(affiliateBroker).optional(),
|
|
317
306
|
fillOrKillParams: transformedFokSchema,
|
|
318
307
|
dcaParams: transformedDcaParamsSchema.optional(),
|
|
319
|
-
extraParams: z.object({ solanaDataAccount: solanaAddress.optional() }).optional()
|
|
308
|
+
extraParams: zod.z.object({ solanaDataAccount: solanaAddress.optional() }).optional()
|
|
320
309
|
}).superRefine((val, ctx) => {
|
|
321
310
|
if (val.srcAddress && !validateAddress(val.srcAsset.chain, val.srcAddress, network)) {
|
|
322
311
|
ctx.addIssue({
|
|
323
312
|
message: `Address "${val.srcAddress}" is not a valid "${val.srcAsset.chain}" address for "${network}"`,
|
|
324
|
-
code: z.ZodIssueCode.custom
|
|
313
|
+
code: zod.z.ZodIssueCode.custom
|
|
325
314
|
});
|
|
326
315
|
}
|
|
327
316
|
}).superRefine((val, ctx) => {
|
|
328
317
|
if (!validateAddress(val.destAsset.chain, val.destAddress, network)) {
|
|
329
318
|
ctx.addIssue({
|
|
330
319
|
message: `Address "${val.destAddress}" is not a valid "${val.destAsset.chain}" address for "${network}"`,
|
|
331
|
-
code: z.ZodIssueCode.custom
|
|
320
|
+
code: zod.z.ZodIssueCode.custom
|
|
332
321
|
});
|
|
333
322
|
}
|
|
334
323
|
}).superRefine((val, ctx) => {
|
|
335
324
|
if (!validateAddress(val.srcAsset.chain, val.fillOrKillParams.refund_address, network)) {
|
|
336
325
|
ctx.addIssue({
|
|
337
326
|
message: `Address "${val.fillOrKillParams.refund_address}" is not a valid "${val.srcAsset.chain}" address for "${network}"`,
|
|
338
|
-
code: z.ZodIssueCode.custom
|
|
327
|
+
code: zod.z.ZodIssueCode.custom
|
|
339
328
|
});
|
|
340
329
|
}
|
|
341
330
|
}).transform((data) => {
|
|
342
331
|
let extraParams;
|
|
343
332
|
if (data.srcAsset.chain === "Bitcoin") {
|
|
344
|
-
const minOutputAmount =
|
|
333
|
+
const minOutputAmount = BigNumber2__default.default(data.amount.toString()).multipliedBy(tickMath.priceX128ToPrice(data.fillOrKillParams.min_price)).toFixed(0);
|
|
345
334
|
extraParams = {
|
|
346
335
|
chain: "Bitcoin",
|
|
347
336
|
min_output_amount: `0x${BigInt(minOutputAmount).toString(16)}`,
|
|
@@ -368,15 +357,15 @@ var getParameterEncodingRequestSchema = (network) => z.object({
|
|
|
368
357
|
}
|
|
369
358
|
return { ...data, extraParams };
|
|
370
359
|
});
|
|
371
|
-
async function requestSwapDepositAddress(request, opts,
|
|
372
|
-
const client = new HttpClient(opts.url);
|
|
360
|
+
async function requestSwapDepositAddress(request, opts, chainflipNetwork) {
|
|
361
|
+
const client = new rpc.HttpClient(opts.url);
|
|
373
362
|
if (request.srcChain && typeof request.srcAsset === "string") {
|
|
374
363
|
request = { ...request, srcAsset: { asset: request.srcAsset, chain: request.srcChain } };
|
|
375
364
|
}
|
|
376
365
|
if (request.destChain && typeof request.destAsset === "string") {
|
|
377
366
|
request = { ...request, destAsset: { asset: request.destAsset, chain: request.destChain } };
|
|
378
367
|
}
|
|
379
|
-
const params = getDepositAddressRequestSchema(
|
|
368
|
+
const params = getDepositAddressRequestSchema(chainflipNetwork).parse(request);
|
|
380
369
|
const response = await client.sendRequest(
|
|
381
370
|
"broker_request_swap_deposit_address",
|
|
382
371
|
params.srcAsset,
|
|
@@ -389,14 +378,14 @@ async function requestSwapDepositAddress(request, opts, chainflipNetwork2) {
|
|
|
389
378
|
params.fillOrKillParams,
|
|
390
379
|
params.dcaParams
|
|
391
380
|
);
|
|
392
|
-
if (params.srcAsset.chain === "Polkadot" && isHex(response.address)) {
|
|
393
|
-
response.address =
|
|
381
|
+
if (params.srcAsset.chain === "Polkadot" && string.isHex(response.address)) {
|
|
382
|
+
response.address = ss58__namespace.encode({ data: response.address, ss58Format: DOT_PREFIX });
|
|
394
383
|
}
|
|
395
384
|
return transformKeysToCamelCase(response);
|
|
396
385
|
}
|
|
397
|
-
async function requestSwapParameterEncoding(request, opts,
|
|
398
|
-
const client = new HttpClient(opts.url);
|
|
399
|
-
const params = getParameterEncodingRequestSchema(
|
|
386
|
+
async function requestSwapParameterEncoding(request, opts, chainflipNetwork) {
|
|
387
|
+
const client = new rpc.HttpClient(opts.url);
|
|
388
|
+
const params = getParameterEncodingRequestSchema(chainflipNetwork).parse(request);
|
|
400
389
|
const response = await client.sendRequest(
|
|
401
390
|
"broker_request_swap_parameter_encoding",
|
|
402
391
|
params.srcAsset,
|
|
@@ -413,80 +402,31 @@ async function requestSwapParameterEncoding(request, opts, chainflipNetwork2) {
|
|
|
413
402
|
}
|
|
414
403
|
|
|
415
404
|
// ../shared/src/dataStructures.ts
|
|
416
|
-
var
|
|
417
|
-
constructor(
|
|
418
|
-
this.
|
|
419
|
-
|
|
420
|
-
|
|
421
|
-
|
|
422
|
-
|
|
423
|
-
|
|
424
|
-
|
|
425
|
-
|
|
426
|
-
|
|
427
|
-
|
|
428
|
-
|
|
429
|
-
|
|
430
|
-
|
|
431
|
-
|
|
432
|
-
|
|
433
|
-
}
|
|
434
|
-
clear() {
|
|
435
|
-
if (this.timeout) clearTimeout(this.timeout);
|
|
436
|
-
}
|
|
437
|
-
};
|
|
438
|
-
var CacheMap = class {
|
|
439
|
-
constructor(ttl, resetExpiryOnLookup = true) {
|
|
440
|
-
this.ttl = ttl;
|
|
441
|
-
this.resetExpiryOnLookup = resetExpiryOnLookup;
|
|
442
|
-
}
|
|
443
|
-
store = /* @__PURE__ */ new Map();
|
|
444
|
-
set(key, value) {
|
|
445
|
-
this.delete(key);
|
|
446
|
-
const timer = new Timer(value, () => this.store.delete(key), this.ttl);
|
|
447
|
-
this.store.set(key, timer);
|
|
448
|
-
return this;
|
|
449
|
-
}
|
|
450
|
-
get(key) {
|
|
451
|
-
return this.store.get(key)?.getValue(this.resetExpiryOnLookup);
|
|
452
|
-
}
|
|
453
|
-
delete(key) {
|
|
454
|
-
this.store.get(key)?.clear();
|
|
455
|
-
return this.store.delete(key);
|
|
456
|
-
}
|
|
457
|
-
};
|
|
458
|
-
var AsyncCacheMap = class extends CacheMap {
|
|
459
|
-
fetch;
|
|
460
|
-
constructor({
|
|
461
|
-
fetch,
|
|
462
|
-
ttl,
|
|
463
|
-
resetExpiryOnLookup = true
|
|
464
|
-
}) {
|
|
465
|
-
super(ttl, resetExpiryOnLookup);
|
|
466
|
-
this.fetch = fetch;
|
|
467
|
-
}
|
|
468
|
-
get(key) {
|
|
469
|
-
let promise = super.get(key);
|
|
470
|
-
if (!promise) {
|
|
471
|
-
promise = this.fetch(key).catch((err) => {
|
|
472
|
-
this.delete(key);
|
|
473
|
-
throw err;
|
|
474
|
-
});
|
|
475
|
-
this.set(key, promise);
|
|
405
|
+
var Cache = class {
|
|
406
|
+
constructor(fetchers) {
|
|
407
|
+
this.fetchers = fetchers;
|
|
408
|
+
}
|
|
409
|
+
values = {};
|
|
410
|
+
read(type) {
|
|
411
|
+
const { fetch, ttl } = this.fetchers[type];
|
|
412
|
+
let cached = this.values[type];
|
|
413
|
+
if (!cached || cached.timestamp + ttl < Date.now()) {
|
|
414
|
+
cached = {
|
|
415
|
+
timestamp: Date.now(),
|
|
416
|
+
value: fetch().catch((err) => {
|
|
417
|
+
this.values[type] = void 0;
|
|
418
|
+
throw err;
|
|
419
|
+
})
|
|
420
|
+
};
|
|
421
|
+
this.values[type] = cached;
|
|
476
422
|
}
|
|
477
|
-
return
|
|
478
|
-
}
|
|
479
|
-
load(key) {
|
|
480
|
-
return this.get(key).then(
|
|
481
|
-
() => true,
|
|
482
|
-
() => false
|
|
483
|
-
);
|
|
423
|
+
return cached.value;
|
|
484
424
|
}
|
|
485
425
|
};
|
|
486
|
-
var getPriceX128FromPrice = (price, srcAsset, destAsset) =>
|
|
426
|
+
var getPriceX128FromPrice = (price, srcAsset, destAsset) => BigNumber2__default.default(price).multipliedBy(new BigNumber2__default.default(2).pow(128)).shiftedBy(chainflip.assetConstants[destAsset].decimals - chainflip.assetConstants[srcAsset].decimals).toFixed(0);
|
|
487
427
|
var parseFoKParams = (params, quote) => {
|
|
488
|
-
const srcAsset = getInternalAsset(quote.srcAsset);
|
|
489
|
-
const destAsset = getInternalAsset(quote.destAsset);
|
|
428
|
+
const srcAsset = chainflip.getInternalAsset(quote.srcAsset);
|
|
429
|
+
const destAsset = chainflip.getInternalAsset(quote.destAsset);
|
|
490
430
|
let minPrice;
|
|
491
431
|
if ("minPrice" in params) {
|
|
492
432
|
assert(
|
|
@@ -495,16 +435,16 @@ var parseFoKParams = (params, quote) => {
|
|
|
495
435
|
);
|
|
496
436
|
minPrice = params.minPrice;
|
|
497
437
|
} else if ("slippageTolerancePercent" in params) {
|
|
498
|
-
const tolerance = new
|
|
438
|
+
const tolerance = new BigNumber2__default.default(params.slippageTolerancePercent);
|
|
499
439
|
assert(!tolerance.isNaN(), "Invalid slippage tolerance");
|
|
500
440
|
assert(
|
|
501
441
|
tolerance.gte(0) && tolerance.lte(100),
|
|
502
442
|
"Slippage tolerance must be between 0 and 100 inclusive",
|
|
503
443
|
RangeError
|
|
504
444
|
);
|
|
505
|
-
const estimatedPrice = new
|
|
445
|
+
const estimatedPrice = new BigNumber2__default.default(quote.estimatedPrice);
|
|
506
446
|
assert(!estimatedPrice.isNaN(), "Invalid estimated price");
|
|
507
|
-
minPrice = estimatedPrice.times(new
|
|
447
|
+
minPrice = estimatedPrice.times(new BigNumber2__default.default(100).minus(tolerance).dividedBy(100)).toFixed(chainflip.assetConstants[destAsset].decimals);
|
|
508
448
|
} else {
|
|
509
449
|
throw new Error("Either minPrice or slippageTolerancePercent must be provided");
|
|
510
450
|
}
|
|
@@ -514,18 +454,39 @@ var parseFoKParams = (params, quote) => {
|
|
|
514
454
|
minPriceX128: getPriceX128FromPrice(minPrice, srcAsset, destAsset)
|
|
515
455
|
};
|
|
516
456
|
};
|
|
517
|
-
|
|
518
|
-
|
|
457
|
+
var isTestnet = (network) => network !== "mainnet";
|
|
458
|
+
var camelCase = (str) => str.replace(/_([a-z])/g, (_, char) => char.toUpperCase());
|
|
459
|
+
var camelCaseKeys = (obj) => {
|
|
460
|
+
if (typeof obj !== "object" || obj === null) return obj;
|
|
461
|
+
if (Array.isArray(obj)) return obj.map((item) => camelCaseKeys(item));
|
|
462
|
+
return Object.fromEntries(
|
|
463
|
+
Object.entries(obj).map(([key, value]) => [camelCase(key), camelCaseKeys(value)])
|
|
464
|
+
);
|
|
465
|
+
};
|
|
466
|
+
var createRequest = (method) => async (urlOrNetwork, ...params) => {
|
|
467
|
+
const url = "network" in urlOrNetwork ? rpc.constants.PUBLIC_RPC_ENDPOINTS[urlOrNetwork.network] : urlOrNetwork.rpcUrl;
|
|
468
|
+
const result = await new rpc.HttpClient(url).sendRequest(method, ...params);
|
|
469
|
+
return camelCaseKeys(result);
|
|
470
|
+
};
|
|
471
|
+
var transform = (fn, cb) => (...args) => fn(...args).then(cb);
|
|
472
|
+
var getEnvironment = createRequest("cf_environment");
|
|
473
|
+
var getAllBoostPoolsDepth = transform(
|
|
474
|
+
createRequest("cf_boost_pools_depth"),
|
|
475
|
+
(result) => result.map(({ chain: chain2, asset: asset2, ...rest }) => ({
|
|
476
|
+
asset: chainflip.getInternalAsset({ chain: chain2, asset: asset2 }),
|
|
477
|
+
...rest
|
|
478
|
+
}))
|
|
479
|
+
);
|
|
519
480
|
var MAX_SWAP_AMOUNT = 2n ** 128n - 1n;
|
|
520
481
|
var validateSwapAmount = (env, asset2, amount) => {
|
|
521
|
-
const minimumAmount =
|
|
482
|
+
const minimumAmount = chainflip.readAssetValue(env.ingressEgress.minimumDepositAmounts, asset2);
|
|
522
483
|
if (amount < minimumAmount) {
|
|
523
484
|
return {
|
|
524
485
|
success: false,
|
|
525
486
|
reason: `expected amount is below minimum swap amount (${minimumAmount})`
|
|
526
487
|
};
|
|
527
488
|
}
|
|
528
|
-
const maxAmount =
|
|
489
|
+
const maxAmount = chainflip.readAssetValue(env.swapping.maximumSwapAmounts, asset2) ?? MAX_SWAP_AMOUNT;
|
|
529
490
|
if (maxAmount != null && amount > maxAmount) {
|
|
530
491
|
return {
|
|
531
492
|
success: false,
|
|
@@ -534,6 +495,76 @@ var validateSwapAmount = (env, asset2, amount) => {
|
|
|
534
495
|
}
|
|
535
496
|
return { success: true };
|
|
536
497
|
};
|
|
498
|
+
|
|
499
|
+
// ../shared/src/consts.ts
|
|
500
|
+
var ETHEREUM_EVM_CHAIN_ID = {
|
|
501
|
+
backspin: 10997,
|
|
502
|
+
// backspin ethereum
|
|
503
|
+
sisyphos: 11155111,
|
|
504
|
+
// sepolia
|
|
505
|
+
perseverance: 11155111,
|
|
506
|
+
// sepolia
|
|
507
|
+
mainnet: 1
|
|
508
|
+
// mainnet
|
|
509
|
+
};
|
|
510
|
+
var ARBITRUM_EVM_CHAIN_ID = {
|
|
511
|
+
backspin: 412346,
|
|
512
|
+
// backspin arbitrum
|
|
513
|
+
sisyphos: 421614,
|
|
514
|
+
// arb-sepolia
|
|
515
|
+
perseverance: 421614,
|
|
516
|
+
// arb-sepolia
|
|
517
|
+
mainnet: 42161
|
|
518
|
+
// mainnet
|
|
519
|
+
};
|
|
520
|
+
var getEvmChainId = (chain2, network) => {
|
|
521
|
+
switch (chain2) {
|
|
522
|
+
case "Ethereum":
|
|
523
|
+
return ETHEREUM_EVM_CHAIN_ID[network];
|
|
524
|
+
case "Arbitrum":
|
|
525
|
+
return ARBITRUM_EVM_CHAIN_ID[network];
|
|
526
|
+
default:
|
|
527
|
+
return void 0;
|
|
528
|
+
}
|
|
529
|
+
};
|
|
530
|
+
var SEPOLIA_USDC_CONTRACT_ADDRESS = "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238";
|
|
531
|
+
var SEPOLIA_USDT_CONTRACT_ADDRESS = "0x27CEA6Eb8a21Aae05Eb29C91c5CA10592892F584";
|
|
532
|
+
var ADDRESSES = {
|
|
533
|
+
backspin: {
|
|
534
|
+
FLIP_CONTRACT_ADDRESS: "0x10C6E9530F1C1AF873a391030a1D9E8ed0630D26",
|
|
535
|
+
USDC_CONTRACT_ADDRESS: "0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0",
|
|
536
|
+
USDT_CONTRACT_ADDRESS: "0x0DCd1Bf9A1b36cE34237eEaFef220932846BCD82",
|
|
537
|
+
ARBUSDC_CONTRACT_ADDRESS: "0xCf7Ed3AccA5a467e9e704C703E8D87F634fB0Fc9",
|
|
538
|
+
STATE_CHAIN_GATEWAY_ADDRESS: "0xeEBe00Ac0756308ac4AaBfD76c05c4F3088B8883",
|
|
539
|
+
SOLUSDC_CONTRACT_ADDRESS: "24PNhTaNtomHhoy3fTRaMhAFCRj4uHqhZEEoWrKDbR5p"
|
|
540
|
+
},
|
|
541
|
+
sisyphos: {
|
|
542
|
+
FLIP_CONTRACT_ADDRESS: "0xcD079EAB6B5443b545788Fd210C8800FEADd87fa",
|
|
543
|
+
USDC_CONTRACT_ADDRESS: SEPOLIA_USDC_CONTRACT_ADDRESS,
|
|
544
|
+
USDT_CONTRACT_ADDRESS: SEPOLIA_USDT_CONTRACT_ADDRESS,
|
|
545
|
+
ARBUSDC_CONTRACT_ADDRESS: "0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d",
|
|
546
|
+
STATE_CHAIN_GATEWAY_ADDRESS: "0x1F7fE41C798cc7b1D34BdC8de2dDDA4a4bE744D9",
|
|
547
|
+
SOLUSDC_CONTRACT_ADDRESS: "4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU"
|
|
548
|
+
},
|
|
549
|
+
perseverance: {
|
|
550
|
+
FLIP_CONTRACT_ADDRESS: "0xdC27c60956cB065D19F08bb69a707E37b36d8086",
|
|
551
|
+
USDC_CONTRACT_ADDRESS: SEPOLIA_USDC_CONTRACT_ADDRESS,
|
|
552
|
+
USDT_CONTRACT_ADDRESS: SEPOLIA_USDT_CONTRACT_ADDRESS,
|
|
553
|
+
ARBUSDC_CONTRACT_ADDRESS: "0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d",
|
|
554
|
+
STATE_CHAIN_GATEWAY_ADDRESS: "0xA34a967197Ee90BB7fb28e928388a573c5CFd099",
|
|
555
|
+
SOLUSDC_CONTRACT_ADDRESS: "4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU"
|
|
556
|
+
},
|
|
557
|
+
mainnet: {
|
|
558
|
+
FLIP_CONTRACT_ADDRESS: "0x826180541412D574cf1336d22c0C0a287822678A",
|
|
559
|
+
USDC_CONTRACT_ADDRESS: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
|
|
560
|
+
USDT_CONTRACT_ADDRESS: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
|
|
561
|
+
ARBUSDC_CONTRACT_ADDRESS: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
|
|
562
|
+
STATE_CHAIN_GATEWAY_ADDRESS: "0x6995Ab7c4D7F4B03f467Cf4c8E920427d9621DBd",
|
|
563
|
+
SOLUSDC_CONTRACT_ADDRESS: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
|
|
564
|
+
}
|
|
565
|
+
};
|
|
566
|
+
|
|
567
|
+
// src/swap/assets.ts
|
|
537
568
|
var getTokenContractAddress = (asset2, network) => {
|
|
538
569
|
switch (asset2) {
|
|
539
570
|
case "Btc":
|
|
@@ -541,31 +572,43 @@ var getTokenContractAddress = (asset2, network) => {
|
|
|
541
572
|
case "Eth":
|
|
542
573
|
case "ArbEth":
|
|
543
574
|
case "Sol":
|
|
575
|
+
case "HubDot":
|
|
576
|
+
case "HubUsdc":
|
|
577
|
+
case "HubUsdt":
|
|
544
578
|
return void 0;
|
|
545
579
|
default:
|
|
546
|
-
return ADDRESSES[network][`${toUpperCase(asset2)}_CONTRACT_ADDRESS`];
|
|
580
|
+
return ADDRESSES[network][`${string.toUpperCase(asset2)}_CONTRACT_ADDRESS`];
|
|
547
581
|
}
|
|
548
582
|
};
|
|
583
|
+
var assetNames = {
|
|
584
|
+
Eth: "Ether",
|
|
585
|
+
Flip: "FLIP",
|
|
586
|
+
Usdc: "USDC",
|
|
587
|
+
Usdt: "USDT",
|
|
588
|
+
Dot: "Polkadot",
|
|
589
|
+
Btc: "Bitcoin",
|
|
590
|
+
ArbEth: "Arbitrum Ether",
|
|
591
|
+
ArbUsdc: "Arbitrum USDC",
|
|
592
|
+
Sol: "Solana",
|
|
593
|
+
SolUsdc: "Solana USDC",
|
|
594
|
+
HubDot: "Assethub DOT",
|
|
595
|
+
HubUsdc: "Assethub USDC",
|
|
596
|
+
HubUsdt: "Assethub USDT"
|
|
597
|
+
};
|
|
549
598
|
var getAssetData = (asset2, network, env) => {
|
|
550
|
-
const assetConstant = assetConstants[asset2];
|
|
599
|
+
const assetConstant = chainflip.assetConstants[asset2];
|
|
551
600
|
return {
|
|
552
601
|
chainflipId: asset2,
|
|
553
|
-
asset: assetConstant.
|
|
602
|
+
asset: assetConstant.symbol,
|
|
554
603
|
chain: assetConstant.chain,
|
|
555
604
|
contractAddress: getTokenContractAddress(asset2, network),
|
|
556
605
|
decimals: assetConstant.decimals,
|
|
557
|
-
name:
|
|
558
|
-
symbol: assetConstant.
|
|
606
|
+
name: assetNames[asset2],
|
|
607
|
+
symbol: assetConstant.symbol,
|
|
559
608
|
isMainnet: !isTestnet(network),
|
|
560
|
-
minimumSwapAmount:
|
|
561
|
-
|
|
562
|
-
|
|
563
|
-
).toString(),
|
|
564
|
-
maximumSwapAmount: readChainAssetValue(env.swapping.maximumSwapAmounts, asset2)?.toString() ?? null,
|
|
565
|
-
minimumEgressAmount: readChainAssetValue(
|
|
566
|
-
env.ingressEgress.minimumEgressAmounts,
|
|
567
|
-
asset2
|
|
568
|
-
).toString()
|
|
609
|
+
minimumSwapAmount: chainflip.readAssetValue(env.ingressEgress.minimumDepositAmounts, asset2).toString(),
|
|
610
|
+
maximumSwapAmount: chainflip.readAssetValue(env.swapping.maximumSwapAmounts, asset2)?.toString() ?? null,
|
|
611
|
+
minimumEgressAmount: chainflip.readAssetValue(env.ingressEgress.minimumEgressAmounts, asset2).toString()
|
|
569
612
|
};
|
|
570
613
|
};
|
|
571
614
|
|
|
@@ -576,46 +619,20 @@ var getChainData = (chain2, network, env) => ({
|
|
|
576
619
|
evmChainId: getEvmChainId(chain2, network),
|
|
577
620
|
isMainnet: !isTestnet(network),
|
|
578
621
|
requiredBlockConfirmations: isNotNullish(env.ingressEgress.witnessSafetyMargins[chain2]) ? Number(env.ingressEgress.witnessSafetyMargins[chain2]) + 1 : void 0,
|
|
579
|
-
maxRetryDurationBlocks: env.
|
|
622
|
+
maxRetryDurationBlocks: env.swapping.maxSwapRetryDurationBlocks
|
|
580
623
|
});
|
|
581
624
|
|
|
582
625
|
// package.json
|
|
583
|
-
var
|
|
626
|
+
var package_default = {
|
|
627
|
+
version: "1.9.0-beta.1"};
|
|
584
628
|
|
|
585
629
|
// src/swap/consts.ts
|
|
586
|
-
var CF_SDK_VERSION_HEADERS = { "X-Chainflip-Sdk-Version": version };
|
|
630
|
+
var CF_SDK_VERSION_HEADERS = { "X-Chainflip-Sdk-Version": package_default.version };
|
|
587
631
|
var BACKEND_SERVICE_URLS = {
|
|
588
|
-
|
|
589
|
-
|
|
590
|
-
|
|
591
|
-
|
|
592
|
-
};
|
|
593
|
-
var getQuote = async (baseUrl, quoteRequest, { signal }) => {
|
|
594
|
-
const affiliateCommissionBps = quoteRequest.affiliateBrokers?.reduce((acc, affiliate) => acc + affiliate.commissionBps, 0) ?? 0;
|
|
595
|
-
const totalBrokerCommissionBps = (quoteRequest.brokerCommissionBps ?? 0) + affiliateCommissionBps;
|
|
596
|
-
const params = {
|
|
597
|
-
amount: quoteRequest.amount,
|
|
598
|
-
srcChain: quoteRequest.srcChain,
|
|
599
|
-
srcAsset: quoteRequest.srcAsset,
|
|
600
|
-
destChain: quoteRequest.destChain,
|
|
601
|
-
destAsset: quoteRequest.destAsset,
|
|
602
|
-
isVaultSwap: String(Boolean(quoteRequest.isVaultSwap)),
|
|
603
|
-
...totalBrokerCommissionBps && {
|
|
604
|
-
brokerCommissionBps: String(totalBrokerCommissionBps)
|
|
605
|
-
},
|
|
606
|
-
...quoteRequest.ccmParams && {
|
|
607
|
-
ccmGasBudget: quoteRequest.ccmParams.gasBudget,
|
|
608
|
-
ccmMessageLengthBytes: String(quoteRequest.ccmParams.messageLengthBytes)
|
|
609
|
-
},
|
|
610
|
-
dcaEnabled: "false"
|
|
611
|
-
};
|
|
612
|
-
const { data } = await axios.get("/quote", {
|
|
613
|
-
baseURL: baseUrl,
|
|
614
|
-
params,
|
|
615
|
-
signal,
|
|
616
|
-
headers: CF_SDK_VERSION_HEADERS
|
|
617
|
-
});
|
|
618
|
-
return { ...quoteRequest, quote: data };
|
|
632
|
+
backspin: "https://chainflip-swap-backspin.staging/",
|
|
633
|
+
sisyphos: "https://chainflip-swap.staging/",
|
|
634
|
+
perseverance: "https://chainflip-swap-perseverance.chainflip.io/",
|
|
635
|
+
mainnet: "https://chainflip-swap.chainflip.io/"
|
|
619
636
|
};
|
|
620
637
|
var getQuoteV2 = async (baseUrl, quoteRequest, { signal }) => {
|
|
621
638
|
const affiliateCommissionBps = quoteRequest.affiliateBrokers?.reduce((acc, affiliate) => acc + affiliate.commissionBps, 0) ?? 0;
|
|
@@ -636,7 +653,7 @@ var getQuoteV2 = async (baseUrl, quoteRequest, { signal }) => {
|
|
|
636
653
|
},
|
|
637
654
|
dcaEnabled: String(Boolean(quoteRequest.dcaEnabled))
|
|
638
655
|
};
|
|
639
|
-
const { data } = await
|
|
656
|
+
const { data } = await axios__default.default.get("/v2/quote", {
|
|
640
657
|
baseURL: baseUrl,
|
|
641
658
|
params,
|
|
642
659
|
signal,
|
|
@@ -644,16 +661,8 @@ var getQuoteV2 = async (baseUrl, quoteRequest, { signal }) => {
|
|
|
644
661
|
});
|
|
645
662
|
return { ...quoteRequest, quotes: data };
|
|
646
663
|
};
|
|
647
|
-
var getStatus = async (baseUrl, { id }, { signal }) => {
|
|
648
|
-
const { data } = await axios.get(`/swaps/${id}`, {
|
|
649
|
-
baseURL: baseUrl,
|
|
650
|
-
signal,
|
|
651
|
-
headers: CF_SDK_VERSION_HEADERS
|
|
652
|
-
});
|
|
653
|
-
return data;
|
|
654
|
-
};
|
|
655
664
|
var getStatusV2 = async (baseUrl, { id }, { signal }) => {
|
|
656
|
-
const { data } = await
|
|
665
|
+
const { data } = await axios__default.default.get(`/v2/swaps/${id}`, {
|
|
657
666
|
baseURL: baseUrl,
|
|
658
667
|
signal,
|
|
659
668
|
headers: CF_SDK_VERSION_HEADERS
|
|
@@ -677,78 +686,74 @@ var SwapSDK = class {
|
|
|
677
686
|
options;
|
|
678
687
|
rpcConfig;
|
|
679
688
|
trpc;
|
|
680
|
-
|
|
681
|
-
supportedAssets;
|
|
689
|
+
cache;
|
|
682
690
|
dcaEnabled = false;
|
|
683
691
|
constructor(options = {}) {
|
|
684
|
-
const network = options.network ??
|
|
692
|
+
const network = options.network ?? "perseverance";
|
|
685
693
|
this.options = {
|
|
686
694
|
...options,
|
|
687
695
|
network,
|
|
688
696
|
backendUrl: options.backendUrl ?? BACKEND_SERVICE_URLS[network]
|
|
689
697
|
};
|
|
690
698
|
this.rpcConfig = options.rpcUrl ? { rpcUrl: options.rpcUrl } : { network };
|
|
691
|
-
this.trpc = createTRPCProxyClient({
|
|
692
|
-
transformer:
|
|
699
|
+
this.trpc = client.createTRPCProxyClient({
|
|
700
|
+
transformer: superjson__default.default,
|
|
693
701
|
links: [
|
|
694
|
-
httpBatchLink({
|
|
702
|
+
client.httpBatchLink({
|
|
695
703
|
url: new URL("/trpc", this.options.backendUrl),
|
|
696
704
|
headers: CF_SDK_VERSION_HEADERS
|
|
697
705
|
})
|
|
698
706
|
]
|
|
699
707
|
});
|
|
700
708
|
this.dcaEnabled = options.enabledFeatures?.dca ?? false;
|
|
701
|
-
this.
|
|
702
|
-
|
|
703
|
-
|
|
704
|
-
|
|
709
|
+
this.cache = new Cache({
|
|
710
|
+
environment: {
|
|
711
|
+
fetch: () => getEnvironment(this.rpcConfig),
|
|
712
|
+
ttl: 6e4
|
|
713
|
+
},
|
|
714
|
+
networkStatus: {
|
|
715
|
+
fetch: () => this.trpc.networkStatus.query(),
|
|
716
|
+
ttl: 6e4
|
|
717
|
+
}
|
|
705
718
|
});
|
|
706
719
|
}
|
|
707
|
-
async getChains(sourceChain) {
|
|
708
|
-
if (sourceChain && !(sourceChain
|
|
720
|
+
async getChains(sourceChain, type = "all") {
|
|
721
|
+
if (sourceChain && !chainflip.chainflipChains.includes(sourceChain)) {
|
|
709
722
|
throw new Error(`unsupported source chain "${sourceChain}"`);
|
|
723
|
+
}
|
|
710
724
|
const [env, supportedAssets] = await Promise.all([
|
|
711
725
|
this.getStateChainEnvironment(),
|
|
712
|
-
this.getSupportedAssets()
|
|
726
|
+
this.getSupportedAssets(type)
|
|
713
727
|
]);
|
|
714
|
-
const supportedChains =
|
|
715
|
-
|
|
728
|
+
const supportedChains = new Set(supportedAssets.map((a) => chainflip.assetConstants[a].chain));
|
|
729
|
+
if (sourceChain && !supportedChains.has(sourceChain)) return [];
|
|
730
|
+
return [...supportedChains].map((chain2) => getChainData(chain2, this.options.network, env)).filter((chain2) => chain2.chain !== sourceChain);
|
|
716
731
|
}
|
|
717
732
|
async getStateChainEnvironment() {
|
|
718
|
-
return this.
|
|
733
|
+
return this.cache.read("environment");
|
|
719
734
|
}
|
|
720
|
-
async getSupportedAssets() {
|
|
721
|
-
|
|
722
|
-
return
|
|
735
|
+
async getSupportedAssets(type) {
|
|
736
|
+
const assets = await this.cache.read("networkStatus");
|
|
737
|
+
return assets.assets[type];
|
|
723
738
|
}
|
|
724
739
|
async getBoostPoolsDepth() {
|
|
725
740
|
return getAllBoostPoolsDepth(this.rpcConfig);
|
|
726
741
|
}
|
|
727
|
-
async getAssets(chain2) {
|
|
728
|
-
if (chain2 && !(chain2
|
|
742
|
+
async getAssets(chain2, type = "all") {
|
|
743
|
+
if (chain2 && !chainflip.chainflipChains.includes(chain2)) throw new Error(`unsupported chain "${chain2}"`);
|
|
729
744
|
const [env, supportedAssets] = await Promise.all([
|
|
730
745
|
this.getStateChainEnvironment(),
|
|
731
|
-
this.getSupportedAssets()
|
|
746
|
+
this.getSupportedAssets(type)
|
|
732
747
|
]);
|
|
733
748
|
return supportedAssets.map((asset2) => getAssetData(asset2, this.options.network, env)).filter((asset2) => !chain2 || asset2.chain === chain2);
|
|
734
749
|
}
|
|
735
|
-
|
|
736
|
-
|
|
737
|
-
|
|
738
|
-
|
|
739
|
-
|
|
740
|
-
|
|
741
|
-
|
|
742
|
-
this.options.backendUrl,
|
|
743
|
-
{
|
|
744
|
-
...quoteRequest,
|
|
745
|
-
brokerCommissionBps: submitterBrokerCommissionBps
|
|
746
|
-
},
|
|
747
|
-
options
|
|
748
|
-
);
|
|
749
|
-
}
|
|
750
|
-
getQuoteV2(quoteRequest, options = {}) {
|
|
751
|
-
const submitterBrokerCommissionBps = quoteRequest.brokerCommissionBps ?? this.options.broker?.commissionBps ?? 0;
|
|
750
|
+
async getQuoteV2(quoteRequest, options = {}) {
|
|
751
|
+
let submitterBrokerCommissionBps;
|
|
752
|
+
if (this.options.broker) {
|
|
753
|
+
submitterBrokerCommissionBps = quoteRequest.brokerCommissionBps ?? this.options.broker?.commissionBps ?? 0;
|
|
754
|
+
} else {
|
|
755
|
+
submitterBrokerCommissionBps = (await this.cache.read("networkStatus")).cfBrokerCommissionBps;
|
|
756
|
+
}
|
|
752
757
|
return getQuoteV2(
|
|
753
758
|
this.options.backendUrl,
|
|
754
759
|
{
|
|
@@ -759,89 +764,12 @@ var SwapSDK = class {
|
|
|
759
764
|
options
|
|
760
765
|
);
|
|
761
766
|
}
|
|
762
|
-
/** @deprecated DEPRECATED(1.7) use requestDepositAddressV2() */
|
|
763
|
-
async requestDepositAddress(depositAddressRequest) {
|
|
764
|
-
console.error(
|
|
765
|
-
"[@chainflip/sdk] The requestDepositAddress method is deprecated and will be removed in the 1.9 release. Use the requestDepositAddressV2 method instead."
|
|
766
|
-
);
|
|
767
|
-
const {
|
|
768
|
-
srcChain,
|
|
769
|
-
srcAsset,
|
|
770
|
-
amount,
|
|
771
|
-
destChain,
|
|
772
|
-
destAsset,
|
|
773
|
-
brokerCommissionBps,
|
|
774
|
-
affiliateBrokers
|
|
775
|
-
} = depositAddressRequest;
|
|
776
|
-
await this.validateSwapAmount({ chain: srcChain, asset: srcAsset }, BigInt(amount));
|
|
777
|
-
const fillOrKillParams2 = {
|
|
778
|
-
...depositAddressRequest.fillOrKillParams,
|
|
779
|
-
minPriceX128: getPriceX128FromPrice(
|
|
780
|
-
depositAddressRequest.fillOrKillParams.minPrice,
|
|
781
|
-
getInternalAsset({ chain: srcChain, asset: srcAsset }),
|
|
782
|
-
getInternalAsset({ chain: destChain, asset: destAsset })
|
|
783
|
-
)
|
|
784
|
-
};
|
|
785
|
-
let response;
|
|
786
|
-
if (this.options.broker) {
|
|
787
|
-
const result = await requestSwapDepositAddress(
|
|
788
|
-
{
|
|
789
|
-
...depositAddressRequest,
|
|
790
|
-
commissionBps: brokerCommissionBps ?? this.options.broker.commissionBps,
|
|
791
|
-
affiliates: affiliateBrokers,
|
|
792
|
-
fillOrKillParams: fillOrKillParams2
|
|
793
|
-
},
|
|
794
|
-
{ url: this.options.broker.url },
|
|
795
|
-
this.options.network
|
|
796
|
-
);
|
|
797
|
-
response = {
|
|
798
|
-
id: `${result.issuedBlock}-${depositAddressRequest.srcChain}-${result.channelId}`,
|
|
799
|
-
depositAddress: result.address,
|
|
800
|
-
brokerCommissionBps: brokerCommissionBps ?? this.options.broker.commissionBps ?? 0,
|
|
801
|
-
srcChainExpiryBlock: result.sourceChainExpiryBlock,
|
|
802
|
-
maxBoostFeeBps: depositAddressRequest.maxBoostFeeBps,
|
|
803
|
-
channelOpeningFee: result.channelOpeningFee
|
|
804
|
-
};
|
|
805
|
-
} else {
|
|
806
|
-
assert(
|
|
807
|
-
!depositAddressRequest.brokerCommissionBps,
|
|
808
|
-
"Broker commission is supported only when initializing the SDK with a brokerUrl"
|
|
809
|
-
);
|
|
810
|
-
assert(
|
|
811
|
-
!depositAddressRequest.affiliateBrokers?.length,
|
|
812
|
-
"Affiliate brokers are supported only when initializing the SDK with a brokerUrl"
|
|
813
|
-
);
|
|
814
|
-
assert(fillOrKillParams2, "Fill or kill parameters are required");
|
|
815
|
-
response = await this.trpc.openSwapDepositChannel.mutate({
|
|
816
|
-
...depositAddressRequest,
|
|
817
|
-
fillOrKillParams: fillOrKillParams2
|
|
818
|
-
});
|
|
819
|
-
}
|
|
820
|
-
return {
|
|
821
|
-
...depositAddressRequest,
|
|
822
|
-
depositChannelId: response.id,
|
|
823
|
-
depositAddress: response.depositAddress,
|
|
824
|
-
brokerCommissionBps: response.brokerCommissionBps,
|
|
825
|
-
affiliateBrokers: depositAddressRequest.affiliateBrokers ?? [],
|
|
826
|
-
maxBoostFeeBps: Number(response.maxBoostFeeBps) || 0,
|
|
827
|
-
depositChannelExpiryBlock: response.srcChainExpiryBlock,
|
|
828
|
-
estimatedDepositChannelExpiryTime: response.estimatedExpiryTime,
|
|
829
|
-
channelOpeningFee: response.channelOpeningFee
|
|
830
|
-
};
|
|
831
|
-
}
|
|
832
|
-
/** @deprecated DEPRECATED(1.7) use getStatusV2() */
|
|
833
|
-
getStatus(swapStatusRequest, options = {}) {
|
|
834
|
-
console.error(
|
|
835
|
-
"[@chainflip/sdk] The getStatus method is deprecated and will be removed in the 1.9 release. Use the getStatusV2 method instead."
|
|
836
|
-
);
|
|
837
|
-
return getStatus(this.options.backendUrl, swapStatusRequest, options);
|
|
838
|
-
}
|
|
839
767
|
getStatusV2(swapStatusRequest, options = {}) {
|
|
840
768
|
return getStatusV2(this.options.backendUrl, swapStatusRequest, options);
|
|
841
769
|
}
|
|
842
770
|
async validateSwapAmount(asset2, amount) {
|
|
843
771
|
const stateChainEnv = await this.getStateChainEnvironment();
|
|
844
|
-
const internalAsset = getInternalAsset(asset2);
|
|
772
|
+
const internalAsset = chainflip.getInternalAsset(asset2);
|
|
845
773
|
const result = validateSwapAmount(stateChainEnv, internalAsset, amount);
|
|
846
774
|
if (!result.success) throw new Error(result.reason);
|
|
847
775
|
}
|
|
@@ -856,7 +784,7 @@ var SwapSDK = class {
|
|
|
856
784
|
const {
|
|
857
785
|
ingressEgress: { witnessSafetyMargins }
|
|
858
786
|
} = await this.getStateChainEnvironment();
|
|
859
|
-
return
|
|
787
|
+
return chainflip.chainflipChains.reduce(
|
|
860
788
|
(acc, chain2) => {
|
|
861
789
|
acc[chain2] = witnessSafetyMargins[chain2] ? Number(witnessSafetyMargins[chain2]) + 1 : null;
|
|
862
790
|
return acc;
|
|
@@ -874,7 +802,7 @@ var SwapSDK = class {
|
|
|
874
802
|
let poolsDepth = await this.getBoostPoolsDepth();
|
|
875
803
|
if ("chain" in params && "asset" in params) {
|
|
876
804
|
const { chain: chain2, asset: asset2 } = params;
|
|
877
|
-
const internalAsset = getInternalAsset({ chain: chain2, asset: asset2 });
|
|
805
|
+
const internalAsset = chainflip.getInternalAsset({ chain: chain2, asset: asset2 });
|
|
878
806
|
poolsDepth = poolsDepth.filter((boostPoolDepth) => boostPoolDepth.asset === internalAsset).sort((a, b) => b.tier - a.tier);
|
|
879
807
|
}
|
|
880
808
|
if ("feeTierBps" in params && params.feeTierBps !== void 0) {
|
|
@@ -883,7 +811,7 @@ var SwapSDK = class {
|
|
|
883
811
|
return poolsDepth.map((depth) => ({
|
|
884
812
|
availableAmount: depth.availableAmount,
|
|
885
813
|
feeTierBps: depth.tier,
|
|
886
|
-
...
|
|
814
|
+
...chainflip.internalAssetToRpcAsset[depth.asset]
|
|
887
815
|
}));
|
|
888
816
|
}
|
|
889
817
|
async requestDepositAddressV2({
|
|
@@ -993,7 +921,7 @@ var SwapSDK = class {
|
|
|
993
921
|
dcaParams: quote.type === "DCA" ? quote.dcaParams : void 0,
|
|
994
922
|
extraParams,
|
|
995
923
|
brokerAccount,
|
|
996
|
-
brokerCommissionBps,
|
|
924
|
+
commissionBps: brokerCommissionBps,
|
|
997
925
|
affiliates
|
|
998
926
|
};
|
|
999
927
|
if (this.options.broker) {
|
|
@@ -1004,14 +932,14 @@ var SwapSDK = class {
|
|
|
1004
932
|
return requestSwapParameterEncoding(
|
|
1005
933
|
{
|
|
1006
934
|
...vaultSwapRequest,
|
|
1007
|
-
commissionBps: vaultSwapRequest.
|
|
935
|
+
commissionBps: vaultSwapRequest.commissionBps ?? this.options.broker.commissionBps
|
|
1008
936
|
},
|
|
1009
937
|
{ url: this.options.broker.url },
|
|
1010
938
|
this.options.network
|
|
1011
939
|
);
|
|
1012
940
|
}
|
|
1013
941
|
assert(
|
|
1014
|
-
!vaultSwapRequest.
|
|
942
|
+
!vaultSwapRequest.commissionBps || vaultSwapRequest.brokerAccount,
|
|
1015
943
|
"Broker commission is supported only when setting a broker account"
|
|
1016
944
|
);
|
|
1017
945
|
assert(
|
|
@@ -1020,6 +948,23 @@ var SwapSDK = class {
|
|
|
1020
948
|
);
|
|
1021
949
|
return this.trpc.encodeVaultSwapData.mutate(vaultSwapRequest);
|
|
1022
950
|
}
|
|
951
|
+
async checkBoostEnabled() {
|
|
952
|
+
const { boostDepositsEnabled } = await this.cache.read("networkStatus");
|
|
953
|
+
return boostDepositsEnabled;
|
|
954
|
+
}
|
|
1023
955
|
};
|
|
956
|
+
var arrayToMap = (array) => Object.fromEntries(array.map((item) => [item, item]));
|
|
957
|
+
var ChainflipNetworks = arrayToMap(chainflip.chainflipNetworks);
|
|
958
|
+
var InternalAssets = arrayToMap(chainflip.chainflipAssets);
|
|
959
|
+
var Chains = arrayToMap(chainflip.chainflipChains);
|
|
960
|
+
var Assets = arrayToMap(chainflip.assetSymbols);
|
|
1024
961
|
|
|
1025
|
-
|
|
962
|
+
Object.defineProperty(exports, "getChainflipId", {
|
|
963
|
+
enumerable: true,
|
|
964
|
+
get: function () { return chainflip.getInternalAsset; }
|
|
965
|
+
});
|
|
966
|
+
exports.Assets = Assets;
|
|
967
|
+
exports.ChainflipIds = InternalAssets;
|
|
968
|
+
exports.ChainflipNetworks = ChainflipNetworks;
|
|
969
|
+
exports.Chains = Chains;
|
|
970
|
+
exports.SwapSDK = SwapSDK;
|