@dhedge/trading-widget 6.2.1 → 6.2.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/README.md +1 -0
- package/core-kit/utils/transaction.d.ts +14 -1
- package/{dytm-DdzHS3o4.js → dytm-3a5llKkf.js} +285 -281
- package/dytm-BGpelTOE.cjs +1 -0
- package/index.cjs +1 -1
- package/index.js +1571 -1563
- package/package.json +1 -1
- package/utils.cjs +1 -1
- package/utils.js +60 -59
- package/dytm-CliLZLfa.cjs +0 -1
|
@@ -1,7 +1,7 @@
|
|
|
1
|
-
import {
|
|
2
|
-
import { aq as
|
|
1
|
+
import { hyperEvm as F, mainnet as w, polygon as Z, optimism as J, base as tt, arbitrum as et } from "wagmi/chains";
|
|
2
|
+
import { aq as st, ao as nt, ap as at, a as b, q as D, ar as rt, as as ot, a5 as it, ak as ct, a3 as ut, b as dt, ae as pt, Z as v, aj as lt, at as Y, e as mt, d as yt, M as At, R as gt, P as Et, au as ht, av as ft, Q as Tt, N as _t, ah as T, _ as St, W as wt, X as bt, U as Dt, aw as G, ax as Rt, ay as It, az as Nt, aA as Ot, aB as Ct, ad as Mt } from "./gmx-Cyz_GmV5.js";
|
|
3
3
|
import u from "bignumber.js";
|
|
4
|
-
import { zeroHash as
|
|
4
|
+
import { zeroHash as xt, bytesToHex as Lt, pad as Bt, stringToHex as R, encodeAbiParameters as h, encodeFunctionData as g, erc20Abi as W, maxUint256 as I } from "viem";
|
|
5
5
|
const xe = typeof window < "u", Le = [
|
|
6
6
|
{
|
|
7
7
|
inputs: [
|
|
@@ -30,7 +30,7 @@ const xe = typeof window < "u", Le = [
|
|
|
30
30
|
stateMutability: "view",
|
|
31
31
|
type: "function"
|
|
32
32
|
}
|
|
33
|
-
],
|
|
33
|
+
], Pt = [
|
|
34
34
|
{
|
|
35
35
|
type: "tuple",
|
|
36
36
|
components: [
|
|
@@ -53,7 +53,7 @@ const xe = typeof window < "u", Le = [
|
|
|
53
53
|
{ name: "amountOutMinimum", type: "uint256" }
|
|
54
54
|
]
|
|
55
55
|
}
|
|
56
|
-
],
|
|
56
|
+
], Ut = [
|
|
57
57
|
{ name: "asset", type: "address" },
|
|
58
58
|
{ name: "amount", type: "uint256" },
|
|
59
59
|
{ name: "assetType", type: "uint16" },
|
|
@@ -75,7 +75,7 @@ const xe = typeof window < "u", Le = [
|
|
|
75
75
|
{
|
|
76
76
|
name: "assetData",
|
|
77
77
|
type: "tuple[]",
|
|
78
|
-
components:
|
|
78
|
+
components: Ut
|
|
79
79
|
}
|
|
80
80
|
],
|
|
81
81
|
stateMutability: "nonpayable",
|
|
@@ -88,7 +88,7 @@ const xe = typeof window < "u", Le = [
|
|
|
88
88
|
stateMutability: "view",
|
|
89
89
|
type: "function"
|
|
90
90
|
}
|
|
91
|
-
],
|
|
91
|
+
], k = [
|
|
92
92
|
{
|
|
93
93
|
inputs: [
|
|
94
94
|
{
|
|
@@ -130,7 +130,7 @@ const xe = typeof window < "u", Le = [
|
|
|
130
130
|
stateMutability: "nonpayable",
|
|
131
131
|
type: "function"
|
|
132
132
|
}
|
|
133
|
-
],
|
|
133
|
+
], $t = [
|
|
134
134
|
{
|
|
135
135
|
inputs: [
|
|
136
136
|
{ name: "tokenIn", type: "address" },
|
|
@@ -159,7 +159,7 @@ const xe = typeof window < "u", Le = [
|
|
|
159
159
|
stateMutability: "nonpayable",
|
|
160
160
|
type: "function"
|
|
161
161
|
}
|
|
162
|
-
],
|
|
162
|
+
], Ft = [
|
|
163
163
|
{
|
|
164
164
|
type: "tuple",
|
|
165
165
|
components: [
|
|
@@ -204,7 +204,7 @@ const xe = typeof window < "u", Le = [
|
|
|
204
204
|
hint: "Increase slippage tolerance and try again."
|
|
205
205
|
}
|
|
206
206
|
}
|
|
207
|
-
},
|
|
207
|
+
}, H = (t) => ({
|
|
208
208
|
stringErrors: {
|
|
209
209
|
...t.stringErrors,
|
|
210
210
|
...S.stringErrors
|
|
@@ -213,44 +213,44 @@ const xe = typeof window < "u", Le = [
|
|
|
213
213
|
...t.selectorErrors,
|
|
214
214
|
...S.selectorErrors
|
|
215
215
|
}
|
|
216
|
-
}),
|
|
216
|
+
}), vt = [
|
|
217
217
|
"https://cdn.jsdelivr.net/gh/dhedge/V2-Public@master/readmes/errorCodes/registry.json",
|
|
218
218
|
"https://raw.githubusercontent.com/dhedge/V2-Public/master/readmes/errorCodes/registry.json"
|
|
219
|
-
],
|
|
220
|
-
let
|
|
221
|
-
const
|
|
222
|
-
|
|
223
|
-
},
|
|
219
|
+
], Yt = 1, Gt = 1e4, N = 2e6, Wt = 2e3, kt = 500, Ht = 120, Vt = 300, Kt = 4, qt = /^dh\d{1,3}$/i, V = /[\u0000-\u001f\u007f]/, jt = /https?:\/\/|[<>`]/i, Xt = (t) => t.length <= Ht && !V.test(t) && (qt.test(t) || t.length >= Kt), A = (t) => typeof t == "string" && t.length > 0 && t.length <= Vt && !V.test(t) && !jt.test(t);
|
|
220
|
+
let K = S, _ = null;
|
|
221
|
+
const q = () => K, zt = (t) => {
|
|
222
|
+
K = H(t);
|
|
223
|
+
}, Qt = (t) => {
|
|
224
224
|
const e = t;
|
|
225
|
-
if (e?.schemaVersion !==
|
|
225
|
+
if (e?.schemaVersion !== Yt)
|
|
226
226
|
throw new Error(
|
|
227
227
|
`Unsupported error registry schemaVersion: ${String(e?.schemaVersion)}`
|
|
228
228
|
);
|
|
229
|
-
const n = {};
|
|
230
|
-
for (const [r, a] of Object.entries(e.stringErrors ?? {}))
|
|
231
|
-
a?.curated === !0 && jt(r) && A(a.description) && A(a.action) && (n[r] = { title: a.description, hint: a.action });
|
|
232
229
|
const s = {};
|
|
230
|
+
for (const [r, a] of Object.entries(e.stringErrors ?? {}))
|
|
231
|
+
a?.curated === !0 && Xt(r) && A(a.description) && A(a.action) && (s[r] = { title: a.description, hint: a.action });
|
|
232
|
+
const n = {};
|
|
233
233
|
for (const [r, a] of Object.entries(e.selectorErrors ?? {}))
|
|
234
|
-
a?.curated === !0 && /^0x[0-9a-f]{8}$/.test(r) && A(a.signature) && A(a.description) && A(a.action) && (
|
|
234
|
+
a?.curated === !0 && /^0x[0-9a-f]{8}$/.test(r) && A(a.signature) && A(a.description) && A(a.action) && (n[r] = {
|
|
235
235
|
signature: a.signature,
|
|
236
236
|
title: a.description,
|
|
237
237
|
hint: a.action
|
|
238
238
|
});
|
|
239
|
-
if (!Object.keys(
|
|
239
|
+
if (!Object.keys(s).length)
|
|
240
240
|
throw new Error("Error registry contained no curated string errors");
|
|
241
|
-
if (Object.keys(
|
|
241
|
+
if (Object.keys(s).length > Wt || Object.keys(n).length > kt)
|
|
242
242
|
throw new Error("Error registry exceeded expected entry counts");
|
|
243
|
-
return { stringErrors:
|
|
244
|
-
},
|
|
245
|
-
timeoutMs: t =
|
|
243
|
+
return { stringErrors: s, selectorErrors: n };
|
|
244
|
+
}, Zt = async ({
|
|
245
|
+
timeoutMs: t = Gt
|
|
246
246
|
} = {}) => {
|
|
247
247
|
const e = [];
|
|
248
|
-
for (const
|
|
249
|
-
const
|
|
248
|
+
for (const s of vt) {
|
|
249
|
+
const n = new AbortController(), r = setTimeout(() => n.abort(), t);
|
|
250
250
|
try {
|
|
251
|
-
const a = await fetch(
|
|
251
|
+
const a = await fetch(s, {
|
|
252
252
|
headers: { accept: "application/json" },
|
|
253
|
-
signal:
|
|
253
|
+
signal: n.signal
|
|
254
254
|
});
|
|
255
255
|
if (!a.ok) throw new Error(`HTTP ${a.status}`);
|
|
256
256
|
const o = Number(a.headers.get("content-length"));
|
|
@@ -259,25 +259,25 @@ const K = () => V, Xt = (t) => {
|
|
|
259
259
|
const i = await a.text();
|
|
260
260
|
if (i.length > N)
|
|
261
261
|
throw new Error(`Response too large: ${i.length} chars`);
|
|
262
|
-
return
|
|
262
|
+
return H(Qt(JSON.parse(i)));
|
|
263
263
|
} catch (a) {
|
|
264
264
|
e.push(
|
|
265
|
-
`${
|
|
265
|
+
`${s}: ${a instanceof Error ? a.message : String(a)}`
|
|
266
266
|
);
|
|
267
267
|
} finally {
|
|
268
268
|
clearTimeout(r);
|
|
269
269
|
}
|
|
270
270
|
}
|
|
271
271
|
throw new Error(`All error registry sources failed: ${e.join("; ")}`);
|
|
272
|
-
}, Pe = () => (_ ?? (_ =
|
|
272
|
+
}, Pe = () => (_ ?? (_ = Zt().then(zt).catch(() => {
|
|
273
273
|
_ = null;
|
|
274
|
-
})), _),
|
|
275
|
-
function
|
|
276
|
-
return
|
|
274
|
+
})), _), Jt = () => typeof window < "u";
|
|
275
|
+
function te() {
|
|
276
|
+
return Jt() && typeof window.ethereum < "u";
|
|
277
277
|
}
|
|
278
278
|
async function Ue(t) {
|
|
279
279
|
try {
|
|
280
|
-
if (
|
|
280
|
+
if (te())
|
|
281
281
|
return window.ethereum.request({
|
|
282
282
|
method: "wallet_watchAsset",
|
|
283
283
|
params: {
|
|
@@ -290,7 +290,7 @@ async function Ue(t) {
|
|
|
290
290
|
}
|
|
291
291
|
return !1;
|
|
292
292
|
}
|
|
293
|
-
const l = (t, e) => t?.toLowerCase() === e?.toLowerCase(), $e = (t) => l(t,
|
|
293
|
+
const l = (t, e) => t?.toLowerCase() === e?.toLowerCase(), $e = (t) => l(t, st), E = (t) => {
|
|
294
294
|
if (!t) throw new Error("Cannot prefix an empty hex value");
|
|
295
295
|
return t.startsWith("0x") ? t : `0x${t}`;
|
|
296
296
|
}, p = (t, e) => {
|
|
@@ -299,37 +299,40 @@ const l = (t, e) => t?.toLowerCase() === e?.toLowerCase(), $e = (t) => l(t, et),
|
|
|
299
299
|
} catch {
|
|
300
300
|
throw new Error(`Cannot convert "${e}" value "${t}" to bigint`);
|
|
301
301
|
}
|
|
302
|
-
}, O = (t) => t ?
|
|
302
|
+
}, O = (t) => t ? Bt(E(t), { size: 32 }) : xt, ee = (t) => {
|
|
303
303
|
if (!t) throw new Error("Cannot decode an empty base64 string");
|
|
304
|
-
return
|
|
305
|
-
},
|
|
304
|
+
return Lt(Uint8Array.from(atob(t), (e) => e.charCodeAt(0)));
|
|
305
|
+
}, se = (t, e) => at[e]?.[t] ?? b, Fe = (t) => nt[t], ve = (t) => t && `${t.substring(0, 6)}...${t.substring(
|
|
306
306
|
t.length - 4,
|
|
307
307
|
t.length
|
|
308
308
|
)}`, Ye = ({
|
|
309
309
|
address: t,
|
|
310
310
|
chainId: e
|
|
311
311
|
}) => {
|
|
312
|
-
const
|
|
312
|
+
const s = se(
|
|
313
313
|
"aaveLendingPoolV3",
|
|
314
314
|
e
|
|
315
315
|
);
|
|
316
|
-
return l(t,
|
|
316
|
+
return l(t, s);
|
|
317
317
|
}, ne = ({
|
|
318
318
|
sourceAddress: t,
|
|
319
319
|
amount: e
|
|
320
320
|
}) => `${t}_${e}`, Ge = (t, e) => {
|
|
321
|
-
const
|
|
322
|
-
return { firstPart:
|
|
323
|
-
},
|
|
321
|
+
const s = t.slice(0, e), n = t.slice(e);
|
|
322
|
+
return { firstPart: s, secondPart: n };
|
|
323
|
+
}, ae = (t, e) => t / e * 100, We = (t) => t < 1 ? 4 : t < 10 ? 3 : 2, ke = (t, e = D) => new u(t.toString()).shiftedBy(e).toFixed(0), He = (t, e, s, n) => new u(e).dividedBy(s).multipliedBy(t).shiftedBy(-(n || D)).toNumber(), Ve = (t) => BigInt(
|
|
324
324
|
new u(t || "0").shiftedBy(D).toFixed(0, u.ROUND_DOWN)
|
|
325
|
-
),
|
|
326
|
-
const e = new u(0.01),
|
|
327
|
-
return BigInt(
|
|
325
|
+
), j = (t) => {
|
|
326
|
+
const e = new u(0.01), s = new u(t), n = !s.isZero() && s.lt(e) ? e : s;
|
|
327
|
+
return BigInt(n.multipliedBy(100).toFixed(0));
|
|
328
328
|
}, Ke = ({
|
|
329
|
+
chainId: t,
|
|
330
|
+
slippage: e
|
|
331
|
+
}) => t === F.id ? BigInt(0) : j(e), qe = ({
|
|
329
332
|
vaultAddress: t,
|
|
330
333
|
swapData: e,
|
|
331
|
-
sendTokenAddress:
|
|
332
|
-
sendTokenAmount:
|
|
334
|
+
sendTokenAddress: s,
|
|
335
|
+
sendTokenAmount: n,
|
|
333
336
|
vaultDepositTokenAddress: r,
|
|
334
337
|
minVaultTokensReceivedAmount: a,
|
|
335
338
|
routerKey: o = "ONE_INCH",
|
|
@@ -337,18 +340,18 @@ const l = (t, e) => t?.toLowerCase() === e?.toLowerCase(), $e = (t) => l(t, et),
|
|
|
337
340
|
swapSlippage: c
|
|
338
341
|
}) => {
|
|
339
342
|
const d = new u(i).multipliedBy(1 - c / 100).toFixed(0), m = [R(o, { size: 32 }), e];
|
|
340
|
-
return [t, [[
|
|
341
|
-
},
|
|
343
|
+
return [t, [[s, n, m], [r, d]], a];
|
|
344
|
+
}, je = ({
|
|
342
345
|
receiveAssetAddress: t,
|
|
343
346
|
assets: e,
|
|
344
|
-
swapData:
|
|
345
|
-
slippage:
|
|
347
|
+
swapData: s,
|
|
348
|
+
slippage: n
|
|
346
349
|
}) => {
|
|
347
350
|
const r = {
|
|
348
351
|
srcData: [],
|
|
349
352
|
destAmount: new u("0")
|
|
350
353
|
}, { srcData: a, destAmount: o } = e?.reduce((i, c) => {
|
|
351
|
-
const d =
|
|
354
|
+
const d = s?.[c.address];
|
|
352
355
|
if (!d)
|
|
353
356
|
return i;
|
|
354
357
|
const m = [
|
|
@@ -364,27 +367,27 @@ const l = (t, e) => t?.toLowerCase() === e?.toLowerCase(), $e = (t) => l(t, et),
|
|
|
364
367
|
a,
|
|
365
368
|
[
|
|
366
369
|
t,
|
|
367
|
-
o.times(1 -
|
|
370
|
+
o.times(1 - n / 100).toFixed(0, u.ROUND_DOWN)
|
|
368
371
|
]
|
|
369
372
|
];
|
|
370
373
|
}, re = ({
|
|
371
374
|
assetAddress: t,
|
|
372
375
|
swapQuotes: e,
|
|
373
|
-
swapParams:
|
|
374
|
-
slippageToleranceForContractTransaction:
|
|
376
|
+
swapParams: s,
|
|
377
|
+
slippageToleranceForContractTransaction: n,
|
|
375
378
|
routerKey: r
|
|
376
379
|
}) => {
|
|
377
|
-
if (!
|
|
380
|
+
if (!s)
|
|
378
381
|
return {
|
|
379
382
|
supportedAsset: t,
|
|
380
383
|
withdrawData: "",
|
|
381
384
|
slippageTolerance: BigInt(0)
|
|
382
385
|
};
|
|
383
|
-
const { srcData: a, dstData: o } =
|
|
386
|
+
const { srcData: a, dstData: o } = s, i = a.map(({ asset: m, amount: y }) => {
|
|
384
387
|
const f = e?.[ne({
|
|
385
388
|
sourceAddress: m,
|
|
386
389
|
amount: y.toString()
|
|
387
|
-
})]?.find((
|
|
390
|
+
})]?.find((Q) => Q.routerKey === r);
|
|
388
391
|
return {
|
|
389
392
|
asset: m,
|
|
390
393
|
amount: y,
|
|
@@ -394,48 +397,48 @@ const l = (t, e) => t?.toLowerCase() === e?.toLowerCase(), $e = (t) => l(t, et),
|
|
|
394
397
|
}
|
|
395
398
|
};
|
|
396
399
|
}), c = h(
|
|
397
|
-
|
|
400
|
+
rt,
|
|
398
401
|
[i]
|
|
399
|
-
), d = h(
|
|
402
|
+
), d = h(ot, [
|
|
400
403
|
{
|
|
401
404
|
encodedSrcData: c,
|
|
402
405
|
dstData: {
|
|
403
406
|
dstAddress: o.asset,
|
|
404
407
|
dstAmount: o.amount
|
|
405
408
|
},
|
|
406
|
-
slippage:
|
|
409
|
+
slippage: n
|
|
407
410
|
}
|
|
408
411
|
]);
|
|
409
412
|
return {
|
|
410
413
|
supportedAsset: t,
|
|
411
414
|
withdrawData: d,
|
|
412
|
-
slippageTolerance:
|
|
415
|
+
slippageTolerance: n
|
|
413
416
|
};
|
|
414
|
-
},
|
|
417
|
+
}, Xe = ({
|
|
415
418
|
chainId: t,
|
|
416
419
|
txHash: e,
|
|
417
|
-
error:
|
|
420
|
+
error: s
|
|
418
421
|
}) => {
|
|
419
|
-
if (t !== w.id || !e || !
|
|
422
|
+
if (t !== w.id || !e || !s)
|
|
420
423
|
return !1;
|
|
421
|
-
const
|
|
422
|
-
return /\bNo Result\b/i.test(
|
|
423
|
-
},
|
|
424
|
+
const n = s instanceof Error ? s.message : String(s);
|
|
425
|
+
return /\bNo Result\b/i.test(n);
|
|
426
|
+
}, ze = ({
|
|
424
427
|
chainId: t,
|
|
425
428
|
action: e,
|
|
426
|
-
isRabbyWallet:
|
|
427
|
-
}) => e === "update_ondo_prices" && t === w.id &&
|
|
429
|
+
isRabbyWallet: s
|
|
430
|
+
}) => e === "update_ondo_prices" && t === w.id && s ? it : t ? ct[t] ?? 0 : 0, Qe = (t, e) => dt[e]?.nativeTokenSymbol === t, Ze = ({
|
|
428
431
|
nativeTokenBalance: t,
|
|
429
432
|
tokenDecimals: e,
|
|
430
|
-
gasPrice:
|
|
433
|
+
gasPrice: s
|
|
431
434
|
}) => {
|
|
432
|
-
const
|
|
433
|
-
|
|
435
|
+
const n = new u(s).multipliedBy(ut).shiftedBy(-e), r = new u(t).minus(
|
|
436
|
+
n
|
|
434
437
|
);
|
|
435
438
|
return r.gt("0") ? r : new u("0");
|
|
436
|
-
},
|
|
439
|
+
}, Je = (t) => pt.includes(t), ts = (t) => {
|
|
437
440
|
const e = Object.values(t).reduce(
|
|
438
|
-
(
|
|
441
|
+
(s, { type: n }) => (s[n] = s[n] + 1, s),
|
|
439
442
|
{ string: 0, number: 0 }
|
|
440
443
|
);
|
|
441
444
|
if (e.string > 10)
|
|
@@ -443,180 +446,180 @@ const l = (t, e) => t?.toLowerCase() === e?.toLowerCase(), $e = (t) => l(t, et),
|
|
|
443
446
|
if (e.number > 40)
|
|
444
447
|
throw new Error("logger params must contain up to 40 numeric values");
|
|
445
448
|
return !0;
|
|
446
|
-
}, oe = (t, e = 150) => t.length > e ? t.substring(0, e) : t,
|
|
447
|
-
...
|
|
448
|
-
...
|
|
449
|
+
}, oe = (t, e = 150) => t.length > e ? t.substring(0, e) : t, X = () => ({
|
|
450
|
+
...q().stringErrors,
|
|
451
|
+
...lt
|
|
449
452
|
}), ie = () => [
|
|
450
|
-
...Object.keys(
|
|
451
|
-
...Object.keys(
|
|
453
|
+
...Object.keys(X()),
|
|
454
|
+
...Object.keys(v)
|
|
452
455
|
], ce = /^dh\d+$/i, ue = (t, e) => ce.test(e) ? new RegExp(`\\b${e}\\b`, "i").test(t) : t.includes(e.toLowerCase()), C = (t, e) => {
|
|
453
|
-
const
|
|
454
|
-
return [...e ?? ie()].sort((
|
|
455
|
-
}, M = (t) =>
|
|
456
|
-
const { selectorErrors: e } =
|
|
457
|
-
if (
|
|
458
|
-
return { title:
|
|
456
|
+
const s = t.toLowerCase();
|
|
457
|
+
return [...e ?? ie()].sort((n, r) => r.length - n.length).find((n) => ue(s, n));
|
|
458
|
+
}, M = (t) => X()[t] ?? v[t], de = /\b0x[0-9a-f]{8}\b/i, pe = (t) => t.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), le = (t) => {
|
|
459
|
+
const { selectorErrors: e } = q(), s = t.match(de)?.[0]?.toLowerCase(), n = s ? e[s] : void 0;
|
|
460
|
+
if (n)
|
|
461
|
+
return { title: n.title, hint: n.hint };
|
|
459
462
|
const r = Object.values(e).find(
|
|
460
463
|
(a) => new RegExp(
|
|
461
464
|
`\\b${pe(a.signature.split("(")[0] ?? "")}\\b`
|
|
462
465
|
).test(t)
|
|
463
466
|
);
|
|
464
467
|
return r ? { title: r.title, hint: r.hint } : void 0;
|
|
465
|
-
},
|
|
468
|
+
}, es = ({
|
|
466
469
|
errorMessage: t,
|
|
467
470
|
abiErrors: e
|
|
468
471
|
}) => {
|
|
469
472
|
if (!t || t.includes("User rejected"))
|
|
470
473
|
return null;
|
|
471
|
-
const
|
|
472
|
-
if (
|
|
473
|
-
const o = C(
|
|
474
|
+
const s = e.find((o) => t.includes(o));
|
|
475
|
+
if (s) {
|
|
476
|
+
const o = C(s);
|
|
474
477
|
if (o)
|
|
475
478
|
return M(o);
|
|
476
479
|
}
|
|
477
|
-
const
|
|
478
|
-
if (
|
|
479
|
-
return M(
|
|
480
|
+
const n = C(t);
|
|
481
|
+
if (n)
|
|
482
|
+
return M(n);
|
|
480
483
|
const r = le(t);
|
|
481
484
|
if (r)
|
|
482
485
|
return r;
|
|
483
|
-
const [a] = t.split(
|
|
486
|
+
const [a] = t.split(s ? "." : "Contract").map((o) => o.trim());
|
|
484
487
|
return {
|
|
485
488
|
title: "Transaction failed",
|
|
486
|
-
hint: `${oe(a ?? "")} ${
|
|
489
|
+
hint: `${oe(a ?? "")} ${s ? `: ${s}` : ""}`
|
|
487
490
|
};
|
|
488
|
-
},
|
|
491
|
+
}, ss = (t) => typeof t == "number" && Number.isFinite(t), ns = (t) => typeof t == "bigint" && t !== BigInt(0), me = (t, e = Y) => new u(t).shiftedBy(-e).toNumber(), ye = (t) => !isNaN(parseFloat(t)) && !isNaN(t), Ae = ({
|
|
489
492
|
value: t,
|
|
490
493
|
minimumFractionDigits: e = 2,
|
|
491
|
-
maximumFractionDigits:
|
|
492
|
-
compact:
|
|
494
|
+
maximumFractionDigits: s = 2,
|
|
495
|
+
compact: n = !1,
|
|
493
496
|
normalize: r = !1
|
|
494
497
|
}) => new Intl.NumberFormat("en-US", {
|
|
495
498
|
style: "currency",
|
|
496
499
|
currency: "USD",
|
|
497
|
-
notation:
|
|
500
|
+
notation: n ? "compact" : void 0,
|
|
498
501
|
minimumFractionDigits: e,
|
|
499
|
-
maximumFractionDigits:
|
|
502
|
+
maximumFractionDigits: s
|
|
500
503
|
}).format(r ? me(t) : Number(t)), x = (t) => ye(t) ? new u(t).toFixed() : "", L = ["₀", "₁", "₂", "₃", "₄", "₅", "₆", "₇", "₈", "₉"], ge = ({
|
|
501
504
|
value: t,
|
|
502
505
|
decimals: e = 4
|
|
503
506
|
}) => {
|
|
504
|
-
const
|
|
505
|
-
if (
|
|
506
|
-
return x(
|
|
507
|
-
const r = (/e/i.test(t.toString()) ? parseFloat(t.toString()).toFixed(
|
|
507
|
+
const s = new u(t);
|
|
508
|
+
if (s.isGreaterThan(1) || s.isZero())
|
|
509
|
+
return x(s.toFixed(e));
|
|
510
|
+
const r = (/e/i.test(t.toString()) ? parseFloat(t.toString()).toFixed(Y) : t.toString()).match(/^0\.(0+)(\d+)$/);
|
|
508
511
|
if (r) {
|
|
509
512
|
const [, a, o] = r;
|
|
510
513
|
if (a.length >= e && a.length < L.length)
|
|
511
514
|
return `0.0${L[a.length]}${o.slice(0, 3)}`;
|
|
512
515
|
}
|
|
513
|
-
return x(
|
|
514
|
-
}, Ee = (t, e = 0) => `${t.toLocaleString("en-US", { maximumFractionDigits: e })}%`,
|
|
515
|
-
const
|
|
516
|
-
return Ee(
|
|
517
|
-
},
|
|
516
|
+
return x(s.toFixed(e));
|
|
517
|
+
}, Ee = (t, e = 0) => `${t.toLocaleString("en-US", { maximumFractionDigits: e })}%`, as = (t) => t.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ","), rs = (t, e, s = 0) => {
|
|
518
|
+
const n = ae(+t, e);
|
|
519
|
+
return Ee(n, s);
|
|
520
|
+
}, os = ({
|
|
518
521
|
currency: t,
|
|
519
522
|
value: e
|
|
520
|
-
}) => t === "USD" ? Ae({ value: e }) : `${
|
|
523
|
+
}) => t === "USD" ? Ae({ value: e }) : `${mt[t]} ${ge({
|
|
521
524
|
value: e,
|
|
522
|
-
decimals:
|
|
525
|
+
decimals: yt[t]
|
|
523
526
|
})}`, he = (t, e) => new u(
|
|
524
527
|
new u(t).toFixed(e, u.ROUND_DOWN)
|
|
525
|
-
).toString(), fe = (t, e = 3,
|
|
528
|
+
).toString(), fe = (t, e = 3, s = 2) => {
|
|
526
529
|
if (t.length <= 5)
|
|
527
530
|
return t;
|
|
528
|
-
const
|
|
529
|
-
return t.length <= e +
|
|
530
|
-
},
|
|
531
|
+
const n = "...";
|
|
532
|
+
return t.length <= e + s + n.length ? t : `${t.slice(0, e)}${n}${t.slice(-s)}`;
|
|
533
|
+
}, is = ({
|
|
531
534
|
balance: t,
|
|
532
535
|
symbol: e,
|
|
533
|
-
precision:
|
|
534
|
-
truncateSymbol:
|
|
535
|
-
}) => `${he(t,
|
|
536
|
+
precision: s,
|
|
537
|
+
truncateSymbol: n
|
|
538
|
+
}) => `${he(t, s)} ${n ? fe(e) : e}`, cs = (t) => {
|
|
536
539
|
if (!t)
|
|
537
540
|
return;
|
|
538
541
|
const e = t.match(/0x[a-fA-F0-9]{64}/);
|
|
539
542
|
if (!e)
|
|
540
543
|
return;
|
|
541
|
-
const
|
|
542
|
-
return `${
|
|
543
|
-
},
|
|
544
|
+
const s = e[0];
|
|
545
|
+
return `${s.slice(0, 4)}...${s.slice(-3)}`;
|
|
546
|
+
}, us = (t) => l(ht, t) || l(ft, t), ds = (t) => _t.some(
|
|
544
547
|
(e) => l(e, t)
|
|
545
|
-
),
|
|
548
|
+
), ps = (t) => At[t.toLowerCase()] ?? {
|
|
546
549
|
symbol: "",
|
|
547
550
|
decimals: 18,
|
|
548
551
|
address: b
|
|
549
|
-
},
|
|
552
|
+
}, ls = (t) => l(t, Tt) ? gt : Et, Te = (t) => `eth_${t}`, ms = ({
|
|
550
553
|
action: t,
|
|
551
554
|
log: e,
|
|
552
|
-
symbol:
|
|
553
|
-
vaultAddress:
|
|
555
|
+
symbol: s,
|
|
556
|
+
vaultAddress: n,
|
|
554
557
|
chainId: r
|
|
555
558
|
}) => {
|
|
556
559
|
const a = {
|
|
557
|
-
[T.SYMBOL.NAME]:
|
|
560
|
+
[T.SYMBOL.NAME]: s,
|
|
558
561
|
[T.CHAIN_ID.NAME]: r,
|
|
559
|
-
[T.ADDRESS.NAME]: Te(
|
|
562
|
+
[T.ADDRESS.NAME]: Te(n)
|
|
560
563
|
};
|
|
561
|
-
|
|
564
|
+
St[t].forEach((o) => {
|
|
562
565
|
e?.(o, a);
|
|
563
566
|
});
|
|
564
|
-
},
|
|
567
|
+
}, ys = (t) => Dt.some((e) => l(e, t)), As = (t) => wt[t.toLowerCase()] ?? {
|
|
565
568
|
symbol: "",
|
|
566
569
|
decimals: 18,
|
|
567
570
|
address: b
|
|
568
|
-
},
|
|
569
|
-
|
|
570
|
-
const
|
|
571
|
-
const
|
|
572
|
-
|
|
571
|
+
}, gs = (t) => bt[t.toLowerCase()], _e = "0x3333333333333333333333333333333333333333";
|
|
572
|
+
et.id + "", Ct.address, tt.id + "", Ot.address, J.id + "", Nt.address, Z.id + "", It.address, w.id + "", Rt.address, F.id + "", G.address;
|
|
573
|
+
const Es = (t) => l(t, _e), hs = () => G, fs = /* @__PURE__ */ new Map(), z = (t, e) => !e || e.size === 0 ? t : t.map((s) => {
|
|
574
|
+
const n = e.get(
|
|
575
|
+
s.supportedAsset.toLowerCase()
|
|
573
576
|
);
|
|
574
|
-
return
|
|
575
|
-
...
|
|
576
|
-
withdrawData:
|
|
577
|
-
slippageTolerance:
|
|
578
|
-
} :
|
|
577
|
+
return n ? {
|
|
578
|
+
...s,
|
|
579
|
+
withdrawData: n.withdrawData,
|
|
580
|
+
slippageTolerance: n.slippageTolerance
|
|
581
|
+
} : s;
|
|
579
582
|
}), Se = (t) => {
|
|
580
583
|
const e = t.find(
|
|
581
|
-
({ swapQuotes:
|
|
584
|
+
({ swapQuotes: s }) => s
|
|
582
585
|
);
|
|
583
586
|
return e?.swapQuotes ? Object.values(e.swapQuotes)[0]?.map(
|
|
584
|
-
({ routerKey:
|
|
587
|
+
({ routerKey: s }) => s
|
|
585
588
|
) ?? [] : [];
|
|
586
|
-
}, we = (t, e,
|
|
587
|
-
supportedAsset:
|
|
589
|
+
}, we = (t, e, s) => t.map(({ asset: n, swapParams: r, swapQuotes: a }) => !r || !a ? {
|
|
590
|
+
supportedAsset: n,
|
|
588
591
|
withdrawData: "",
|
|
589
|
-
slippageTolerance:
|
|
592
|
+
slippageTolerance: s
|
|
590
593
|
} : re({
|
|
591
|
-
assetAddress:
|
|
594
|
+
assetAddress: n,
|
|
592
595
|
swapQuotes: a,
|
|
593
596
|
swapParams: r,
|
|
594
|
-
slippageToleranceForContractTransaction:
|
|
597
|
+
slippageToleranceForContractTransaction: s,
|
|
595
598
|
routerKey: e
|
|
596
|
-
})), be = async (t, e,
|
|
599
|
+
})), be = async (t, e, s, n, r, a) => {
|
|
597
600
|
for (const o of t) {
|
|
598
|
-
const i =
|
|
601
|
+
const i = z(
|
|
599
602
|
we(
|
|
600
603
|
e,
|
|
601
604
|
o,
|
|
602
|
-
|
|
605
|
+
s
|
|
603
606
|
),
|
|
604
607
|
a
|
|
605
|
-
), { error: c } = await
|
|
608
|
+
), { error: c } = await n(...r, i);
|
|
606
609
|
if (!c)
|
|
607
610
|
return i;
|
|
608
611
|
}
|
|
609
612
|
return null;
|
|
610
|
-
},
|
|
611
|
-
const
|
|
613
|
+
}, Ts = (t, e, s) => {
|
|
614
|
+
const n = (t ?? []).map((r) => ({
|
|
612
615
|
supportedAsset: r,
|
|
613
616
|
withdrawData: "",
|
|
614
617
|
slippageTolerance: e
|
|
615
618
|
}));
|
|
616
|
-
return
|
|
617
|
-
},
|
|
619
|
+
return z(n, s);
|
|
620
|
+
}, _s = async (t, e, s, n, r) => {
|
|
618
621
|
for (const a of t) {
|
|
619
|
-
const o =
|
|
622
|
+
const o = j(a);
|
|
620
623
|
try {
|
|
621
624
|
const i = await e(a), c = Se(
|
|
622
625
|
i
|
|
@@ -624,8 +627,8 @@ const En = (t) => l(t, _e), hn = () => Y, fn = /* @__PURE__ */ new Map(), j = (t
|
|
|
624
627
|
c,
|
|
625
628
|
i,
|
|
626
629
|
o,
|
|
627
|
-
n,
|
|
628
630
|
s,
|
|
631
|
+
n,
|
|
629
632
|
r
|
|
630
633
|
);
|
|
631
634
|
if (d)
|
|
@@ -640,9 +643,9 @@ const En = (t) => l(t, _e), hn = () => Y, fn = /* @__PURE__ */ new Map(), j = (t
|
|
|
640
643
|
}
|
|
641
644
|
}
|
|
642
645
|
return null;
|
|
643
|
-
},
|
|
644
|
-
fetchAaveSwapParams:
|
|
645
|
-
fetchAaveSwapQuotes:
|
|
646
|
+
}, Ss = async (t, e, {
|
|
647
|
+
fetchAaveSwapParams: s,
|
|
648
|
+
fetchAaveSwapQuotes: n,
|
|
646
649
|
withdrawAmountD18: r,
|
|
647
650
|
slippage: a
|
|
648
651
|
}) => Promise.all(
|
|
@@ -650,12 +653,12 @@ const En = (t) => l(t, _e), hn = () => Y, fn = /* @__PURE__ */ new Map(), j = (t
|
|
|
650
653
|
if (!l(o, e))
|
|
651
654
|
return { asset: o };
|
|
652
655
|
try {
|
|
653
|
-
const c = await
|
|
656
|
+
const c = await s({
|
|
654
657
|
withdrawAmountD18: r,
|
|
655
658
|
slippage: a
|
|
656
659
|
});
|
|
657
660
|
if (c?.srcData.length) {
|
|
658
|
-
const d = await
|
|
661
|
+
const d = await n({
|
|
659
662
|
swapParams: c,
|
|
660
663
|
slippage: a
|
|
661
664
|
});
|
|
@@ -666,15 +669,15 @@ const En = (t) => l(t, _e), hn = () => Y, fn = /* @__PURE__ */ new Map(), j = (t
|
|
|
666
669
|
return console.error(c), { asset: o };
|
|
667
670
|
}
|
|
668
671
|
})
|
|
669
|
-
), B = (t) => Math.round(t * 100) / 100,
|
|
672
|
+
), B = (t) => Math.round(t * 100) / 100, ws = ({
|
|
670
673
|
maxSlippage: t,
|
|
671
|
-
candidates: e =
|
|
674
|
+
candidates: e = Mt
|
|
672
675
|
}) => {
|
|
673
676
|
if (!Number.isFinite(t) || t <= 0)
|
|
674
677
|
return [];
|
|
675
|
-
const
|
|
676
|
-
return r.add(
|
|
677
|
-
}, P = 1000000000000000000n, De = 1000000n, U = 10000n, $ = 100n,
|
|
678
|
+
const s = B(Math.min(t, 100)), n = e.filter((a) => a > 0 && a <= s).map(B), r = new Set(n);
|
|
679
|
+
return r.add(s), r.add(t), Array.from(r).sort((a, o) => a - o);
|
|
680
|
+
}, P = 1000000000000000000n, De = 1000000n, U = 10000n, $ = 100n, bs = (t) => ({
|
|
678
681
|
quotes: t.quotes.map(
|
|
679
682
|
(e) => ({
|
|
680
683
|
chainId: p(e.chainId, "chainId"),
|
|
@@ -689,8 +692,8 @@ const En = (t) => l(t, _e), hn = () => Y, fn = /* @__PURE__ */ new Map(), j = (t
|
|
|
689
692
|
})
|
|
690
693
|
),
|
|
691
694
|
signatures: t.signatures.map(E)
|
|
692
|
-
}), Re = (t, e,
|
|
693
|
-
const
|
|
695
|
+
}), Re = (t, e, s) => {
|
|
696
|
+
const n = BigInt(Math.max(0, Math.round(s * 100))), r = n > $ ? $ : n, a = U - r, i = t * e / P * a * De, c = U * P;
|
|
694
697
|
return (i + c - 1n) / c;
|
|
695
698
|
}, Ie = (t, e) => ({
|
|
696
699
|
chainId: e,
|
|
@@ -702,40 +705,40 @@ const En = (t) => l(t, _e), hn = () => Y, fn = /* @__PURE__ */ new Map(), j = (t
|
|
|
702
705
|
expiration: p(t.expiration, "expiration"),
|
|
703
706
|
side: Number(t.side),
|
|
704
707
|
additionalData: O(t.additionalData)
|
|
705
|
-
}),
|
|
708
|
+
}), Ds = ({
|
|
706
709
|
attestation: t,
|
|
707
710
|
chainId: e,
|
|
708
|
-
slippagePercent:
|
|
711
|
+
slippagePercent: s
|
|
709
712
|
}) => {
|
|
710
|
-
const
|
|
711
|
-
return h(
|
|
713
|
+
const n = Ie(t, e);
|
|
714
|
+
return h(Pt, [
|
|
712
715
|
{
|
|
713
|
-
attestationSignature:
|
|
714
|
-
quote:
|
|
716
|
+
attestationSignature: ee(t.signature),
|
|
717
|
+
quote: n,
|
|
715
718
|
amountOutMinimum: Re(
|
|
716
|
-
|
|
717
|
-
|
|
718
|
-
|
|
719
|
+
n.quantity,
|
|
720
|
+
n.price,
|
|
721
|
+
s
|
|
719
722
|
)
|
|
720
723
|
}
|
|
721
724
|
]);
|
|
722
|
-
},
|
|
723
|
-
(
|
|
725
|
+
}, Rs = (t) => [...t.reduce(
|
|
726
|
+
(s, n) => s.has(n.accountId) ? s : s.set(n.accountId, n),
|
|
724
727
|
/* @__PURE__ */ new Map()
|
|
725
|
-
).values()].map(({ accountId:
|
|
726
|
-
accountId:
|
|
727
|
-
marketId:
|
|
728
|
+
).values()].map(({ accountId: s, marketId: n }) => ({
|
|
729
|
+
accountId: s,
|
|
730
|
+
marketId: n,
|
|
728
731
|
collaterals: t.filter(
|
|
729
|
-
(r) => r.accountId ===
|
|
732
|
+
(r) => r.accountId === s && !r.isDebt
|
|
730
733
|
),
|
|
731
734
|
debt: t.find(
|
|
732
|
-
(r) => r.accountId ===
|
|
735
|
+
(r) => r.accountId === s && r.isDebt
|
|
733
736
|
)
|
|
734
|
-
})),
|
|
737
|
+
})), Is = ({
|
|
735
738
|
collateral: t,
|
|
736
739
|
dytmOffice: e,
|
|
737
|
-
processor:
|
|
738
|
-
gmToken:
|
|
740
|
+
processor: s,
|
|
741
|
+
gmToken: n,
|
|
739
742
|
ondoGMSwap: r,
|
|
740
743
|
usdc: a,
|
|
741
744
|
gmAmount: o,
|
|
@@ -747,13 +750,13 @@ const En = (t) => l(t, _e), hn = () => Y, fn = /* @__PURE__ */ new Map(), j = (t
|
|
|
747
750
|
// 1 · pull GM collateral out of the split account -> processor
|
|
748
751
|
to: e,
|
|
749
752
|
data: g({
|
|
750
|
-
abi:
|
|
753
|
+
abi: k,
|
|
751
754
|
functionName: "withdraw",
|
|
752
755
|
args: [
|
|
753
756
|
{
|
|
754
757
|
account: t.accountId,
|
|
755
758
|
tokenId: t.tokenId,
|
|
756
|
-
receiver:
|
|
759
|
+
receiver: s,
|
|
757
760
|
assets: o,
|
|
758
761
|
shares: 0n,
|
|
759
762
|
extraData: "0x"
|
|
@@ -763,9 +766,9 @@ const En = (t) => l(t, _e), hn = () => Y, fn = /* @__PURE__ */ new Map(), j = (t
|
|
|
763
766
|
},
|
|
764
767
|
{
|
|
765
768
|
// 2 · approve the GM token to Ondo's swap contract
|
|
766
|
-
to:
|
|
769
|
+
to: n,
|
|
767
770
|
data: g({
|
|
768
|
-
abi:
|
|
771
|
+
abi: W,
|
|
769
772
|
functionName: "approve",
|
|
770
773
|
args: [r, o]
|
|
771
774
|
})
|
|
@@ -774,31 +777,31 @@ const En = (t) => l(t, _e), hn = () => Y, fn = /* @__PURE__ */ new Map(), j = (t
|
|
|
774
777
|
// 3 · redeem GM -> USDC with the signed attestation
|
|
775
778
|
to: r,
|
|
776
779
|
data: g({
|
|
777
|
-
abi:
|
|
780
|
+
abi: $t,
|
|
778
781
|
functionName: "swapExactInWithAttestation",
|
|
779
|
-
args: [
|
|
782
|
+
args: [n, o, a, i, c, d]
|
|
780
783
|
})
|
|
781
784
|
}
|
|
782
|
-
],
|
|
785
|
+
], Ns = ({
|
|
783
786
|
accountId: t,
|
|
784
787
|
debtKey: e,
|
|
785
|
-
dytmOffice:
|
|
786
|
-
usdc:
|
|
788
|
+
dytmOffice: s,
|
|
789
|
+
usdc: n
|
|
787
790
|
}) => [
|
|
788
791
|
{
|
|
789
792
|
// approve USDC to the DYTM Office for the repay
|
|
790
|
-
to:
|
|
793
|
+
to: n,
|
|
791
794
|
data: g({
|
|
792
|
-
abi:
|
|
795
|
+
abi: W,
|
|
793
796
|
functionName: "approve",
|
|
794
|
-
args: [
|
|
797
|
+
args: [s, I]
|
|
795
798
|
})
|
|
796
799
|
},
|
|
797
800
|
{
|
|
798
801
|
// repay the slice's whole USDC debt
|
|
799
|
-
to:
|
|
802
|
+
to: s,
|
|
800
803
|
data: g({
|
|
801
|
-
abi:
|
|
804
|
+
abi: k,
|
|
802
805
|
functionName: "repay",
|
|
803
806
|
args: [
|
|
804
807
|
{
|
|
@@ -814,94 +817,95 @@ const En = (t) => l(t, _e), hn = () => Y, fn = /* @__PURE__ */ new Map(), j = (t
|
|
|
814
817
|
]
|
|
815
818
|
})
|
|
816
819
|
}
|
|
817
|
-
],
|
|
820
|
+
], Os = ({
|
|
818
821
|
actions: t,
|
|
819
822
|
outputAsset: e,
|
|
820
|
-
minOutputAmount:
|
|
821
|
-
}) => h(
|
|
822
|
-
{ actions: t, outputAsset: e, minOutputAmount:
|
|
823
|
+
minOutputAmount: s
|
|
824
|
+
}) => h(Ft, [
|
|
825
|
+
{ actions: t, outputAsset: e, minOutputAmount: s }
|
|
823
826
|
]);
|
|
824
827
|
export {
|
|
825
|
-
|
|
826
|
-
|
|
827
|
-
|
|
828
|
-
C,
|
|
829
|
-
|
|
830
|
-
|
|
831
|
-
|
|
832
|
-
|
|
833
|
-
|
|
834
|
-
|
|
835
|
-
|
|
836
|
-
|
|
837
|
-
|
|
838
|
-
|
|
839
|
-
|
|
840
|
-
|
|
841
|
-
|
|
842
|
-
|
|
843
|
-
|
|
844
|
-
|
|
828
|
+
bs as $,
|
|
829
|
+
se as A,
|
|
830
|
+
q as B,
|
|
831
|
+
We as C,
|
|
832
|
+
C as D,
|
|
833
|
+
fs as E,
|
|
834
|
+
ps as F,
|
|
835
|
+
ls as G,
|
|
836
|
+
As as H,
|
|
837
|
+
gs as I,
|
|
838
|
+
hs as J,
|
|
839
|
+
Ze as K,
|
|
840
|
+
ae as L,
|
|
841
|
+
He as M,
|
|
842
|
+
ze as N,
|
|
843
|
+
j as O,
|
|
844
|
+
cs as P,
|
|
845
|
+
Rs as Q,
|
|
846
|
+
Ye as R,
|
|
847
|
+
ds as S,
|
|
845
848
|
S as T,
|
|
846
|
-
|
|
847
|
-
|
|
848
|
-
|
|
849
|
-
|
|
850
|
-
|
|
851
|
-
|
|
852
|
-
|
|
853
|
-
|
|
854
|
-
|
|
855
|
-
|
|
856
|
-
|
|
857
|
-
|
|
858
|
-
|
|
859
|
-
|
|
860
|
-
|
|
861
|
-
|
|
862
|
-
|
|
863
|
-
|
|
864
|
-
|
|
865
|
-
|
|
866
|
-
|
|
867
|
-
|
|
868
|
-
|
|
869
|
-
|
|
870
|
-
|
|
871
|
-
|
|
872
|
-
|
|
873
|
-
|
|
874
|
-
|
|
875
|
-
|
|
876
|
-
|
|
877
|
-
|
|
878
|
-
|
|
879
|
-
|
|
880
|
-
|
|
881
|
-
|
|
882
|
-
|
|
849
|
+
us as U,
|
|
850
|
+
ys as V,
|
|
851
|
+
Es as W,
|
|
852
|
+
Qe as X,
|
|
853
|
+
Je as Y,
|
|
854
|
+
ms as Z,
|
|
855
|
+
Ie as _,
|
|
856
|
+
zt as a,
|
|
857
|
+
z as a0,
|
|
858
|
+
Ve as a1,
|
|
859
|
+
es as a2,
|
|
860
|
+
ke as a3,
|
|
861
|
+
ve as a4,
|
|
862
|
+
Xe as a5,
|
|
863
|
+
Ge as a6,
|
|
864
|
+
p as a7,
|
|
865
|
+
O as a8,
|
|
866
|
+
Te as a9,
|
|
867
|
+
fe as aa,
|
|
868
|
+
be as ab,
|
|
869
|
+
_s as ac,
|
|
870
|
+
ts as ad,
|
|
871
|
+
$e as ae,
|
|
872
|
+
ss as af,
|
|
873
|
+
l as ag,
|
|
874
|
+
Ae as ah,
|
|
875
|
+
ns as ai,
|
|
876
|
+
me as aj,
|
|
877
|
+
Be as ak,
|
|
878
|
+
Le as al,
|
|
879
|
+
_e as am,
|
|
880
|
+
ge as an,
|
|
881
|
+
Ue as ao,
|
|
882
|
+
Ee as ap,
|
|
883
|
+
ye as aq,
|
|
884
|
+
as as ar,
|
|
885
|
+
x as as,
|
|
886
|
+
ee as b,
|
|
883
887
|
re as c,
|
|
884
888
|
we as d,
|
|
885
|
-
|
|
886
|
-
|
|
889
|
+
Is as e,
|
|
890
|
+
Ns as f,
|
|
887
891
|
ne as g,
|
|
888
|
-
|
|
889
|
-
|
|
892
|
+
je as h,
|
|
893
|
+
qe as i,
|
|
890
894
|
xe as j,
|
|
891
895
|
Re as k,
|
|
892
|
-
|
|
893
|
-
|
|
894
|
-
|
|
895
|
-
|
|
896
|
+
Ts as l,
|
|
897
|
+
Ds as m,
|
|
898
|
+
Os as n,
|
|
899
|
+
Ss as o,
|
|
896
900
|
Pe as p,
|
|
897
901
|
E as q,
|
|
898
902
|
Se as r,
|
|
899
|
-
|
|
903
|
+
Zt as s,
|
|
900
904
|
he as t,
|
|
901
|
-
|
|
902
|
-
|
|
903
|
-
|
|
904
|
-
|
|
905
|
-
|
|
906
|
-
|
|
905
|
+
os as u,
|
|
906
|
+
rs as v,
|
|
907
|
+
is as w,
|
|
908
|
+
ws as x,
|
|
909
|
+
Ke as y,
|
|
910
|
+
Fe as z
|
|
907
911
|
};
|