@chainflip/sdk 1.1.1 → 1.1.2
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/{broker-BDXRD56F.mjs → broker-IPTE3R72.mjs} +13 -13
- package/dist/{chunk-UTZ4VKAX.mjs → chunk-4PQXI2DE.mjs} +1 -1
- package/dist/{chunk-EQSMT5US.mjs → chunk-Q7HQVR3T.mjs} +25 -1
- package/dist/chunk-Z4OL2TKA.mjs +603 -0
- package/dist/{contracts-rsXvYw7v.d.mts → contracts-ss509umD.d.mts} +1 -1
- package/dist/{contracts-rsXvYw7v.d.ts → contracts-ss509umD.d.ts} +1 -1
- package/dist/funding.d.mts +1 -1
- package/dist/funding.d.ts +1 -1
- package/dist/funding.mjs +2 -2
- package/dist/swap.d.mts +36 -36
- package/dist/swap.d.ts +36 -36
- package/dist/swap.js +471 -214
- package/dist/swap.mjs +23 -22
- package/package.json +1 -1
- package/dist/chunk-KUNN7I5S.mjs +0 -371
package/dist/swap.mjs
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
|
-
import { getEnvironment, getVaultManagerContractAddress, approve, getTokenContractAddress, checkAllowance, Vault__factory, extractOverrides } from './chunk-
|
|
2
|
-
import { numericString, ethereumAddress, dotAddress,
|
|
3
|
-
import { __name, z, Chains, Assets, ChainflipNetworks, __publicField, assert, assertIsValidAssetAndChain, isTokenCall, isTokenSwap, chainContractIds, assetContractIds, assetDecimals, isTestnet } from './chunk-
|
|
4
|
-
export { Assets, ChainflipNetworks, Chains, assetChains, assetContractIds, assetDecimals, chainAssets, chainContractIds } from './chunk-
|
|
1
|
+
import { getEnvironment, getVaultManagerContractAddress, approve, getTokenContractAddress, checkAllowance, Vault__factory, extractOverrides } from './chunk-4PQXI2DE.mjs';
|
|
2
|
+
import { numericString, ethereumAddress, dotAddress, ccmMetadataSchema, btcAddress } from './chunk-Z4OL2TKA.mjs';
|
|
3
|
+
import { __name, z, Chains, Assets, ChainflipNetworks, __publicField, assert, assertIsValidAssetAndChain, isTokenCall, isTokenSwap, chainContractIds, assetContractIds, assetDecimals, isTestnet } from './chunk-Q7HQVR3T.mjs';
|
|
4
|
+
export { Assets, ChainflipNetworks, Chains, assetChains, assetContractIds, assetDecimals, chainAssets, chainContractIds } from './chunk-Q7HQVR3T.mjs';
|
|
5
5
|
import { decodeAddress } from '@polkadot/util-crypto';
|
|
6
6
|
import axios from 'axios';
|
|
7
7
|
|
|
@@ -2225,11 +2225,11 @@ var ethToDot = eth.extend({
|
|
|
2225
2225
|
destAddress: dotAddress.transform((addr) => bytesToHex(decodeAddress(addr))),
|
|
2226
2226
|
destAsset: z.literal(Assets.DOT)
|
|
2227
2227
|
});
|
|
2228
|
-
var ethToBtc = eth.extend({
|
|
2228
|
+
var ethToBtc = /* @__PURE__ */ __name((network) => eth.extend({
|
|
2229
2229
|
destChain: z.literal(Chains.Bitcoin),
|
|
2230
|
-
destAddress: btcAddress().transform(utf8ToHex),
|
|
2230
|
+
destAddress: btcAddress(network).transform(utf8ToHex),
|
|
2231
2231
|
destAsset: z.literal(Assets.BTC)
|
|
2232
|
-
});
|
|
2232
|
+
}), "ethToBtc");
|
|
2233
2233
|
var erc20Asset = z.union([
|
|
2234
2234
|
z.literal(Assets.FLIP),
|
|
2235
2235
|
z.literal(Assets.USDC)
|
|
@@ -2237,11 +2237,11 @@ var erc20Asset = z.union([
|
|
|
2237
2237
|
var ethToERC20 = ethToEthereum.extend({
|
|
2238
2238
|
destAsset: erc20Asset
|
|
2239
2239
|
});
|
|
2240
|
-
var nativeSwapParamsSchema = z.union([
|
|
2240
|
+
var nativeSwapParamsSchema = /* @__PURE__ */ __name((network) => z.union([
|
|
2241
2241
|
ethToERC20,
|
|
2242
2242
|
ethToDot,
|
|
2243
|
-
ethToBtc
|
|
2244
|
-
]);
|
|
2243
|
+
ethToBtc(network)
|
|
2244
|
+
]), "nativeSwapParamsSchema");
|
|
2245
2245
|
var flipToEthereumAsset = ethToEthereum.extend({
|
|
2246
2246
|
srcAsset: z.literal(Assets.FLIP),
|
|
2247
2247
|
destAsset: z.union([
|
|
@@ -2259,15 +2259,15 @@ var usdcToEthereumAsset = ethToEthereum.extend({
|
|
|
2259
2259
|
var erc20ToDot = ethToDot.extend({
|
|
2260
2260
|
srcAsset: erc20Asset
|
|
2261
2261
|
});
|
|
2262
|
-
var erc20ToBtc = ethToBtc.extend({
|
|
2262
|
+
var erc20ToBtc = /* @__PURE__ */ __name((network) => ethToBtc(network).extend({
|
|
2263
2263
|
srcAsset: erc20Asset
|
|
2264
|
-
});
|
|
2265
|
-
var tokenSwapParamsSchema = z.union([
|
|
2264
|
+
}), "erc20ToBtc");
|
|
2265
|
+
var tokenSwapParamsSchema = /* @__PURE__ */ __name((network) => z.union([
|
|
2266
2266
|
flipToEthereumAsset,
|
|
2267
2267
|
usdcToEthereumAsset,
|
|
2268
2268
|
erc20ToDot,
|
|
2269
|
-
erc20ToBtc
|
|
2270
|
-
]);
|
|
2269
|
+
erc20ToBtc(network)
|
|
2270
|
+
]), "tokenSwapParamsSchema");
|
|
2271
2271
|
var ccmFlipToEthereumAssset = flipToEthereumAsset.extend({
|
|
2272
2272
|
ccmMetadata: ccmMetadataSchema
|
|
2273
2273
|
});
|
|
@@ -2281,13 +2281,13 @@ var tokenCallParamsSchema = z.union([
|
|
|
2281
2281
|
var nativeCallParamsSchema = ethToERC20.extend({
|
|
2282
2282
|
ccmMetadata: ccmMetadataSchema
|
|
2283
2283
|
});
|
|
2284
|
-
var executeSwapParamsSchema = z.union([
|
|
2284
|
+
var executeSwapParamsSchema = /* @__PURE__ */ __name((network) => z.union([
|
|
2285
2285
|
// call schemas needs to precede swap schemas
|
|
2286
2286
|
nativeCallParamsSchema,
|
|
2287
2287
|
tokenCallParamsSchema,
|
|
2288
|
-
nativeSwapParamsSchema,
|
|
2289
|
-
tokenSwapParamsSchema
|
|
2290
|
-
]);
|
|
2288
|
+
nativeSwapParamsSchema(network),
|
|
2289
|
+
tokenSwapParamsSchema(network)
|
|
2290
|
+
]), "executeSwapParamsSchema");
|
|
2291
2291
|
|
|
2292
2292
|
// ../shared/src/vault/executeSwap.ts
|
|
2293
2293
|
var swapNative = /* @__PURE__ */ __name(async ({ destChain, destAsset, destAddress, amount }, networkOpts, txOpts) => {
|
|
@@ -2329,7 +2329,8 @@ var callToken = /* @__PURE__ */ __name(async (params, networkOpts, txOpts) => {
|
|
|
2329
2329
|
return transaction.wait(txOpts.wait);
|
|
2330
2330
|
}, "callToken");
|
|
2331
2331
|
var executeSwap = /* @__PURE__ */ __name(async (params, networkOpts, txOpts) => {
|
|
2332
|
-
const
|
|
2332
|
+
const network = networkOpts.network === "localnet" ? "backspin" : networkOpts.network;
|
|
2333
|
+
const parsedParams = executeSwapParamsSchema(network).parse(params);
|
|
2333
2334
|
if ("ccmMetadata" in parsedParams) {
|
|
2334
2335
|
return isTokenCall(parsedParams) ? callToken(parsedParams, networkOpts, txOpts) : callNative(parsedParams, networkOpts, txOpts);
|
|
2335
2336
|
}
|
|
@@ -2580,8 +2581,8 @@ var _SwapSDK = class _SwapSDK {
|
|
|
2580
2581
|
}, BigInt(amount));
|
|
2581
2582
|
let response;
|
|
2582
2583
|
if (this.brokerConfig !== void 0) {
|
|
2583
|
-
const { requestSwapDepositAddress } = await import('./broker-
|
|
2584
|
-
const result = await requestSwapDepositAddress(depositAddressRequest, this.brokerConfig);
|
|
2584
|
+
const { requestSwapDepositAddress } = await import('./broker-IPTE3R72.mjs');
|
|
2585
|
+
const result = await requestSwapDepositAddress(depositAddressRequest, this.brokerConfig, this.network);
|
|
2585
2586
|
response = {
|
|
2586
2587
|
id: `${result.issuedBlock}-${depositAddressRequest.srcChain}-${result.channelId}`,
|
|
2587
2588
|
depositAddress: result.address,
|
package/package.json
CHANGED
package/dist/chunk-KUNN7I5S.mjs
DELETED
|
@@ -1,371 +0,0 @@
|
|
|
1
|
-
import { z, isString, Chains, Assets, assetChains, ChainflipNetworks, __name, assert } from './chunk-EQSMT5US.mjs';
|
|
2
|
-
import { hexToU8a } from '@polkadot/util';
|
|
3
|
-
import { encodeAddress, decodeAddress, base58Decode } from '@polkadot/util-crypto';
|
|
4
|
-
import * as ethers from 'ethers';
|
|
5
|
-
|
|
6
|
-
// ../shared/src/validation/segwitAddr.ts
|
|
7
|
-
var CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
|
|
8
|
-
var GENERATOR = [
|
|
9
|
-
996825010,
|
|
10
|
-
642813549,
|
|
11
|
-
513874426,
|
|
12
|
-
1027748829,
|
|
13
|
-
705979059
|
|
14
|
-
];
|
|
15
|
-
var Encoding;
|
|
16
|
-
(function(Encoding2) {
|
|
17
|
-
Encoding2["Bech32"] = "bech32";
|
|
18
|
-
Encoding2["Bech32m"] = "bech32m";
|
|
19
|
-
})(Encoding || (Encoding = {}));
|
|
20
|
-
var bech32 = {
|
|
21
|
-
getEncodingConst(enc) {
|
|
22
|
-
if (enc === "bech32")
|
|
23
|
-
return 1;
|
|
24
|
-
if (enc === "bech32m")
|
|
25
|
-
return 734539939;
|
|
26
|
-
return null;
|
|
27
|
-
},
|
|
28
|
-
polymod(values) {
|
|
29
|
-
let chk = 1;
|
|
30
|
-
for (let p = 0; p < values.length; p += 1) {
|
|
31
|
-
const top = chk >> 25;
|
|
32
|
-
chk = (chk & 33554431) << 5 ^ values[p];
|
|
33
|
-
for (let i = 0; i < 5; i += 1) {
|
|
34
|
-
if (top >> i & 1) {
|
|
35
|
-
chk ^= GENERATOR[i];
|
|
36
|
-
}
|
|
37
|
-
}
|
|
38
|
-
}
|
|
39
|
-
return chk;
|
|
40
|
-
},
|
|
41
|
-
hrpExpand(hrp) {
|
|
42
|
-
const ret = [];
|
|
43
|
-
let p;
|
|
44
|
-
for (p = 0; p < hrp.length; p += 1) {
|
|
45
|
-
ret.push(hrp.charCodeAt(p) >> 5);
|
|
46
|
-
}
|
|
47
|
-
ret.push(0);
|
|
48
|
-
for (p = 0; p < hrp.length; p += 1) {
|
|
49
|
-
ret.push(hrp.charCodeAt(p) & 31);
|
|
50
|
-
}
|
|
51
|
-
return ret;
|
|
52
|
-
},
|
|
53
|
-
verifyChecksum(hrp, data, enc) {
|
|
54
|
-
return this.polymod(this.hrpExpand(hrp).concat(data)) === this.getEncodingConst(enc);
|
|
55
|
-
},
|
|
56
|
-
createChecksum(hrp, data, enc) {
|
|
57
|
-
const values = this.hrpExpand(hrp).concat(data).concat([
|
|
58
|
-
0,
|
|
59
|
-
0,
|
|
60
|
-
0,
|
|
61
|
-
0,
|
|
62
|
-
0,
|
|
63
|
-
0
|
|
64
|
-
]);
|
|
65
|
-
const mod = this.polymod(values) ^ this.getEncodingConst(enc);
|
|
66
|
-
const ret = [];
|
|
67
|
-
for (let p = 0; p < 6; p += 1) {
|
|
68
|
-
ret.push(mod >> 5 * (5 - p) & 31);
|
|
69
|
-
}
|
|
70
|
-
return ret;
|
|
71
|
-
},
|
|
72
|
-
encode(hrp, data, enc) {
|
|
73
|
-
const combined = data.concat(this.createChecksum(hrp, data, enc));
|
|
74
|
-
let ret = `${hrp}1`;
|
|
75
|
-
for (let p = 0; p < combined.length; p += 1) {
|
|
76
|
-
ret += CHARSET.charAt(combined[p]);
|
|
77
|
-
}
|
|
78
|
-
return ret;
|
|
79
|
-
},
|
|
80
|
-
decode(bechString, enc) {
|
|
81
|
-
let p;
|
|
82
|
-
let hasLower = false;
|
|
83
|
-
let hasUpper = false;
|
|
84
|
-
for (p = 0; p < bechString.length; p += 1) {
|
|
85
|
-
if (bechString.charCodeAt(p) < 33 || bechString.charCodeAt(p) > 126) {
|
|
86
|
-
return null;
|
|
87
|
-
}
|
|
88
|
-
if (bechString.charCodeAt(p) >= 97 && bechString.charCodeAt(p) <= 122) {
|
|
89
|
-
hasLower = true;
|
|
90
|
-
}
|
|
91
|
-
if (bechString.charCodeAt(p) >= 65 && bechString.charCodeAt(p) <= 90) {
|
|
92
|
-
hasUpper = true;
|
|
93
|
-
}
|
|
94
|
-
}
|
|
95
|
-
if (hasLower && hasUpper)
|
|
96
|
-
return null;
|
|
97
|
-
const lowercase = bechString.toLowerCase();
|
|
98
|
-
const pos = lowercase.lastIndexOf("1");
|
|
99
|
-
if (pos < 1 || pos + 7 > lowercase.length || lowercase.length > 90) {
|
|
100
|
-
return null;
|
|
101
|
-
}
|
|
102
|
-
const hrp = lowercase.substring(0, pos);
|
|
103
|
-
const data = [];
|
|
104
|
-
for (p = pos + 1; p < lowercase.length; p += 1) {
|
|
105
|
-
const d = CHARSET.indexOf(lowercase.charAt(p));
|
|
106
|
-
if (d === -1)
|
|
107
|
-
return null;
|
|
108
|
-
data.push(d);
|
|
109
|
-
}
|
|
110
|
-
if (!this.verifyChecksum(hrp, data, enc)) {
|
|
111
|
-
return null;
|
|
112
|
-
}
|
|
113
|
-
return {
|
|
114
|
-
hrp,
|
|
115
|
-
data: data.slice(0, data.length - 6)
|
|
116
|
-
};
|
|
117
|
-
}
|
|
118
|
-
};
|
|
119
|
-
var segwitAddress = {
|
|
120
|
-
convertbits(data, frombits, tobits, pad) {
|
|
121
|
-
let acc = 0;
|
|
122
|
-
let bits = 0;
|
|
123
|
-
const ret = [];
|
|
124
|
-
const maxv = (1 << tobits) - 1;
|
|
125
|
-
for (let p = 0; p < data.length; p += 1) {
|
|
126
|
-
const value = data[p];
|
|
127
|
-
if (value < 0 || value >> frombits !== 0) {
|
|
128
|
-
return null;
|
|
129
|
-
}
|
|
130
|
-
acc = acc << frombits | value;
|
|
131
|
-
bits += frombits;
|
|
132
|
-
while (bits >= tobits) {
|
|
133
|
-
bits -= tobits;
|
|
134
|
-
ret.push(acc >> bits & maxv);
|
|
135
|
-
}
|
|
136
|
-
}
|
|
137
|
-
if (pad) {
|
|
138
|
-
if (bits > 0) {
|
|
139
|
-
ret.push(acc << tobits - bits & maxv);
|
|
140
|
-
}
|
|
141
|
-
} else if (bits >= frombits || acc << tobits - bits & maxv) {
|
|
142
|
-
return null;
|
|
143
|
-
}
|
|
144
|
-
return ret;
|
|
145
|
-
},
|
|
146
|
-
decode(hrp, addr) {
|
|
147
|
-
let bech32m = false;
|
|
148
|
-
let dec = bech32.decode(addr, "bech32");
|
|
149
|
-
if (dec === null) {
|
|
150
|
-
dec = bech32.decode(addr, "bech32m");
|
|
151
|
-
bech32m = true;
|
|
152
|
-
}
|
|
153
|
-
if (dec === null || dec.hrp !== hrp || dec.data.length < 1 || dec.data[0] > 16) {
|
|
154
|
-
return null;
|
|
155
|
-
}
|
|
156
|
-
const res = this.convertbits(dec.data.slice(1), 5, 8, false);
|
|
157
|
-
if (res === null || res.length < 2 || res.length > 40) {
|
|
158
|
-
return null;
|
|
159
|
-
}
|
|
160
|
-
if (dec.data[0] === 0 && res.length !== 20 && res.length !== 32) {
|
|
161
|
-
return null;
|
|
162
|
-
}
|
|
163
|
-
if (dec.data[0] === 0 && bech32m) {
|
|
164
|
-
return null;
|
|
165
|
-
}
|
|
166
|
-
if (dec.data[0] !== 0 && !bech32m) {
|
|
167
|
-
return null;
|
|
168
|
-
}
|
|
169
|
-
return {
|
|
170
|
-
version: dec.data[0],
|
|
171
|
-
program: res
|
|
172
|
-
};
|
|
173
|
-
},
|
|
174
|
-
encode(hrp, version, program) {
|
|
175
|
-
let enc = "bech32";
|
|
176
|
-
if (version > 0) {
|
|
177
|
-
enc = "bech32m";
|
|
178
|
-
}
|
|
179
|
-
const ret = bech32.encode(
|
|
180
|
-
hrp,
|
|
181
|
-
// @ts-expect-error can be null
|
|
182
|
-
[
|
|
183
|
-
version
|
|
184
|
-
].concat(this.convertbits(program, 8, 5, true)),
|
|
185
|
-
enc
|
|
186
|
-
);
|
|
187
|
-
if (this.decode(hrp, ret) === null) {
|
|
188
|
-
return null;
|
|
189
|
-
}
|
|
190
|
-
return ret;
|
|
191
|
-
}
|
|
192
|
-
};
|
|
193
|
-
var isValidSegwitAddress = /* @__PURE__ */ __name((address) => {
|
|
194
|
-
const hrp = /^(bc|tb|bcrt)1/.exec(address)?.[1];
|
|
195
|
-
if (!hrp)
|
|
196
|
-
return false;
|
|
197
|
-
return segwitAddress.decode(hrp, address) !== null;
|
|
198
|
-
}, "isValidSegwitAddress");
|
|
199
|
-
|
|
200
|
-
// ../shared/src/validation/addressValidation.ts
|
|
201
|
-
var assertArraylikeEqual = /* @__PURE__ */ __name((a, b) => {
|
|
202
|
-
assert(a.length === b.length, "arraylike lengths must be equal");
|
|
203
|
-
for (let i = 0; i < a.length; i += 1) {
|
|
204
|
-
assert(a[i] === b[i], "arraylike elements must be equal");
|
|
205
|
-
}
|
|
206
|
-
}, "assertArraylikeEqual");
|
|
207
|
-
var validateP2PKHOrP2SHAddress = /* @__PURE__ */ __name((address, network) => {
|
|
208
|
-
try {
|
|
209
|
-
const decoded = base58Decode(address);
|
|
210
|
-
assert(decoded.length === 25, "decoded address must be 25 bytes long");
|
|
211
|
-
if (network === "mainnet") {
|
|
212
|
-
assert(decoded[0] === 0 || decoded[0] === 5, "decoded address must start with 0x00 or 0x05");
|
|
213
|
-
} else {
|
|
214
|
-
assert(decoded[0] === 111 || decoded[0] === 196, "decoded address must start with 0x6f or 0xc4");
|
|
215
|
-
}
|
|
216
|
-
const checksum = decoded.slice(-4);
|
|
217
|
-
const doubleHash = ethers.getBytes(ethers.sha256(ethers.sha256(decoded.slice(0, 21))));
|
|
218
|
-
assertArraylikeEqual(checksum, doubleHash.slice(0, 4));
|
|
219
|
-
return true;
|
|
220
|
-
} catch (error) {
|
|
221
|
-
return false;
|
|
222
|
-
}
|
|
223
|
-
}, "validateP2PKHOrP2SHAddress");
|
|
224
|
-
var validateSegwitAddress = /* @__PURE__ */ __name((address, network) => {
|
|
225
|
-
try {
|
|
226
|
-
assert(
|
|
227
|
-
// On mainnet, the address must start with "bc1"
|
|
228
|
-
network === "mainnet" && address.startsWith("bc1") || // on testnet it must start with "tb1"
|
|
229
|
-
network === "testnet" && address.startsWith("tb1") || // on regtest it must start with "bcrt1"
|
|
230
|
-
network === "regtest" && address.startsWith("bcrt1"),
|
|
231
|
-
"address must start with bc1, tb1 or bcrt1"
|
|
232
|
-
);
|
|
233
|
-
return isValidSegwitAddress(address);
|
|
234
|
-
} catch {
|
|
235
|
-
return false;
|
|
236
|
-
}
|
|
237
|
-
}, "validateSegwitAddress");
|
|
238
|
-
var validateBitcoinAddress = /* @__PURE__ */ __name((address, network) => validateP2PKHOrP2SHAddress(address, network) || validateSegwitAddress(address, network), "validateBitcoinAddress");
|
|
239
|
-
var validateBitcoinMainnetAddress = /* @__PURE__ */ __name((address) => validateBitcoinAddress(address, "mainnet"), "validateBitcoinMainnetAddress");
|
|
240
|
-
var validateBitcoinTestnetAddress = /* @__PURE__ */ __name((address) => validateBitcoinAddress(address, "testnet"), "validateBitcoinTestnetAddress");
|
|
241
|
-
var validateBitcoinRegtestAddress = /* @__PURE__ */ __name((address) => validateBitcoinAddress(address, "regtest"), "validateBitcoinRegtestAddress");
|
|
242
|
-
|
|
243
|
-
// ../shared/src/parsers.ts
|
|
244
|
-
var safeStringify = /* @__PURE__ */ __name((obj) => JSON.stringify(obj, (key, value) => typeof value === "bigint" ? value.toString() : value), "safeStringify");
|
|
245
|
-
var errorMap = /* @__PURE__ */ __name((_issue, context) => ({
|
|
246
|
-
message: `received: ${safeStringify(context.data)}`
|
|
247
|
-
}), "errorMap");
|
|
248
|
-
var string = z.string({
|
|
249
|
-
errorMap
|
|
250
|
-
});
|
|
251
|
-
z.number({
|
|
252
|
-
errorMap
|
|
253
|
-
});
|
|
254
|
-
var numericString = string.regex(/^[0-9]+$/);
|
|
255
|
-
var hexString = z.custom((val) => typeof val === "string" && /^0x[0-9a-f]+$/i.test(val));
|
|
256
|
-
var hexStringWithMaxByteSize = /* @__PURE__ */ __name((maxByteSize) => hexString.refine((val) => val.length / 2 <= maxByteSize + 1, {
|
|
257
|
-
message: `String must be less than or equal to ${maxByteSize} bytes`
|
|
258
|
-
}), "hexStringWithMaxByteSize");
|
|
259
|
-
var hexStringFromNumber = numericString.transform((arg) => `0x${BigInt(arg).toString(16)}`);
|
|
260
|
-
string.regex(/^[0-9a-f]+$/);
|
|
261
|
-
var btcAddress = /* @__PURE__ */ __name((env) => {
|
|
262
|
-
const network = env ?? process.env.CHAINFLIP_NETWORK;
|
|
263
|
-
if (network === "mainnet")
|
|
264
|
-
return string.regex(/^(1|3|bc1)/).refine(validateBitcoinMainnetAddress);
|
|
265
|
-
return z.union([
|
|
266
|
-
string.regex(/^(m|n|2|tb1)/).refine(validateBitcoinTestnetAddress),
|
|
267
|
-
string.regex(/^bcrt1/).refine(validateBitcoinRegtestAddress)
|
|
268
|
-
]);
|
|
269
|
-
}, "btcAddress");
|
|
270
|
-
var dotAddress = z.union([
|
|
271
|
-
string,
|
|
272
|
-
hexString
|
|
273
|
-
]).transform((arg) => {
|
|
274
|
-
try {
|
|
275
|
-
if (arg.startsWith("0x")) {
|
|
276
|
-
return encodeAddress(hexToU8a(arg));
|
|
277
|
-
}
|
|
278
|
-
decodeAddress(arg);
|
|
279
|
-
return arg;
|
|
280
|
-
} catch {
|
|
281
|
-
return null;
|
|
282
|
-
}
|
|
283
|
-
}).refine(isString);
|
|
284
|
-
var ethereumAddress = hexString.refine((address) => ethers.isAddress(address));
|
|
285
|
-
numericString.transform((arg) => BigInt(arg));
|
|
286
|
-
var u128 = z.union([
|
|
287
|
-
numericString,
|
|
288
|
-
hexString
|
|
289
|
-
]).transform((arg) => BigInt(arg));
|
|
290
|
-
var unsignedInteger = z.union([
|
|
291
|
-
u128,
|
|
292
|
-
z.number().transform((n) => BigInt(n))
|
|
293
|
-
]);
|
|
294
|
-
z.object({
|
|
295
|
-
__kind: z.enum([
|
|
296
|
-
"Usdc",
|
|
297
|
-
"Flip",
|
|
298
|
-
"Dot",
|
|
299
|
-
"Eth",
|
|
300
|
-
"Btc"
|
|
301
|
-
])
|
|
302
|
-
}).transform(({ __kind }) => __kind.toUpperCase());
|
|
303
|
-
var transformAsset = /* @__PURE__ */ __name((asset) => ({
|
|
304
|
-
asset,
|
|
305
|
-
chain: assetChains[asset]
|
|
306
|
-
}), "transformAsset");
|
|
307
|
-
var chainflipChain = z.nativeEnum(Chains);
|
|
308
|
-
var chainflipAsset = z.nativeEnum(Assets);
|
|
309
|
-
var chainflipAssetAndChain = z.union([
|
|
310
|
-
chainflipAsset.transform(transformAsset),
|
|
311
|
-
z.object({
|
|
312
|
-
asset: z.nativeEnum(Assets),
|
|
313
|
-
chain: z.nativeEnum(Chains)
|
|
314
|
-
})
|
|
315
|
-
]).superRefine((obj, ctx) => {
|
|
316
|
-
if (assetChains[obj.asset] !== obj.chain) {
|
|
317
|
-
ctx.addIssue({
|
|
318
|
-
code: z.ZodIssueCode.custom,
|
|
319
|
-
message: `asset ${obj.asset} does not belong to chain ${obj.chain}`,
|
|
320
|
-
path: []
|
|
321
|
-
});
|
|
322
|
-
}
|
|
323
|
-
return z.NEVER;
|
|
324
|
-
});
|
|
325
|
-
z.nativeEnum(ChainflipNetworks);
|
|
326
|
-
z.union([
|
|
327
|
-
z.object({
|
|
328
|
-
__kind: z.literal("CcmPrincipal"),
|
|
329
|
-
value: unsignedInteger
|
|
330
|
-
}).transform(({ value: ccmId }) => ({
|
|
331
|
-
type: "PRINCIPAL",
|
|
332
|
-
ccmId
|
|
333
|
-
})),
|
|
334
|
-
z.object({
|
|
335
|
-
__kind: z.literal("CcmGas"),
|
|
336
|
-
value: unsignedInteger
|
|
337
|
-
}).transform(({ value: ccmId }) => ({
|
|
338
|
-
type: "GAS",
|
|
339
|
-
ccmId
|
|
340
|
-
})),
|
|
341
|
-
z.object({
|
|
342
|
-
__kind: z.literal("Swap")
|
|
343
|
-
}).transform(() => ({
|
|
344
|
-
type: "SWAP"
|
|
345
|
-
}))
|
|
346
|
-
]);
|
|
347
|
-
|
|
348
|
-
// ../shared/src/schemas.ts
|
|
349
|
-
z.object({
|
|
350
|
-
srcAsset: chainflipAssetAndChain,
|
|
351
|
-
destAsset: chainflipAssetAndChain,
|
|
352
|
-
amount: numericString
|
|
353
|
-
});
|
|
354
|
-
var ccmMetadataSchema = z.object({
|
|
355
|
-
gasBudget: numericString,
|
|
356
|
-
message: hexStringWithMaxByteSize(1024 * 10)
|
|
357
|
-
});
|
|
358
|
-
z.object({
|
|
359
|
-
srcAsset: chainflipAsset,
|
|
360
|
-
destAsset: chainflipAsset,
|
|
361
|
-
srcChain: chainflipChain,
|
|
362
|
-
destChain: chainflipChain,
|
|
363
|
-
destAddress: z.string(),
|
|
364
|
-
amount: numericString,
|
|
365
|
-
ccmMetadata: ccmMetadataSchema.optional()
|
|
366
|
-
}).transform(({ amount, ...rest }) => ({
|
|
367
|
-
...rest,
|
|
368
|
-
expectedDepositAmount: amount
|
|
369
|
-
}));
|
|
370
|
-
|
|
371
|
-
export { btcAddress, ccmMetadataSchema, chainflipAssetAndChain, dotAddress, ethereumAddress, hexString, hexStringFromNumber, numericString, unsignedInteger };
|