@orbs-network/spot-react 2.1.13 → 2.1.15
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 +13 -6
- package/dist/spot-react/src/context/client-error-notice.d.ts.map +1 -1
- package/dist/spot-react/src/context/create-spot-store.d.ts +2 -1
- package/dist/spot-react/src/context/create-spot-store.d.ts.map +1 -1
- package/dist/spot-react/src/context/error-boundary.d.ts.map +1 -1
- package/dist/spot-react/src/context/order-form-context.d.ts.map +1 -1
- package/dist/spot-react/src/context/spot-provider.d.ts.map +1 -1
- package/dist/spot-react/src/context/spot-resources.d.ts +6 -0
- package/dist/spot-react/src/context/spot-resources.d.ts.map +1 -0
- package/dist/spot-react/src/context/{spot-runtime-context.d.ts → spot-trading-context.d.ts} +7 -6
- package/dist/spot-react/src/context/spot-trading-context.d.ts.map +1 -0
- package/dist/spot-react/src/context/use-client.d.ts +2 -0
- package/dist/spot-react/src/context/use-client.d.ts.map +1 -1
- package/dist/spot-react/src/context/use-spot-provider-state.d.ts +2 -2
- package/dist/spot-react/src/context/use-spot-provider-state.d.ts.map +1 -1
- package/dist/spot-react/src/execute-order.d.ts +1 -1
- package/dist/spot-react/src/execute-order.d.ts.map +1 -1
- package/dist/spot-react/src/hooks/order-hooks.d.ts +2 -2
- package/dist/spot-react/src/hooks/order-hooks.d.ts.map +1 -1
- package/dist/spot-react/src/hooks/use-cancel-order.d.ts.map +1 -1
- package/dist/spot-react/src/index.d.ts +1 -1
- package/dist/spot-react/src/index.d.ts.map +1 -1
- package/dist/spot-react/src/order-history-data.d.ts +14 -1
- package/dist/spot-react/src/order-history-data.d.ts.map +1 -1
- package/dist/spot-react/src/types.d.ts +0 -1
- package/dist/spot-react/src/types.d.ts.map +1 -1
- package/dist/spot-react.js +801 -825
- package/dist/spot-react.umd.cjs +1 -1
- package/package.json +2 -2
- package/dist/spot-react/src/context/spot-runtime-context.d.ts.map +0 -1
- package/dist/spot-react/src/context/use-spot-analytics.d.ts +0 -3
- package/dist/spot-react/src/context/use-spot-analytics.d.ts.map +0 -1
package/dist/spot-react.js
CHANGED
|
@@ -1,32 +1,32 @@
|
|
|
1
1
|
"use client";
|
|
2
|
-
var
|
|
3
|
-
var
|
|
4
|
-
var oe = (e, t, n) =>
|
|
5
|
-
import { OrderStatus as J, Module as
|
|
6
|
-
import { DISCLAIMER_URL as
|
|
7
|
-
import { jsx as
|
|
8
|
-
import { createContext as le, useContext as me, useState as
|
|
9
|
-
import { useStore as
|
|
2
|
+
var xe = Object.defineProperty;
|
|
3
|
+
var Fe = (e, t, n) => t in e ? xe(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
|
|
4
|
+
var oe = (e, t, n) => Fe(e, typeof t != "symbol" ? t + "" : t, n);
|
|
5
|
+
import { OrderStatus as J, Module as X, createClient as Ue, analytics as De, calculateOrderForm as Ge, isNativeAddress as Q, eqIgnoreCase as Pe, toAmountRaw as k, toAmountUI as ne, isTxRejected as ve, getOrderLimitPriceRate as Me, getTriggerPriceRate as Be, getOrderExecutionRate as we, getOrderFillDelayMillis as _e, getTwapConfig as qe, invertPriceInput as fe, setUIVersion as We } from "@orbs-network/spot-ui";
|
|
6
|
+
import { DISCLAIMER_URL as ur, InputErrors as lr, Module as mr, ORBS_LOGO as gr, ORBS_SLTP_FAQ_URL as Pr, ORBS_TWAP_FAQ_URL as fr, ORBS_WEBSITE_URL as hr, OrderFilter as Er, OrderStatus as Ir, OrderType as Sr, Partners as Or, TimeUnit as pr, calculateOrderForm as Ar, createClient as vr, eqIgnoreCase as wr, getOrderExecutionRate as Cr, getOrderFillDelayMillis as yr, getOrderLimitPriceRate as Rr, getTriggerPriceRate as Tr, getTwapConfig as Nr, invertPriceInput as Lr, isNativeAddress as xr, isTxRejected as Fr, toAmountRaw as Ur, toAmountUI as Dr } from "@orbs-network/spot-ui";
|
|
7
|
+
import { jsx as U, jsxs as ue, Fragment as Ke } from "react/jsx-runtime";
|
|
8
|
+
import { createContext as le, useContext as me, useState as Ve, useCallback as v, useMemo as R, useEffect as ie, Component as He, useRef as je } from "react";
|
|
9
|
+
import { useStore as Je } from "zustand";
|
|
10
10
|
import { createStore as ze } from "zustand/vanilla";
|
|
11
|
-
const
|
|
12
|
-
version:
|
|
13
|
-
},
|
|
11
|
+
const $e = "2.1.15", Qe = {
|
|
12
|
+
version: $e
|
|
13
|
+
}, Ce = le(null), Ye = ({
|
|
14
14
|
children: e,
|
|
15
15
|
value: t
|
|
16
|
-
}) => /* @__PURE__ */
|
|
17
|
-
const e = me(
|
|
16
|
+
}) => /* @__PURE__ */ U(Ce.Provider, { value: t, children: e }), x = () => {
|
|
17
|
+
const e = me(Ce);
|
|
18
18
|
if (e === null)
|
|
19
|
-
throw new Error("
|
|
19
|
+
throw new Error("useSpotTrading must be used within SpotProvider");
|
|
20
20
|
return e;
|
|
21
21
|
};
|
|
22
|
-
var q = /* @__PURE__ */ ((e) => (e[e.LOADING = 1] = "LOADING", e[e.SUCCESS = 2] = "SUCCESS", e[e.FAILED = 3] = "FAILED", e))(q || {}), d = /* @__PURE__ */ ((e) => (e.IDLE = "idle", e.PREPARING = "preparing", e.WRAPPING = "wrapping", e.APPROVING = "approving", e.SIGNING = "signing", e.SUBMITTING = "submitting", e.SUCCESS = "success", e.FAILED = "failed", e.REJECTED = "rejected", e))(d || {}),
|
|
23
|
-
const
|
|
22
|
+
var q = /* @__PURE__ */ ((e) => (e[e.LOADING = 1] = "LOADING", e[e.SUCCESS = 2] = "SUCCESS", e[e.FAILED = 3] = "FAILED", e))(q || {}), d = /* @__PURE__ */ ((e) => (e.IDLE = "idle", e.PREPARING = "preparing", e.WRAPPING = "wrapping", e.APPROVING = "approving", e.SIGNING = "signing", e.SUBMITTING = "submitting", e.SUCCESS = "success", e.FAILED = "failed", e.REJECTED = "rejected", e))(d || {}), ee = /* @__PURE__ */ ((e) => (e.TRIGGER_MARKET_PRICE = "triggerMarketPriceDisclaimer", e.MARKET_PRICE = "marketOrderDisclaimer", e.LIMIT_PRICE = "limitOrderDisclaimer", e))(ee || {}), z = /* @__PURE__ */ ((e) => (e.WRAP = "wrap", e.APPROVE = "approve", e.CREATE = "create", e))(z || {});
|
|
23
|
+
const Xe = /* @__PURE__ */ new Set([
|
|
24
24
|
d.PREPARING,
|
|
25
25
|
d.WRAPPING,
|
|
26
26
|
d.APPROVING,
|
|
27
27
|
d.SIGNING,
|
|
28
28
|
d.SUBMITTING
|
|
29
|
-
]),
|
|
29
|
+
]), Ze = {
|
|
30
30
|
[d.IDLE]: /* @__PURE__ */ new Set(),
|
|
31
31
|
[d.PREPARING]: /* @__PURE__ */ new Set([
|
|
32
32
|
d.PREPARING,
|
|
@@ -63,19 +63,19 @@ const $e = /* @__PURE__ */ new Set([
|
|
|
63
63
|
[d.SUCCESS]: /* @__PURE__ */ new Set(),
|
|
64
64
|
[d.FAILED]: /* @__PURE__ */ new Set(),
|
|
65
65
|
[d.REJECTED]: /* @__PURE__ */ new Set()
|
|
66
|
-
},
|
|
66
|
+
}, te = (e) => ({
|
|
67
67
|
phase: d.IDLE,
|
|
68
68
|
completedWrap: e
|
|
69
|
-
}),
|
|
70
|
-
if (
|
|
69
|
+
}), $ = (e) => Xe.has(e), be = (e) => e === d.IDLE || e === d.FAILED || e === d.REJECTED, ke = (e, t) => Ze[e].has(t), et = (e) => {
|
|
70
|
+
if ($(e)) return q.LOADING;
|
|
71
71
|
if (e === d.SUCCESS) return q.SUCCESS;
|
|
72
72
|
if (e === d.FAILED || e === d.REJECTED)
|
|
73
73
|
return q.FAILED;
|
|
74
|
-
},
|
|
75
|
-
if (e === d.WRAPPING) return
|
|
76
|
-
if (e === d.APPROVING) return
|
|
74
|
+
}, tt = (e) => {
|
|
75
|
+
if (e === d.WRAPPING) return z.WRAP;
|
|
76
|
+
if (e === d.APPROVING) return z.APPROVE;
|
|
77
77
|
if (e === d.SIGNING || e === d.SUBMITTING)
|
|
78
|
-
return
|
|
78
|
+
return z.CREATE;
|
|
79
79
|
}, ge = (e) => {
|
|
80
80
|
if (e instanceof Error) return e.message;
|
|
81
81
|
if (typeof e == "string") return e;
|
|
@@ -84,17 +84,17 @@ const $e = /* @__PURE__ */ new Set([
|
|
|
84
84
|
if (typeof t == "string") return t;
|
|
85
85
|
}
|
|
86
86
|
return "Unknown error";
|
|
87
|
-
},
|
|
87
|
+
}, rt = (e) => {
|
|
88
88
|
if (typeof e != "object" || e === null) return 0;
|
|
89
89
|
const t = Reflect.get(e, "code");
|
|
90
90
|
return typeof t == "number" && Number.isFinite(t) ? t : typeof t == "string" && /^-?\d+$/.test(t) ? Number(t) : 0;
|
|
91
|
-
},
|
|
91
|
+
}, re = (e) => e instanceof Error ? e : new Error(ge(e)), se = (e) => {
|
|
92
92
|
const t = ge(e), n = t.match(/,\s*code\s*:\s*(-?\d+)/i);
|
|
93
93
|
return {
|
|
94
94
|
message: t.replace(/^error\s*:/i, "").replace(/,\s*code\s*:\s*-?\d+/i, "").trim() || "Unknown error",
|
|
95
|
-
code:
|
|
95
|
+
code: rt(e) || (n ? Number(n[1]) : 0)
|
|
96
96
|
};
|
|
97
|
-
},
|
|
97
|
+
}, I = (e) => {
|
|
98
98
|
if (e)
|
|
99
99
|
try {
|
|
100
100
|
const t = e();
|
|
@@ -102,27 +102,27 @@ const $e = /* @__PURE__ */ new Set([
|
|
|
102
102
|
});
|
|
103
103
|
} catch {
|
|
104
104
|
}
|
|
105
|
-
},
|
|
105
|
+
}, nt = ({
|
|
106
106
|
execution: e,
|
|
107
107
|
account: t,
|
|
108
108
|
chainId: n,
|
|
109
109
|
inputTokenAddress: r,
|
|
110
|
-
inputAmountRaw:
|
|
110
|
+
inputAmountRaw: i
|
|
111
111
|
}) => {
|
|
112
|
-
const
|
|
113
|
-
if ((
|
|
114
|
-
return
|
|
115
|
-
},
|
|
112
|
+
const o = e.completedWrap;
|
|
113
|
+
if ((o == null ? void 0 : o.account.toLowerCase()) === t.toLowerCase() && o.chainId === n && o.inputTokenAddress.toLowerCase() === r.toLowerCase() && it(o.inputAmountRaw, i))
|
|
114
|
+
return o;
|
|
115
|
+
}, it = (e, t) => {
|
|
116
116
|
try {
|
|
117
117
|
return BigInt(e) >= BigInt(t);
|
|
118
118
|
} catch {
|
|
119
119
|
return !1;
|
|
120
120
|
}
|
|
121
|
-
},
|
|
122
|
-
const t =
|
|
121
|
+
}, ot = 2e4, he = /* @__PURE__ */ new WeakMap(), Ee = (e) => {
|
|
122
|
+
const t = he.get(e);
|
|
123
123
|
if (t) return t;
|
|
124
124
|
const n = {
|
|
125
|
-
all: [...e].sort((r,
|
|
125
|
+
all: [...e].sort((r, i) => i.createdAt - r.createdAt),
|
|
126
126
|
open: [],
|
|
127
127
|
completed: [],
|
|
128
128
|
cancelled: [],
|
|
@@ -143,28 +143,28 @@ const $e = /* @__PURE__ */ new Set([
|
|
|
143
143
|
n.expired.push(r);
|
|
144
144
|
break;
|
|
145
145
|
}
|
|
146
|
-
return
|
|
147
|
-
},
|
|
148
|
-
const n = new Set(e.map((
|
|
149
|
-
(
|
|
146
|
+
return he.set(e, n), n;
|
|
147
|
+
}, st = (e, t) => {
|
|
148
|
+
const n = new Set(e.map((i) => i.historyKey)), r = (t == null ? void 0 : t.filter(
|
|
149
|
+
(i) => i.version === 1 && !n.has(i.historyKey)
|
|
150
150
|
)) ?? [];
|
|
151
151
|
return [...e, ...r];
|
|
152
|
-
},
|
|
152
|
+
}, at = (e, t, n) => {
|
|
153
153
|
if (!e) return;
|
|
154
154
|
const r = new Map(
|
|
155
|
-
t.map((
|
|
156
|
-
),
|
|
157
|
-
for (const
|
|
158
|
-
if (
|
|
159
|
-
const s = r.get(
|
|
160
|
-
!s || s.progress ===
|
|
155
|
+
t.map((o) => [o.historyKey, o])
|
|
156
|
+
), i = [];
|
|
157
|
+
for (const o of e) {
|
|
158
|
+
if (o.version !== 2) continue;
|
|
159
|
+
const s = r.get(o.historyKey);
|
|
160
|
+
!s || s.progress === o.progress || (i.push(s), s.status === J.Completed && I(() => {
|
|
161
161
|
var a;
|
|
162
162
|
return (a = n == null ? void 0 : n.onOrderFilled) == null ? void 0 : a.call(n, s);
|
|
163
163
|
}));
|
|
164
164
|
}
|
|
165
|
-
|
|
166
|
-
var
|
|
167
|
-
return (
|
|
165
|
+
i.length > 0 && I(() => {
|
|
166
|
+
var o;
|
|
167
|
+
return (o = n == null ? void 0 : n.onOrdersProgressUpdate) == null ? void 0 : o.call(n, i);
|
|
168
168
|
});
|
|
169
169
|
}, Ie = (e) => {
|
|
170
170
|
if (e === null || typeof e != "object") return !1;
|
|
@@ -174,22 +174,41 @@ const $e = /* @__PURE__ */ new Set([
|
|
|
174
174
|
if (Object.is(e, t)) return e;
|
|
175
175
|
if (Array.isArray(e) && Array.isArray(t)) {
|
|
176
176
|
const n = t.map(
|
|
177
|
-
(
|
|
177
|
+
(i, o) => ae(e[o], i)
|
|
178
178
|
);
|
|
179
|
-
return e.length === n.length && n.every((
|
|
179
|
+
return e.length === n.length && n.every((i, o) => i === e[o]) ? e : n;
|
|
180
180
|
}
|
|
181
181
|
if (Ie(e) && Ie(t)) {
|
|
182
|
-
const n = Object.keys(e), r = Object.keys(t),
|
|
183
|
-
let
|
|
182
|
+
const n = Object.keys(e), r = Object.keys(t), i = {};
|
|
183
|
+
let o = n.length === r.length;
|
|
184
184
|
for (const s of r) {
|
|
185
|
-
Object.prototype.hasOwnProperty.call(e, s) || (
|
|
185
|
+
Object.prototype.hasOwnProperty.call(e, s) || (o = !1);
|
|
186
186
|
const a = ae(e[s], t[s]);
|
|
187
|
-
|
|
187
|
+
i[s] = a, a !== e[s] && (o = !1);
|
|
188
188
|
}
|
|
189
|
-
return
|
|
189
|
+
return o ? e : i;
|
|
190
190
|
}
|
|
191
191
|
return t;
|
|
192
|
-
},
|
|
192
|
+
}, ct = (e, t) => e ? ae(e, t) : t, dt = async ({
|
|
193
|
+
client: e,
|
|
194
|
+
account: t,
|
|
195
|
+
signal: n,
|
|
196
|
+
supportLegacyOrders: r,
|
|
197
|
+
previousOrders: i,
|
|
198
|
+
legacyLoaded: o,
|
|
199
|
+
callbacks: s
|
|
200
|
+
}) => {
|
|
201
|
+
const a = await e.getAccountOrdersResult({
|
|
202
|
+
signal: n,
|
|
203
|
+
account: t,
|
|
204
|
+
legacyOrders: r && !o
|
|
205
|
+
});
|
|
206
|
+
if (n.aborted) throw n.reason;
|
|
207
|
+
return at(i, a.orders, s), {
|
|
208
|
+
orders: r && !a.legacyLoaded ? st(a.orders, i) : a.orders,
|
|
209
|
+
legacyLoaded: o || a.legacyLoaded
|
|
210
|
+
};
|
|
211
|
+
}, ce = (e) => ({
|
|
193
212
|
tradeCount: e.tradeCount,
|
|
194
213
|
tradeInterval: e.tradeInterval,
|
|
195
214
|
orderDuration: e.orderDuration,
|
|
@@ -199,218 +218,220 @@ const $e = /* @__PURE__ */ new Set([
|
|
|
199
218
|
limitPricePercent: e.limitPricePercent,
|
|
200
219
|
isMarketOrder: e.isMarketOrder,
|
|
201
220
|
isPriceInverted: void 0
|
|
202
|
-
}),
|
|
221
|
+
}), ut = (e) => ({
|
|
203
222
|
...ce(e),
|
|
204
223
|
cancelOrders: {},
|
|
205
|
-
currentExecution:
|
|
206
|
-
}),
|
|
207
|
-
let t = 0, n, r,
|
|
224
|
+
currentExecution: te()
|
|
225
|
+
}), Se = { isFetching: !1 }, Oe = { isFetching: !1 }, lt = (e) => new Promise((t) => setTimeout(t, e)), mt = (e) => {
|
|
226
|
+
let t = 0, n, r, i = 0, o, s, a, c = !1, h = 0, p = 0, u, g, E;
|
|
208
227
|
return ze((m, S) => {
|
|
209
|
-
const
|
|
228
|
+
const y = async () => {
|
|
210
229
|
if (!n || !r) return;
|
|
211
|
-
if (
|
|
212
|
-
const
|
|
213
|
-
m((
|
|
230
|
+
if (o) return o;
|
|
231
|
+
const l = ++i, P = r;
|
|
232
|
+
m((f) => ({
|
|
214
233
|
client: {
|
|
215
234
|
key: n,
|
|
216
|
-
data:
|
|
235
|
+
data: f.client.data,
|
|
217
236
|
error: void 0,
|
|
218
237
|
isFetching: !0
|
|
219
238
|
}
|
|
220
239
|
}));
|
|
221
|
-
const
|
|
222
|
-
let
|
|
223
|
-
for (let
|
|
224
|
-
if (
|
|
240
|
+
const O = (async () => {
|
|
241
|
+
let f;
|
|
242
|
+
for (let B = 0; B < 3; B++) {
|
|
243
|
+
if (l !== i) return;
|
|
225
244
|
try {
|
|
226
|
-
const
|
|
227
|
-
return
|
|
228
|
-
client: { key: n, data:
|
|
229
|
-
}),
|
|
230
|
-
} catch (
|
|
231
|
-
if (
|
|
232
|
-
|
|
245
|
+
const w = await P();
|
|
246
|
+
return l !== i ? void 0 : (m({
|
|
247
|
+
client: { key: n, data: w, isFetching: !1 }
|
|
248
|
+
}), w);
|
|
249
|
+
} catch (w) {
|
|
250
|
+
if (f = w instanceof Error ? w : new Error(String(w)), l !== i) return;
|
|
251
|
+
B < 2 && await lt(2 ** B * 1e3);
|
|
233
252
|
}
|
|
234
253
|
}
|
|
235
|
-
|
|
236
|
-
client: { key: n, error:
|
|
254
|
+
l === i && m({
|
|
255
|
+
client: { key: n, error: f, isFetching: !1 }
|
|
237
256
|
});
|
|
238
257
|
})();
|
|
239
|
-
return
|
|
240
|
-
|
|
241
|
-
}),
|
|
242
|
-
}, T = async (
|
|
243
|
-
if (!
|
|
258
|
+
return o = O, O.finally(() => {
|
|
259
|
+
o === O && (o = void 0);
|
|
260
|
+
}), O;
|
|
261
|
+
}, T = async (l = !1, P = !1) => {
|
|
262
|
+
if (!l && h === 0 || !s || !a)
|
|
244
263
|
return S().orders.data;
|
|
245
264
|
if (u) {
|
|
246
265
|
if (!P) return u;
|
|
247
|
-
const
|
|
248
|
-
return await u, s !==
|
|
266
|
+
const C = s;
|
|
267
|
+
return await u, s !== C ? void 0 : T(l, P);
|
|
249
268
|
}
|
|
250
|
-
const
|
|
251
|
-
|
|
269
|
+
const O = ++p, f = a, B = S().orders.data, w = new AbortController();
|
|
270
|
+
g = w, m((C) => ({
|
|
252
271
|
orders: {
|
|
253
272
|
key: s,
|
|
254
|
-
data:
|
|
273
|
+
data: C.orders.data,
|
|
255
274
|
error: void 0,
|
|
256
275
|
isFetching: !0
|
|
257
276
|
}
|
|
258
277
|
}));
|
|
259
|
-
const
|
|
260
|
-
|
|
278
|
+
const F = f(
|
|
279
|
+
B,
|
|
261
280
|
P ? !1 : c,
|
|
262
|
-
|
|
263
|
-
).then(({ orders:
|
|
264
|
-
if (
|
|
265
|
-
c =
|
|
266
|
-
const
|
|
281
|
+
w.signal
|
|
282
|
+
).then(({ orders: C, legacyLoaded: D }) => {
|
|
283
|
+
if (O !== p) return;
|
|
284
|
+
c = D;
|
|
285
|
+
const G = ct(
|
|
267
286
|
S().orders.data,
|
|
268
|
-
|
|
287
|
+
C
|
|
269
288
|
);
|
|
270
289
|
return m({
|
|
271
290
|
orders: {
|
|
272
291
|
key: s,
|
|
273
|
-
data:
|
|
292
|
+
data: G,
|
|
274
293
|
isFetching: !1
|
|
275
294
|
}
|
|
276
|
-
}),
|
|
277
|
-
}).catch((
|
|
278
|
-
if (
|
|
295
|
+
}), G;
|
|
296
|
+
}).catch((C) => {
|
|
297
|
+
if (O !== p || w.signal.aborted)
|
|
279
298
|
return;
|
|
280
|
-
const
|
|
281
|
-
m((
|
|
299
|
+
const D = C instanceof Error ? C : new Error(String(C));
|
|
300
|
+
m((G) => ({
|
|
282
301
|
orders: {
|
|
283
302
|
key: s,
|
|
284
|
-
data:
|
|
285
|
-
error:
|
|
303
|
+
data: G.orders.data,
|
|
304
|
+
error: D,
|
|
286
305
|
isFetching: !1
|
|
287
306
|
}
|
|
288
307
|
}));
|
|
289
308
|
});
|
|
290
|
-
return u =
|
|
291
|
-
u ===
|
|
292
|
-
}),
|
|
293
|
-
},
|
|
309
|
+
return u = F, F.finally(() => {
|
|
310
|
+
u === F && (u = void 0), g === w && (g = void 0);
|
|
311
|
+
}), F;
|
|
312
|
+
}, L = () => {
|
|
294
313
|
T();
|
|
295
|
-
},
|
|
296
|
-
|
|
297
|
-
orders: { ...
|
|
314
|
+
}, K = () => {
|
|
315
|
+
E && (clearInterval(E), E = void 0), typeof window < "u" && window.removeEventListener("focus", L), g == null || g.abort(), g = void 0, u = void 0, p++, m((l) => ({
|
|
316
|
+
orders: { ...l.orders, isFetching: !1 }
|
|
298
317
|
}));
|
|
299
|
-
},
|
|
300
|
-
!s || !a ||
|
|
318
|
+
}, M = () => {
|
|
319
|
+
!s || !a || E || (T(!0), E = setInterval(() => {
|
|
301
320
|
T();
|
|
302
|
-
},
|
|
321
|
+
}, ot), typeof window < "u" && window.addEventListener("focus", L));
|
|
303
322
|
};
|
|
304
323
|
return {
|
|
305
|
-
client:
|
|
306
|
-
orders:
|
|
307
|
-
state:
|
|
308
|
-
configureClient: (
|
|
309
|
-
if (n ===
|
|
324
|
+
client: Se,
|
|
325
|
+
orders: Oe,
|
|
326
|
+
state: ut(e),
|
|
327
|
+
configureClient: (l, P) => {
|
|
328
|
+
if (n === l) {
|
|
310
329
|
r = P;
|
|
311
330
|
return;
|
|
312
331
|
}
|
|
313
|
-
n =
|
|
314
|
-
client:
|
|
315
|
-
}),
|
|
332
|
+
n = l, r = P, i++, o = void 0, m({
|
|
333
|
+
client: l ? { key: l, isFetching: !1 } : Se
|
|
334
|
+
}), l && P && y();
|
|
316
335
|
},
|
|
317
|
-
refetchClient:
|
|
318
|
-
configureOrders: (
|
|
319
|
-
if (s ===
|
|
336
|
+
refetchClient: y,
|
|
337
|
+
configureOrders: (l, P) => {
|
|
338
|
+
if (s === l) {
|
|
320
339
|
a = P;
|
|
321
340
|
return;
|
|
322
341
|
}
|
|
323
|
-
|
|
324
|
-
orders:
|
|
325
|
-
}),
|
|
342
|
+
K(), s = l, a = P, c = !1, m({
|
|
343
|
+
orders: l ? { key: l, isFetching: !1 } : Oe
|
|
344
|
+
}), h > 0 && M();
|
|
326
345
|
},
|
|
327
|
-
registerOrdersConsumer: () => (
|
|
328
|
-
|
|
346
|
+
registerOrdersConsumer: () => (h++, h === 1 && M(), () => {
|
|
347
|
+
h = Math.max(0, h - 1), h === 0 && K();
|
|
329
348
|
}),
|
|
330
349
|
refetchOrders: T,
|
|
331
|
-
addOrder: (
|
|
350
|
+
addOrder: (l) => {
|
|
332
351
|
m((P) => {
|
|
333
|
-
const
|
|
334
|
-
return
|
|
335
|
-
(
|
|
352
|
+
const O = P.orders.data;
|
|
353
|
+
return O != null && O.some(
|
|
354
|
+
(f) => f.historyKey === l.historyKey
|
|
336
355
|
) ? P : {
|
|
337
356
|
orders: {
|
|
338
357
|
...P.orders,
|
|
339
|
-
data: [
|
|
358
|
+
data: [l, ...O ?? []]
|
|
340
359
|
}
|
|
341
360
|
};
|
|
342
361
|
});
|
|
343
362
|
},
|
|
344
|
-
|
|
345
|
-
m((
|
|
346
|
-
|
|
347
|
-
|
|
348
|
-
|
|
349
|
-
|
|
350
|
-
|
|
351
|
-
|
|
352
|
-
|
|
353
|
-
|
|
354
|
-
|
|
363
|
+
setCancelOrder: (l, P) => {
|
|
364
|
+
m((O) => ({
|
|
365
|
+
state: {
|
|
366
|
+
...O.state,
|
|
367
|
+
cancelOrders: { ...O.state.cancelOrders, [l]: P }
|
|
368
|
+
}
|
|
369
|
+
}));
|
|
370
|
+
},
|
|
371
|
+
clearCancelOrder: (l) => {
|
|
372
|
+
m((P) => {
|
|
373
|
+
if (!(l in P.state.cancelOrders)) return P;
|
|
374
|
+
const O = { ...P.state.cancelOrders };
|
|
375
|
+
return delete O[l], { state: { ...P.state, cancelOrders: O } };
|
|
355
376
|
});
|
|
356
377
|
},
|
|
357
|
-
updateState: (
|
|
358
|
-
beginExecution: (
|
|
378
|
+
updateState: (l) => m((P) => ({ state: { ...P.state, ...l } })),
|
|
379
|
+
beginExecution: (l) => {
|
|
359
380
|
let P;
|
|
360
|
-
return m((
|
|
361
|
-
...
|
|
381
|
+
return m((O) => be(O.state.currentExecution.phase) ? (P = {
|
|
382
|
+
...l,
|
|
362
383
|
executionId: ++t,
|
|
363
384
|
phase: d.PREPARING
|
|
364
385
|
}, {
|
|
365
386
|
state: {
|
|
366
|
-
...
|
|
387
|
+
...O.state,
|
|
367
388
|
currentExecution: P
|
|
368
389
|
}
|
|
369
|
-
}) :
|
|
390
|
+
}) : O), P;
|
|
370
391
|
},
|
|
371
|
-
replaceExecution: (
|
|
372
|
-
let
|
|
373
|
-
return m((
|
|
374
|
-
const
|
|
375
|
-
return
|
|
376
|
-
state: { ...
|
|
392
|
+
replaceExecution: (l, P) => {
|
|
393
|
+
let O = !1;
|
|
394
|
+
return m((f) => {
|
|
395
|
+
const B = f.state.currentExecution;
|
|
396
|
+
return B.executionId !== l || P.executionId !== l || !ke(B.phase, P.phase) ? f : (O = !0, {
|
|
397
|
+
state: { ...f.state, currentExecution: P }
|
|
377
398
|
});
|
|
378
|
-
}),
|
|
399
|
+
}), O;
|
|
379
400
|
},
|
|
380
401
|
returnToOrderForm: () => {
|
|
381
|
-
const
|
|
382
|
-
return
|
|
402
|
+
const l = S().state.currentExecution;
|
|
403
|
+
return $(l.phase) || l.phase === d.SUCCESS ? !1 : (m((P) => ({
|
|
383
404
|
state: {
|
|
384
405
|
...P.state,
|
|
385
|
-
currentExecution:
|
|
406
|
+
currentExecution: te(l.completedWrap)
|
|
386
407
|
}
|
|
387
408
|
})), !0);
|
|
388
409
|
},
|
|
389
|
-
syncFormDefaults: (
|
|
410
|
+
syncFormDefaults: (l) => $(S().state.currentExecution.phase) ? !1 : (m((P) => ({
|
|
390
411
|
state: {
|
|
391
412
|
...P.state,
|
|
392
|
-
...ce(
|
|
393
|
-
currentExecution:
|
|
413
|
+
...ce(l),
|
|
414
|
+
currentExecution: te()
|
|
394
415
|
}
|
|
395
416
|
})), !0),
|
|
396
|
-
startNewOrder: (
|
|
417
|
+
startNewOrder: (l) => {
|
|
397
418
|
const { state: P } = S();
|
|
398
|
-
return
|
|
419
|
+
return $(P.currentExecution.phase) ? !1 : (m((O) => ({
|
|
399
420
|
state: {
|
|
400
|
-
...
|
|
401
|
-
...ce(
|
|
421
|
+
...O.state,
|
|
422
|
+
...ce(l),
|
|
402
423
|
isMarketOrder: P.isMarketOrder,
|
|
403
|
-
currentExecution:
|
|
424
|
+
currentExecution: te()
|
|
404
425
|
}
|
|
405
426
|
})), !0);
|
|
406
427
|
}
|
|
407
428
|
};
|
|
408
429
|
});
|
|
409
|
-
},
|
|
430
|
+
}, ye = (e) => {
|
|
410
431
|
var n;
|
|
411
432
|
const t = (n = e.overrides) == null ? void 0 : n.state;
|
|
412
433
|
return {
|
|
413
|
-
isMarketOrder: e.module ===
|
|
434
|
+
isMarketOrder: e.module === X.LIMIT ? !1 : t == null ? void 0 : t.isMarketOrder,
|
|
414
435
|
tradeCount: t == null ? void 0 : t.tradeCount,
|
|
415
436
|
tradeInterval: t == null ? void 0 : t.tradeInterval,
|
|
416
437
|
orderDuration: t == null ? void 0 : t.orderDuration,
|
|
@@ -419,49 +440,110 @@ const $e = /* @__PURE__ */ new Set([
|
|
|
419
440
|
triggerPricePercent: t == null ? void 0 : t.triggerPricePercent,
|
|
420
441
|
limitPricePercent: t == null ? void 0 : t.limitPricePercent
|
|
421
442
|
};
|
|
422
|
-
},
|
|
443
|
+
}, Re = le(null), gt = ({
|
|
423
444
|
children: e,
|
|
424
445
|
initialState: t
|
|
425
446
|
}) => {
|
|
426
|
-
const [n] =
|
|
427
|
-
return /* @__PURE__ */
|
|
428
|
-
},
|
|
429
|
-
const e = me(
|
|
447
|
+
const [n] = Ve(() => mt(t));
|
|
448
|
+
return /* @__PURE__ */ U(Re.Provider, { value: n, children: e });
|
|
449
|
+
}, V = () => {
|
|
450
|
+
const e = me(Re);
|
|
430
451
|
if (e === null)
|
|
431
452
|
throw new Error("useSpotStore must be used within SpotProvider");
|
|
432
453
|
return e;
|
|
433
|
-
},
|
|
434
|
-
const t =
|
|
435
|
-
return
|
|
436
|
-
},
|
|
437
|
-
const { partner: e, chainId: t,
|
|
454
|
+
}, A = (e) => {
|
|
455
|
+
const t = V();
|
|
456
|
+
return Je(t, e);
|
|
457
|
+
}, Pt = { isFetching: !1 }, ft = () => {
|
|
458
|
+
const { partner: e, chainId: t, hasChainId: n } = x(), r = V(), i = !!(t && n), o = i ? `${e}:${t}` : void 0, s = v(() => t ? Ue(e, t) : Promise.reject(
|
|
438
459
|
new Error("Spot is unavailable on the connected chain")
|
|
439
460
|
), [t, e]);
|
|
440
|
-
|
|
441
|
-
r.getState().configureClient(
|
|
442
|
-
}, [i,
|
|
443
|
-
|
|
444
|
-
|
|
445
|
-
|
|
446
|
-
|
|
447
|
-
|
|
448
|
-
|
|
461
|
+
ie(() => {
|
|
462
|
+
r.getState().configureClient(o, i ? s : void 0);
|
|
463
|
+
}, [i, o, s, r]);
|
|
464
|
+
}, Y = () => {
|
|
465
|
+
const { partner: e, chainId: t, hasChainId: n } = x(), r = V(), i = A((h) => h.client), o = !!(t && n), s = o ? `${e}:${t}` : void 0, a = i.key === s ? i : Pt, c = v(() => {
|
|
466
|
+
if (!o || !s) return Promise.resolve(void 0);
|
|
467
|
+
const h = r.getState();
|
|
468
|
+
return h.client.key !== s ? Promise.resolve(void 0) : h.refetchClient();
|
|
469
|
+
}, [o, s, r]);
|
|
470
|
+
return R(
|
|
449
471
|
() => ({
|
|
450
472
|
data: a.data,
|
|
451
473
|
error: a.error,
|
|
452
|
-
isLoading:
|
|
474
|
+
isLoading: o && !a.data && a.error === void 0,
|
|
453
475
|
isFetching: a.isFetching,
|
|
454
|
-
refetch:
|
|
476
|
+
refetch: c
|
|
477
|
+
}),
|
|
478
|
+
[a, o, c]
|
|
479
|
+
);
|
|
480
|
+
}, ht = { isFetching: !1 }, Te = (e, t, n) => e && t ? JSON.stringify([
|
|
481
|
+
e,
|
|
482
|
+
t.exchangeAddress,
|
|
483
|
+
t.partner,
|
|
484
|
+
t.chainId,
|
|
485
|
+
n
|
|
486
|
+
]) : void 0, Et = () => {
|
|
487
|
+
const { account: e, supportLegacyOrders: t, callbacks: n } = x(), { data: r } = Y(), i = V(), o = Te(e, r, t), s = !!o, a = v(
|
|
488
|
+
async (c, h, p) => !e || !r ? { orders: [], legacyLoaded: !1 } : dt({
|
|
489
|
+
client: r,
|
|
490
|
+
account: e,
|
|
491
|
+
signal: p,
|
|
492
|
+
supportLegacyOrders: t,
|
|
493
|
+
previousOrders: c,
|
|
494
|
+
legacyLoaded: h,
|
|
495
|
+
callbacks: n
|
|
496
|
+
}),
|
|
497
|
+
[e, n, r, t]
|
|
498
|
+
);
|
|
499
|
+
ie(() => {
|
|
500
|
+
i.getState().configureOrders(o, s ? a : void 0);
|
|
501
|
+
}, [s, o, a, i]);
|
|
502
|
+
}, Ne = () => {
|
|
503
|
+
const { account: e, supportLegacyOrders: t } = x(), { data: n } = Y(), r = V(), i = Te(e, n, t), o = !!i, s = v((a = !1) => !o || !i || r.getState().orders.key !== i ? Promise.resolve(void 0) : r.getState().refetchOrders(!0, a), [o, i, r]);
|
|
504
|
+
return { enabled: o, key: i, refetch: s };
|
|
505
|
+
}, It = () => {
|
|
506
|
+
const e = V();
|
|
507
|
+
return v(
|
|
508
|
+
(t) => e.getState().addOrder(t),
|
|
509
|
+
[e]
|
|
510
|
+
);
|
|
511
|
+
}, St = () => {
|
|
512
|
+
const e = V();
|
|
513
|
+
return v(
|
|
514
|
+
() => e.getState().refetchOrders(),
|
|
515
|
+
[e]
|
|
516
|
+
);
|
|
517
|
+
}, zt = () => {
|
|
518
|
+
const e = A((c) => c.orders), t = A(
|
|
519
|
+
(c) => c.registerOrdersConsumer
|
|
520
|
+
), { enabled: n, key: r, refetch: i } = Ne(), o = e.key === r ? e : ht;
|
|
521
|
+
ie(() => t(), [t]);
|
|
522
|
+
const s = R(
|
|
523
|
+
() => o.data === void 0 ? void 0 : Ee(o.data),
|
|
524
|
+
[o.data]
|
|
525
|
+
), a = v(async () => {
|
|
526
|
+
const c = await i();
|
|
527
|
+
return c === void 0 ? void 0 : Ee(c);
|
|
528
|
+
}, [i]);
|
|
529
|
+
return R(
|
|
530
|
+
() => ({
|
|
531
|
+
data: s,
|
|
532
|
+
error: o.error,
|
|
533
|
+
isLoading: n && s === void 0 && o.error === void 0,
|
|
534
|
+
isFetching: o.isFetching,
|
|
535
|
+
isRefetching: o.isFetching && s !== void 0,
|
|
536
|
+
refetch: a
|
|
455
537
|
}),
|
|
456
|
-
[
|
|
538
|
+
[o, s, n, a]
|
|
457
539
|
);
|
|
458
|
-
},
|
|
540
|
+
}, Ot = ({ children: e }) => (ft(), Et(), e), pt = ({
|
|
459
541
|
error: e,
|
|
460
542
|
retry: t,
|
|
461
543
|
isRetrying: n
|
|
462
544
|
}) => /* @__PURE__ */ ue("div", { className: "spot-client-error-fallback", role: "alert", children: [
|
|
463
|
-
/* @__PURE__ */
|
|
464
|
-
/* @__PURE__ */
|
|
545
|
+
/* @__PURE__ */ U("p", { children: e.message || "Unable to load Spot configuration." }),
|
|
546
|
+
/* @__PURE__ */ U(
|
|
465
547
|
"button",
|
|
466
548
|
{
|
|
467
549
|
type: "button",
|
|
@@ -471,41 +553,40 @@ const $e = /* @__PURE__ */ new Set([
|
|
|
471
553
|
children: n ? "Retrying…" : "Retry"
|
|
472
554
|
}
|
|
473
555
|
)
|
|
474
|
-
] }),
|
|
556
|
+
] }), At = ({
|
|
475
557
|
children: e,
|
|
476
|
-
fallback: t =
|
|
558
|
+
fallback: t = pt
|
|
477
559
|
}) => {
|
|
478
|
-
const {
|
|
479
|
-
await
|
|
480
|
-
}, [
|
|
481
|
-
return
|
|
482
|
-
!s || !r || !o || U.onFetchedConfig(
|
|
483
|
-
s.rePermitData,
|
|
484
|
-
n,
|
|
485
|
-
ve(n, r),
|
|
486
|
-
i
|
|
487
|
-
);
|
|
488
|
-
}, [r, s, o, i, n]), /* @__PURE__ */ ue(We, { children: [
|
|
560
|
+
const { hasChainId: n } = x(), { data: r, error: i, isFetching: o, refetch: s } = Y(), a = v(async () => {
|
|
561
|
+
await s();
|
|
562
|
+
}, [s]);
|
|
563
|
+
return /* @__PURE__ */ ue(Ke, { children: [
|
|
489
564
|
e,
|
|
490
|
-
!
|
|
565
|
+
!r && i && n ? /* @__PURE__ */ U(
|
|
491
566
|
t,
|
|
492
567
|
{
|
|
493
|
-
error:
|
|
494
|
-
retry:
|
|
495
|
-
isRetrying:
|
|
568
|
+
error: i,
|
|
569
|
+
retry: a,
|
|
570
|
+
isRetrying: o
|
|
496
571
|
}
|
|
497
572
|
) : null
|
|
498
573
|
] });
|
|
499
|
-
},
|
|
574
|
+
}, vt = ({
|
|
500
575
|
resetErrorBoundary: e
|
|
501
576
|
}) => /* @__PURE__ */ ue("div", { className: "twap-error-fallback", role: "alert", children: [
|
|
502
|
-
/* @__PURE__ */
|
|
503
|
-
/* @__PURE__ */
|
|
504
|
-
] }),
|
|
577
|
+
/* @__PURE__ */ U("p", { children: "Something went wrong" }),
|
|
578
|
+
/* @__PURE__ */ U("button", { type: "button", onClick: e, children: "Retry" })
|
|
579
|
+
] }), wt = ({
|
|
505
580
|
children: e,
|
|
506
|
-
fallback: t =
|
|
507
|
-
}) =>
|
|
508
|
-
|
|
581
|
+
fallback: t = vt
|
|
582
|
+
}) => {
|
|
583
|
+
const n = V(), r = v((i) => {
|
|
584
|
+
var s;
|
|
585
|
+
(((s = n.getState().client.data) == null ? void 0 : s.analytics) ?? De).onCrash(i);
|
|
586
|
+
}, [n]);
|
|
587
|
+
return /* @__PURE__ */ U(Ct, { fallback: t, reportCrash: r, children: e });
|
|
588
|
+
};
|
|
589
|
+
class Ct extends He {
|
|
509
590
|
constructor() {
|
|
510
591
|
super(...arguments);
|
|
511
592
|
oe(this, "state", {});
|
|
@@ -517,13 +598,13 @@ class St extends Ve {
|
|
|
517
598
|
return { error: n };
|
|
518
599
|
}
|
|
519
600
|
componentDidCatch(n) {
|
|
520
|
-
|
|
601
|
+
this.props.reportCrash(n);
|
|
521
602
|
}
|
|
522
603
|
render() {
|
|
523
604
|
const { error: n } = this.state;
|
|
524
605
|
if (n) {
|
|
525
606
|
const r = this.props.fallback;
|
|
526
|
-
return /* @__PURE__ */
|
|
607
|
+
return /* @__PURE__ */ U(
|
|
527
608
|
r,
|
|
528
609
|
{
|
|
529
610
|
error: n,
|
|
@@ -534,153 +615,136 @@ class St extends Ve {
|
|
|
534
615
|
return this.props.children;
|
|
535
616
|
}
|
|
536
617
|
}
|
|
537
|
-
const
|
|
618
|
+
const yt = ({
|
|
538
619
|
children: e,
|
|
539
620
|
defaults: t,
|
|
540
621
|
scopeKey: n
|
|
541
622
|
}) => {
|
|
542
|
-
const r =
|
|
623
|
+
const r = V(), i = A(
|
|
543
624
|
(s) => s.state.currentExecution.phase
|
|
544
|
-
),
|
|
545
|
-
return
|
|
546
|
-
|
|
547
|
-
}, [t,
|
|
548
|
-
}, Le = le(null),
|
|
625
|
+
), o = je(n);
|
|
626
|
+
return ie(() => {
|
|
627
|
+
o.current === n || $(i) || r.getState().syncFormDefaults(t) && (o.current = n);
|
|
628
|
+
}, [t, i, n, r]), e;
|
|
629
|
+
}, Le = le(null), Rt = ({ children: e }) => {
|
|
549
630
|
const {
|
|
550
631
|
inputToken: t,
|
|
551
632
|
outputToken: n,
|
|
552
633
|
inputAmountUi: r,
|
|
553
|
-
quotedOutputAmountRaw:
|
|
554
|
-
inputTokenUsdPrice:
|
|
634
|
+
quotedOutputAmountRaw: i,
|
|
635
|
+
inputTokenUsdPrice: o,
|
|
555
636
|
outputTokenUsdPrice: s,
|
|
556
637
|
minTradeSizeUsd: a,
|
|
557
638
|
inputBalanceRaw: c,
|
|
558
|
-
displayFeePercent:
|
|
559
|
-
priceProtectionPercent:
|
|
639
|
+
displayFeePercent: h,
|
|
640
|
+
priceProtectionPercent: p,
|
|
560
641
|
module: u
|
|
561
|
-
} = x(),
|
|
562
|
-
(
|
|
563
|
-
),
|
|
564
|
-
(
|
|
565
|
-
), T =
|
|
566
|
-
(
|
|
567
|
-
),
|
|
568
|
-
(
|
|
569
|
-
),
|
|
570
|
-
(
|
|
571
|
-
),
|
|
572
|
-
const
|
|
573
|
-
return
|
|
574
|
-
}), P =
|
|
642
|
+
} = x(), g = A((f) => f.state.tradeCount), E = A((f) => f.state.tradeInterval), m = A((f) => f.state.orderDuration), S = A(
|
|
643
|
+
(f) => f.state.limitPriceUi
|
|
644
|
+
), y = A(
|
|
645
|
+
(f) => f.state.triggerPriceUi
|
|
646
|
+
), T = A(
|
|
647
|
+
(f) => f.state.limitPricePercent
|
|
648
|
+
), L = A(
|
|
649
|
+
(f) => f.state.triggerPricePercent
|
|
650
|
+
), K = A(
|
|
651
|
+
(f) => f.state.isPriceInverted
|
|
652
|
+
), M = A((f) => f.state.isMarketOrder), l = A((f) => {
|
|
653
|
+
const B = f.state.currentExecution;
|
|
654
|
+
return B.phase !== d.IDLE ? B.form : void 0;
|
|
655
|
+
}), P = R(
|
|
575
656
|
() => ({
|
|
576
657
|
module: u,
|
|
577
658
|
inputTokenDecimals: (t == null ? void 0 : t.decimals) ?? 0,
|
|
578
659
|
outputTokenDecimals: (n == null ? void 0 : n.decimals) ?? 0,
|
|
579
|
-
quotedOutputAmountRaw:
|
|
580
|
-
inputTokenUsdPrice:
|
|
660
|
+
quotedOutputAmountRaw: i,
|
|
661
|
+
inputTokenUsdPrice: o,
|
|
581
662
|
outputTokenUsdPrice: s,
|
|
582
663
|
minTradeSizeUsd: a,
|
|
583
|
-
priceProtectionPercent:
|
|
584
|
-
displayFeePercent:
|
|
664
|
+
priceProtectionPercent: p,
|
|
665
|
+
displayFeePercent: h,
|
|
585
666
|
inputBalanceRaw: c,
|
|
586
667
|
userInput: {
|
|
587
668
|
inputAmountUi: r,
|
|
588
|
-
isMarketOrder: !!
|
|
589
|
-
tradeCount:
|
|
590
|
-
tradeInterval:
|
|
669
|
+
isMarketOrder: !!M,
|
|
670
|
+
tradeCount: g,
|
|
671
|
+
tradeInterval: E,
|
|
591
672
|
orderDuration: m,
|
|
592
673
|
limitPriceUi: S,
|
|
593
674
|
limitPricePercent: T,
|
|
594
|
-
triggerPriceUi:
|
|
595
|
-
triggerPricePercent:
|
|
596
|
-
isPriceInverted:
|
|
675
|
+
triggerPriceUi: y,
|
|
676
|
+
triggerPricePercent: L,
|
|
677
|
+
isPriceInverted: K
|
|
597
678
|
}
|
|
598
679
|
}),
|
|
599
680
|
[
|
|
600
681
|
n == null ? void 0 : n.decimals,
|
|
601
682
|
s,
|
|
602
|
-
|
|
603
|
-
|
|
683
|
+
h,
|
|
684
|
+
i,
|
|
604
685
|
a,
|
|
605
686
|
u,
|
|
606
|
-
|
|
687
|
+
p,
|
|
607
688
|
c,
|
|
608
689
|
t == null ? void 0 : t.decimals,
|
|
609
|
-
|
|
690
|
+
o,
|
|
691
|
+
K,
|
|
610
692
|
M,
|
|
611
|
-
_,
|
|
612
693
|
T,
|
|
613
|
-
|
|
614
|
-
|
|
694
|
+
L,
|
|
695
|
+
g,
|
|
615
696
|
m,
|
|
616
|
-
|
|
697
|
+
E,
|
|
617
698
|
S,
|
|
618
699
|
r,
|
|
619
|
-
|
|
700
|
+
y
|
|
620
701
|
]
|
|
621
|
-
),
|
|
622
|
-
|
|
623
|
-
|
|
624
|
-
|
|
702
|
+
), O = R(() => {
|
|
703
|
+
if (l) return l;
|
|
704
|
+
const f = Ge(P);
|
|
705
|
+
return t && n ? f : {
|
|
706
|
+
...f,
|
|
625
707
|
isReady: !1,
|
|
626
708
|
canSubmit: !1
|
|
627
709
|
};
|
|
628
|
-
}, [t, n, P]);
|
|
629
|
-
return /* @__PURE__ */
|
|
710
|
+
}, [l, t, n, P]);
|
|
711
|
+
return /* @__PURE__ */ U(Le.Provider, { value: O, children: e });
|
|
630
712
|
}, W = () => {
|
|
631
713
|
const e = me(Le);
|
|
632
714
|
if (!e)
|
|
633
715
|
throw new Error("useOrderForm must be used within OrderFormProvider");
|
|
634
716
|
return e;
|
|
635
|
-
},
|
|
636
|
-
|
|
637
|
-
|
|
638
|
-
|
|
639
|
-
e.minTradeSizeUsd,
|
|
640
|
-
e.chainId,
|
|
641
|
-
e.appId
|
|
642
|
-
);
|
|
643
|
-
}, [
|
|
644
|
-
e.appId,
|
|
645
|
-
e.chainId,
|
|
646
|
-
e.minTradeSizeUsd,
|
|
647
|
-
e.partner,
|
|
648
|
-
t
|
|
649
|
-
]);
|
|
650
|
-
}, pt = (e) => {
|
|
651
|
-
var u, l, h, m, S, R, T, K, M, _, g, P;
|
|
652
|
-
const t = C(
|
|
653
|
-
() => Ge(e.partner),
|
|
654
|
-
[e.partner]
|
|
655
|
-
), n = !!(e.chainId && t.includes(e.chainId)), r = (u = e.wrappedNativeToken) == null ? void 0 : u.address, o = !!(r && ($((l = e.inputToken) == null ? void 0 : l.address) && fe(((h = e.outputToken) == null ? void 0 : h.address) || "", r) || fe(((m = e.inputToken) == null ? void 0 : m.address) || "", r) && $((S = e.outputToken) == null ? void 0 : S.address))), i = o ? ee(e.inputAmountUi, (R = e.outputToken) == null ? void 0 : R.decimals) : e.marketQuote.isLoading ? void 0 : e.marketQuote.quotedOutputAmountRaw, s = o ? !1 : e.marketQuote.isLoading, a = o ? !1 : e.marketQuote.noLiquidity, c = C(
|
|
656
|
-
() => Te({
|
|
717
|
+
}, Tt = (e) => {
|
|
718
|
+
var p, u, g, E, m, S, y, T, L, K, M, l;
|
|
719
|
+
const t = Number.isSafeInteger(e.chainId) && Number(e.chainId) > 0, n = (p = e.wrappedNativeToken) == null ? void 0 : p.address, r = !!(n && (Q((u = e.inputToken) == null ? void 0 : u.address) && Pe(((g = e.outputToken) == null ? void 0 : g.address) || "", n) || Pe(((E = e.inputToken) == null ? void 0 : E.address) || "", n) && Q((m = e.outputToken) == null ? void 0 : m.address))), i = r ? k(e.inputAmountUi, (S = e.outputToken) == null ? void 0 : S.decimals) : e.marketQuote.isLoading ? void 0 : e.marketQuote.quotedOutputAmountRaw, o = r ? !1 : e.marketQuote.isLoading, s = r ? !1 : e.marketQuote.noLiquidity, a = R(
|
|
720
|
+
() => ye({
|
|
657
721
|
module: e.module,
|
|
658
722
|
overrides: e.overrides
|
|
659
723
|
}),
|
|
660
724
|
[e.module, e.overrides]
|
|
661
|
-
),
|
|
725
|
+
), c = JSON.stringify([
|
|
662
726
|
e.partner,
|
|
663
727
|
e.chainId,
|
|
664
728
|
e.module,
|
|
665
|
-
(
|
|
666
|
-
(
|
|
667
|
-
(
|
|
668
|
-
(
|
|
669
|
-
(
|
|
670
|
-
(
|
|
671
|
-
|
|
672
|
-
]),
|
|
729
|
+
(y = e.inputToken) == null ? void 0 : y.address,
|
|
730
|
+
(T = e.inputToken) == null ? void 0 : T.decimals,
|
|
731
|
+
(L = e.outputToken) == null ? void 0 : L.address,
|
|
732
|
+
(K = e.outputToken) == null ? void 0 : K.decimals,
|
|
733
|
+
(M = e.wrappedNativeToken) == null ? void 0 : M.address,
|
|
734
|
+
(l = e.wrappedNativeToken) == null ? void 0 : l.decimals,
|
|
735
|
+
a
|
|
736
|
+
]), h = R(
|
|
673
737
|
() => ({
|
|
674
738
|
inputAmountUi: e.inputAmountUi,
|
|
675
739
|
minTradeSizeUsd: e.minTradeSizeUsd,
|
|
676
740
|
account: e.account,
|
|
677
741
|
walletInteractions: e.walletInteractions,
|
|
678
742
|
quotedOutputAmountRaw: i,
|
|
679
|
-
marketPriceLoading:
|
|
680
|
-
noLiquidity:
|
|
743
|
+
marketPriceLoading: o,
|
|
744
|
+
noLiquidity: s,
|
|
681
745
|
priceProtectionPercent: e.priceProtectionPercent,
|
|
682
746
|
chainId: e.chainId,
|
|
683
|
-
|
|
747
|
+
hasChainId: t,
|
|
684
748
|
partner: e.partner,
|
|
685
749
|
module: e.module,
|
|
686
750
|
displayFeePercent: e.displayFeePercent ?? 0,
|
|
@@ -713,103 +777,35 @@ const Et = ({
|
|
|
713
777
|
e.supportLegacyOrders,
|
|
714
778
|
e.inputAmountUi,
|
|
715
779
|
e.walletInteractions,
|
|
716
|
-
|
|
780
|
+
t,
|
|
781
|
+
o,
|
|
717
782
|
s,
|
|
718
|
-
a,
|
|
719
783
|
i
|
|
720
784
|
]
|
|
721
785
|
);
|
|
722
|
-
return { initialState:
|
|
723
|
-
},
|
|
724
|
-
const { initialState: t, formScopeKey: n,
|
|
725
|
-
return
|
|
726
|
-
|
|
786
|
+
return { initialState: a, formScopeKey: c, trading: h };
|
|
787
|
+
}, $t = (e) => {
|
|
788
|
+
const { initialState: t, formScopeKey: n, trading: r } = Tt(e);
|
|
789
|
+
return /* @__PURE__ */ U(Ye, { value: r, children: /* @__PURE__ */ U(gt, { initialState: t, children: /* @__PURE__ */ U(wt, { fallback: e.errorFallback, children: /* @__PURE__ */ U(Ot, { children: /* @__PURE__ */ U(
|
|
790
|
+
yt,
|
|
727
791
|
{
|
|
728
792
|
defaults: t,
|
|
729
793
|
scopeKey: n,
|
|
730
|
-
children: /* @__PURE__ */
|
|
794
|
+
children: /* @__PURE__ */ U(At, { fallback: e.clientErrorFallback, children: /* @__PURE__ */ U(Rt, { children: e.children }) })
|
|
731
795
|
}
|
|
732
|
-
) }) }) });
|
|
733
|
-
},
|
|
734
|
-
const {
|
|
735
|
-
e,
|
|
736
|
-
i == null ? void 0 : i.exchangeAddress,
|
|
737
|
-
t,
|
|
738
|
-
n,
|
|
739
|
-
r
|
|
740
|
-
]) : void 0, f = v(
|
|
741
|
-
async (u, l, h) => {
|
|
742
|
-
if (!e || !i)
|
|
743
|
-
return { orders: [], legacyLoaded: !1 };
|
|
744
|
-
const m = r && !l, S = await i.getAccountOrders({
|
|
745
|
-
signal: h,
|
|
746
|
-
account: e,
|
|
747
|
-
legacyOrders: m
|
|
748
|
-
});
|
|
749
|
-
return st(u, S, o), {
|
|
750
|
-
orders: r && !m ? ot(S, u) : S,
|
|
751
|
-
legacyLoaded: l || m
|
|
752
|
-
};
|
|
753
|
-
},
|
|
754
|
-
[e, o, i, r]
|
|
755
|
-
);
|
|
756
|
-
X(() => {
|
|
757
|
-
s.getState().configureOrders(c, a ? f : void 0);
|
|
758
|
-
}, [a, c, f, s]);
|
|
759
|
-
const O = v((u = !1) => {
|
|
760
|
-
if (!a || !c) return Promise.resolve(void 0);
|
|
761
|
-
const l = s.getState();
|
|
762
|
-
return l.configureOrders(c, f), l.refetchOrders(!0, u);
|
|
763
|
-
}, [a, c, f, s]);
|
|
764
|
-
return { enabled: a, key: c, refetch: O };
|
|
765
|
-
}, wt = () => {
|
|
766
|
-
Pe();
|
|
767
|
-
const e = z();
|
|
768
|
-
return v(
|
|
769
|
-
(t) => e.getState().addOrder(t),
|
|
770
|
-
[e]
|
|
771
|
-
);
|
|
772
|
-
}, vt = () => {
|
|
773
|
-
const e = z();
|
|
774
|
-
return v(
|
|
775
|
-
() => e.getState().refetchOrders(),
|
|
776
|
-
[e]
|
|
777
|
-
);
|
|
778
|
-
}, zt = () => {
|
|
779
|
-
const e = w((c) => c.orders), t = w(
|
|
780
|
-
(c) => c.registerOrdersConsumer
|
|
781
|
-
), { enabled: n, key: r, refetch: o } = Pe(), i = e.key === r ? e : At;
|
|
782
|
-
X(() => t(), [t]);
|
|
783
|
-
const s = C(
|
|
784
|
-
() => i.data === void 0 ? void 0 : Ee(i.data),
|
|
785
|
-
[i.data]
|
|
786
|
-
), a = v(async () => {
|
|
787
|
-
const c = await o();
|
|
788
|
-
return c === void 0 ? void 0 : Ee(c);
|
|
789
|
-
}, [o]);
|
|
790
|
-
return C(
|
|
791
|
-
() => ({
|
|
792
|
-
data: s,
|
|
793
|
-
error: i.error,
|
|
794
|
-
isLoading: n && s === void 0 && i.error === void 0,
|
|
795
|
-
isFetching: i.isFetching,
|
|
796
|
-
isRefetching: i.isFetching && s !== void 0,
|
|
797
|
-
refetch: a
|
|
798
|
-
}),
|
|
799
|
-
[i, s, n, a]
|
|
800
|
-
);
|
|
801
|
-
}, Ct = 60, Rt = () => {
|
|
802
|
-
const { refetch: e } = Pe();
|
|
796
|
+
) }) }) }) });
|
|
797
|
+
}, Qt = (e, t) => R(() => ne(t, e), [e, t]), Nt = 60, Lt = () => {
|
|
798
|
+
const { refetch: e } = Ne();
|
|
803
799
|
return v(
|
|
804
800
|
async (t, n = !1) => {
|
|
805
|
-
for (let r = 0; r <
|
|
806
|
-
const
|
|
807
|
-
if (!
|
|
801
|
+
for (let r = 0; r < Nt; r++) {
|
|
802
|
+
const i = await e(n);
|
|
803
|
+
if (!i)
|
|
808
804
|
throw new Error("orders not found");
|
|
809
|
-
const
|
|
805
|
+
const o = i.find(
|
|
810
806
|
(s) => s.historyKey === t
|
|
811
807
|
);
|
|
812
|
-
if ((
|
|
808
|
+
if ((o == null ? void 0 : o.status) === J.Cancelled)
|
|
813
809
|
return;
|
|
814
810
|
await new Promise((s) => setTimeout(s, 1e3));
|
|
815
811
|
}
|
|
@@ -819,211 +815,192 @@ const Et = ({
|
|
|
819
815
|
},
|
|
820
816
|
[e]
|
|
821
817
|
);
|
|
822
|
-
},
|
|
823
|
-
const e = z(), t = w((r) => r.updateState);
|
|
824
|
-
return {
|
|
825
|
-
cancelOrders: w((r) => r.state.cancelOrders),
|
|
826
|
-
setCancelOrder: (r, o) => {
|
|
827
|
-
const i = e.getState().state.cancelOrders;
|
|
828
|
-
t({
|
|
829
|
-
cancelOrders: { ...i, [r]: o }
|
|
830
|
-
});
|
|
831
|
-
},
|
|
832
|
-
clearCancelOrder: (r) => {
|
|
833
|
-
const o = e.getState().state.cancelOrders, { [r]: i, ...s } = o;
|
|
834
|
-
t({ cancelOrders: s });
|
|
835
|
-
}
|
|
836
|
-
};
|
|
837
|
-
}, Tt = (e) => ({
|
|
818
|
+
}, xt = (e) => ({
|
|
838
819
|
...e,
|
|
839
820
|
status: J.Cancelled
|
|
840
|
-
}),
|
|
841
|
-
const { account: t, walletInteractions: n, callbacks: r } = x(), { data:
|
|
842
|
-
cancelOrders: s,
|
|
843
|
-
setCancelOrder: a,
|
|
844
|
-
clearCancelOrder: c
|
|
845
|
-
} = yt(), f = v(async () => {
|
|
821
|
+
}), Yt = (e) => {
|
|
822
|
+
const { account: t, walletInteractions: n, callbacks: r } = x(), { data: i } = Y(), o = Lt(), s = A((u) => u.state.cancelOrders[(e == null ? void 0 : e.historyKey) ?? ""]), a = A((u) => u.setCancelOrder), c = A((u) => u.clearCancelOrder), h = v(async () => {
|
|
846
823
|
const u = e == null ? void 0 : e.historyKey;
|
|
847
824
|
try {
|
|
848
825
|
if (!t) throw new Error("missing account");
|
|
849
826
|
if (!e) throw new Error("order is required");
|
|
850
|
-
if (!
|
|
851
|
-
const
|
|
852
|
-
a(
|
|
853
|
-
var
|
|
854
|
-
return (
|
|
855
|
-
}),
|
|
856
|
-
() =>
|
|
827
|
+
if (!i) throw new Error("Spot client is unavailable");
|
|
828
|
+
const g = e.historyKey;
|
|
829
|
+
a(g, { status: q.LOADING }), I(() => {
|
|
830
|
+
var y;
|
|
831
|
+
return (y = r == null ? void 0 : r.onCancelOrderRequest) == null ? void 0 : y.call(r, e);
|
|
832
|
+
}), I(
|
|
833
|
+
() => i.analytics.onCancelOrderRequest(
|
|
857
834
|
[e.version === 1 ? e.id.toString() : e.hash],
|
|
858
835
|
e.version
|
|
859
836
|
)
|
|
860
837
|
);
|
|
861
|
-
const
|
|
838
|
+
const E = i.getCancelOrderRequest(e), m = await n.cancelOrder(E);
|
|
862
839
|
if (!m) throw new Error("failed to cancel order");
|
|
863
|
-
|
|
840
|
+
I(() => i.analytics.onCancelOrderSuccess(m)), a(g, {
|
|
864
841
|
status: q.LOADING,
|
|
865
842
|
txHash: m
|
|
866
|
-
}), await
|
|
867
|
-
const S =
|
|
868
|
-
return a(
|
|
843
|
+
}), await o(g, e.version === 1);
|
|
844
|
+
const S = xt(e);
|
|
845
|
+
return a(g, {
|
|
869
846
|
status: q.SUCCESS,
|
|
870
847
|
txHash: m
|
|
871
|
-
}),
|
|
848
|
+
}), I(
|
|
872
849
|
() => {
|
|
873
|
-
var
|
|
874
|
-
return (
|
|
850
|
+
var y;
|
|
851
|
+
return (y = r == null ? void 0 : r.onCancelOrderSuccess) == null ? void 0 : y.call(r, {
|
|
875
852
|
order: S,
|
|
876
853
|
txHash: m
|
|
877
854
|
});
|
|
878
855
|
}
|
|
879
856
|
), m;
|
|
880
|
-
} catch (
|
|
881
|
-
|
|
857
|
+
} catch (g) {
|
|
858
|
+
ve(g) ? u && c(u) : (u && a(u, {
|
|
882
859
|
status: q.FAILED,
|
|
883
|
-
error: ge(
|
|
884
|
-
}),
|
|
885
|
-
var
|
|
886
|
-
return (
|
|
860
|
+
error: ge(g)
|
|
861
|
+
}), I(() => i == null ? void 0 : i.analytics.onCancelOrderError(g))), I(() => {
|
|
862
|
+
var E;
|
|
863
|
+
return (E = r == null ? void 0 : r.onCancelOrderFailed) == null ? void 0 : E.call(r, re(g));
|
|
887
864
|
});
|
|
888
865
|
}
|
|
889
866
|
}, [
|
|
890
867
|
t,
|
|
891
868
|
r,
|
|
892
869
|
c,
|
|
893
|
-
o,
|
|
894
|
-
e,
|
|
895
870
|
i,
|
|
871
|
+
e,
|
|
872
|
+
o,
|
|
896
873
|
a,
|
|
897
874
|
n
|
|
898
|
-
]),
|
|
899
|
-
const u = s
|
|
875
|
+
]), p = R(() => {
|
|
876
|
+
const u = s;
|
|
900
877
|
return {
|
|
901
878
|
isLoading: (u == null ? void 0 : u.status) === q.LOADING,
|
|
902
|
-
disabled: !!(e && !
|
|
879
|
+
disabled: !!(e && !i),
|
|
903
880
|
isSuccess: (u == null ? void 0 : u.status) === q.SUCCESS,
|
|
904
881
|
isError: (u == null ? void 0 : u.status) === q.FAILED,
|
|
905
882
|
error: u == null ? void 0 : u.error,
|
|
906
883
|
txHash: u == null ? void 0 : u.txHash
|
|
907
884
|
};
|
|
908
|
-
}, [s, e,
|
|
909
|
-
return
|
|
910
|
-
},
|
|
885
|
+
}, [s, e, i]);
|
|
886
|
+
return R(() => ({ cancelOrder: h, ...p }), [h, p]);
|
|
887
|
+
}, Xt = () => {
|
|
911
888
|
const { module: e, values: t } = W();
|
|
912
|
-
if (t.isMarketOrder && e ===
|
|
913
|
-
return
|
|
914
|
-
if (e ===
|
|
915
|
-
return t.isMarketOrder ?
|
|
916
|
-
},
|
|
917
|
-
const { callbacks: e } = x(), t =
|
|
889
|
+
if (t.isMarketOrder && e === X.STOP_LOSS)
|
|
890
|
+
return ee.TRIGGER_MARKET_PRICE;
|
|
891
|
+
if (e === X.LIMIT || e === X.TWAP)
|
|
892
|
+
return t.isMarketOrder ? ee.MARKET_PRICE : ee.LIMIT_PRICE;
|
|
893
|
+
}, Zt = () => {
|
|
894
|
+
const { callbacks: e } = x(), t = A((a) => a.updateState), { schedule: n } = W(), { duration: r } = n, i = v(
|
|
918
895
|
(a) => {
|
|
919
|
-
t({ orderDuration: a }),
|
|
896
|
+
t({ orderDuration: a }), I(() => {
|
|
920
897
|
var c;
|
|
921
898
|
return (c = e == null ? void 0 : e.onOrderDurationChange) == null ? void 0 : c.call(e, a);
|
|
922
899
|
});
|
|
923
900
|
},
|
|
924
901
|
[e, t]
|
|
925
|
-
),
|
|
902
|
+
), o = v(
|
|
926
903
|
(a) => {
|
|
927
904
|
const c = Number(a);
|
|
928
|
-
Number.isFinite(c) &&
|
|
905
|
+
Number.isFinite(c) && i({ unit: r.unit, value: c });
|
|
929
906
|
},
|
|
930
|
-
[r.unit,
|
|
907
|
+
[r.unit, i]
|
|
931
908
|
), s = v(
|
|
932
909
|
(a) => {
|
|
933
|
-
|
|
910
|
+
i({ unit: a, value: r.value });
|
|
934
911
|
},
|
|
935
|
-
[r.value,
|
|
912
|
+
[r.value, i]
|
|
936
913
|
);
|
|
937
|
-
return
|
|
914
|
+
return R(
|
|
938
915
|
() => ({
|
|
939
916
|
duration: r,
|
|
940
|
-
onChange:
|
|
917
|
+
onChange: i,
|
|
941
918
|
milliseconds: n.durationMillis,
|
|
942
|
-
onInputChange:
|
|
919
|
+
onInputChange: o,
|
|
943
920
|
onUnitSelect: s,
|
|
944
921
|
error: n.durationError
|
|
945
922
|
}),
|
|
946
|
-
[r,
|
|
923
|
+
[r, i, o, s, n]
|
|
947
924
|
);
|
|
948
|
-
},
|
|
949
|
-
const { callbacks: e } = x(), t =
|
|
925
|
+
}, bt = () => {
|
|
926
|
+
const { callbacks: e } = x(), t = A((a) => a.updateState), { schedule: n } = W(), { fillDelay: r } = n, i = v(
|
|
950
927
|
(a) => {
|
|
951
|
-
t({ tradeInterval: a }),
|
|
928
|
+
t({ tradeInterval: a }), I(() => {
|
|
952
929
|
var c;
|
|
953
930
|
return (c = e == null ? void 0 : e.onTradeIntervalChange) == null ? void 0 : c.call(e, a);
|
|
954
931
|
});
|
|
955
932
|
},
|
|
956
933
|
[e, t]
|
|
957
|
-
),
|
|
934
|
+
), o = v(
|
|
958
935
|
(a) => {
|
|
959
936
|
const c = Number(a);
|
|
960
|
-
Number.isFinite(c) &&
|
|
937
|
+
Number.isFinite(c) && i({ unit: r.unit, value: c });
|
|
961
938
|
},
|
|
962
|
-
[r.unit,
|
|
939
|
+
[r.unit, i]
|
|
963
940
|
), s = v(
|
|
964
|
-
(a) =>
|
|
965
|
-
[r.value,
|
|
941
|
+
(a) => i({ unit: a, value: r.value }),
|
|
942
|
+
[r.value, i]
|
|
966
943
|
);
|
|
967
|
-
return
|
|
944
|
+
return R(
|
|
968
945
|
() => ({
|
|
969
|
-
onInputChange:
|
|
946
|
+
onInputChange: o,
|
|
970
947
|
onUnitSelect: s,
|
|
971
|
-
onChange:
|
|
948
|
+
onChange: i,
|
|
972
949
|
milliseconds: n.fillDelayMillis,
|
|
973
950
|
fillDelay: r,
|
|
974
951
|
error: n.fillDelayError
|
|
975
952
|
}),
|
|
976
|
-
[r,
|
|
953
|
+
[r, i, o, s, n]
|
|
977
954
|
);
|
|
978
|
-
},
|
|
955
|
+
}, _ = (e, t) => ({
|
|
979
956
|
raw: e || "",
|
|
980
|
-
ui:
|
|
981
|
-
}),
|
|
957
|
+
ui: ne(e, t)
|
|
958
|
+
}), Ft = (e, t, n) => R(() => !e || !t || !n ? [] : e.map((r) => ({
|
|
982
959
|
rawFill: r,
|
|
983
960
|
inputToken: t,
|
|
984
961
|
outputToken: n,
|
|
985
|
-
inputAmount:
|
|
986
|
-
outputAmount:
|
|
962
|
+
inputAmount: _(r.inAmount, t.decimals),
|
|
963
|
+
outputAmount: _(r.outAmount, n.decimals),
|
|
987
964
|
timestamp: r.timestamp,
|
|
988
965
|
txHash: r.txHash,
|
|
989
|
-
executionRate:
|
|
966
|
+
executionRate: we(
|
|
990
967
|
r.inAmount,
|
|
991
968
|
r.outAmount,
|
|
992
969
|
t.decimals,
|
|
993
970
|
n.decimals
|
|
994
971
|
)
|
|
995
|
-
})), [e, t, n]),
|
|
996
|
-
const { chainId: r, partner:
|
|
972
|
+
})), [e, t, n]), kt = (e, t, n) => {
|
|
973
|
+
const { chainId: r, partner: i } = x(), o = R(() => {
|
|
997
974
|
if (!(!t || !n || !e || e.isMarketPrice))
|
|
998
975
|
return Me(
|
|
999
976
|
e,
|
|
1000
977
|
t.decimals,
|
|
1001
978
|
n.decimals
|
|
1002
979
|
);
|
|
1003
|
-
}, [t, e, n]), s =
|
|
980
|
+
}, [t, e, n]), s = R(() => {
|
|
1004
981
|
if (!(!t || !n || !e))
|
|
1005
|
-
return
|
|
982
|
+
return Be(
|
|
1006
983
|
e,
|
|
1007
984
|
t.decimals,
|
|
1008
985
|
n.decimals
|
|
1009
986
|
);
|
|
1010
|
-
}, [t, e, n]), a =
|
|
987
|
+
}, [t, e, n]), a = R(() => {
|
|
1011
988
|
if (!(!t || !n || !e))
|
|
1012
|
-
return
|
|
989
|
+
return we(
|
|
1013
990
|
e.srcAmountFilled,
|
|
1014
991
|
e.dstAmountFilled,
|
|
1015
992
|
t.decimals,
|
|
1016
993
|
n.decimals
|
|
1017
994
|
);
|
|
1018
|
-
}, [t, e, n]), c =
|
|
995
|
+
}, [t, e, n]), c = R(() => e ? _e(
|
|
1019
996
|
e,
|
|
1020
|
-
r ?
|
|
1021
|
-
) : 0, [e,
|
|
1022
|
-
return
|
|
997
|
+
r ? qe(i, r) : void 0
|
|
998
|
+
) : 0, [e, i, r]), h = Ft(e == null ? void 0 : e.fills, t, n);
|
|
999
|
+
return R(() => {
|
|
1023
1000
|
if (e != null && e.id)
|
|
1024
1001
|
return {
|
|
1025
1002
|
original: e,
|
|
1026
|
-
fills:
|
|
1003
|
+
fills: h,
|
|
1027
1004
|
inputToken: t,
|
|
1028
1005
|
outputToken: n,
|
|
1029
1006
|
orderType: e.type,
|
|
@@ -1032,77 +1009,77 @@ const Et = ({
|
|
|
1032
1009
|
totalTrades: e.totalTradesAmount || 0,
|
|
1033
1010
|
tradeInterval: c,
|
|
1034
1011
|
recipient: e.maker || "",
|
|
1035
|
-
inputAmount:
|
|
1036
|
-
limitPrice:
|
|
1037
|
-
|
|
1012
|
+
inputAmount: _(e.srcAmount, t == null ? void 0 : t.decimals),
|
|
1013
|
+
limitPrice: _(
|
|
1014
|
+
k(o, n == null ? void 0 : n.decimals),
|
|
1038
1015
|
n == null ? void 0 : n.decimals
|
|
1039
1016
|
),
|
|
1040
|
-
inputAmountPerTrade:
|
|
1017
|
+
inputAmountPerTrade: _(
|
|
1041
1018
|
e.srcAmountPerTrade,
|
|
1042
1019
|
t == null ? void 0 : t.decimals
|
|
1043
1020
|
),
|
|
1044
|
-
minOutputAmountPerTrade:
|
|
1021
|
+
minOutputAmountPerTrade: _(
|
|
1045
1022
|
e.dstMinAmountPerTrade,
|
|
1046
1023
|
n == null ? void 0 : n.decimals
|
|
1047
1024
|
),
|
|
1048
|
-
minOutputAmount:
|
|
1025
|
+
minOutputAmount: _(
|
|
1049
1026
|
e.dstMinAmountTotal,
|
|
1050
1027
|
n == null ? void 0 : n.decimals
|
|
1051
1028
|
),
|
|
1052
|
-
triggerPrice:
|
|
1053
|
-
|
|
1029
|
+
triggerPrice: _(
|
|
1030
|
+
k(s, n == null ? void 0 : n.decimals),
|
|
1054
1031
|
n == null ? void 0 : n.decimals
|
|
1055
1032
|
),
|
|
1056
1033
|
id: e.id,
|
|
1057
|
-
inputAmountFilled:
|
|
1034
|
+
inputAmountFilled: _(
|
|
1058
1035
|
e.srcAmountFilled,
|
|
1059
1036
|
t == null ? void 0 : t.decimals
|
|
1060
1037
|
),
|
|
1061
|
-
outputAmountFilled:
|
|
1038
|
+
outputAmountFilled: _(
|
|
1062
1039
|
e.dstAmountFilled,
|
|
1063
1040
|
n == null ? void 0 : n.decimals
|
|
1064
1041
|
),
|
|
1065
1042
|
progress: e.progress,
|
|
1066
|
-
executionPrice:
|
|
1067
|
-
|
|
1043
|
+
executionPrice: _(
|
|
1044
|
+
k(a, n == null ? void 0 : n.decimals),
|
|
1068
1045
|
n == null ? void 0 : n.decimals
|
|
1069
1046
|
),
|
|
1070
1047
|
version: e.version
|
|
1071
1048
|
};
|
|
1072
1049
|
}, [
|
|
1073
1050
|
e,
|
|
1074
|
-
|
|
1051
|
+
h,
|
|
1075
1052
|
t,
|
|
1076
1053
|
n,
|
|
1077
1054
|
c,
|
|
1078
|
-
|
|
1055
|
+
o,
|
|
1079
1056
|
s,
|
|
1080
1057
|
a
|
|
1081
1058
|
]);
|
|
1082
|
-
},
|
|
1059
|
+
}, er = () => {
|
|
1083
1060
|
const { marketPriceLoading: e } = x(), t = W().errors.primary;
|
|
1084
1061
|
return e ? void 0 : t;
|
|
1085
|
-
},
|
|
1086
|
-
const { marketPriceLoading: e, inputToken: t, outputToken: n, callbacks: r } = x(), { limitPrice:
|
|
1062
|
+
}, tr = () => {
|
|
1063
|
+
const { marketPriceLoading: e, inputToken: t, outputToken: n, callbacks: r } = x(), { limitPrice: i, values: o, module: s, isInverted: a } = W(), c = A((m) => m.updateState), h = v(
|
|
1087
1064
|
(m) => {
|
|
1088
|
-
c({ limitPriceUi: m, limitPricePercent: null }),
|
|
1065
|
+
c({ limitPriceUi: m, limitPricePercent: null }), I(() => {
|
|
1089
1066
|
var S;
|
|
1090
1067
|
return (S = r == null ? void 0 : r.onLimitPriceChange) == null ? void 0 : S.call(r, m || "");
|
|
1091
|
-
}),
|
|
1068
|
+
}), I(() => {
|
|
1092
1069
|
var S;
|
|
1093
1070
|
return (S = r == null ? void 0 : r.onLimitPricePercentChange) == null ? void 0 : S.call(r, "");
|
|
1094
1071
|
});
|
|
1095
1072
|
},
|
|
1096
1073
|
[r, c]
|
|
1097
|
-
),
|
|
1074
|
+
), p = v(
|
|
1098
1075
|
(m) => {
|
|
1099
1076
|
c({
|
|
1100
1077
|
limitPriceUi: void 0,
|
|
1101
1078
|
limitPricePercent: m
|
|
1102
|
-
}),
|
|
1079
|
+
}), I(() => {
|
|
1103
1080
|
var S;
|
|
1104
1081
|
return (S = r == null ? void 0 : r.onLimitPriceChange) == null ? void 0 : S.call(r, "");
|
|
1105
|
-
}),
|
|
1082
|
+
}), I(() => {
|
|
1106
1083
|
var S;
|
|
1107
1084
|
return (S = r == null ? void 0 : r.onLimitPricePercentChange) == null ? void 0 : S.call(r, m || "");
|
|
1108
1085
|
});
|
|
@@ -1113,62 +1090,62 @@ const Et = ({
|
|
|
1113
1090
|
limitPriceUi: void 0,
|
|
1114
1091
|
limitPricePercent: void 0
|
|
1115
1092
|
});
|
|
1116
|
-
}, [c]),
|
|
1093
|
+
}, [c]), g = !o.isMarketOrder, E = v(() => {
|
|
1117
1094
|
c({
|
|
1118
|
-
isMarketOrder: !
|
|
1119
|
-
...
|
|
1120
|
-
...!
|
|
1095
|
+
isMarketOrder: !o.isMarketOrder,
|
|
1096
|
+
...o.isMarketOrder ? {} : { isPriceInverted: !1 },
|
|
1097
|
+
...!o.isMarketOrder && s === X.STOP_LOSS ? { limitPricePercent: void 0 } : {}
|
|
1121
1098
|
});
|
|
1122
|
-
}, [s, c,
|
|
1123
|
-
return
|
|
1099
|
+
}, [s, c, o.isMarketOrder]);
|
|
1100
|
+
return R(
|
|
1124
1101
|
() => ({
|
|
1125
|
-
price:
|
|
1126
|
-
canonicalPriceRaw:
|
|
1127
|
-
error:
|
|
1128
|
-
onInputChange:
|
|
1129
|
-
onPercentageChange:
|
|
1102
|
+
price: i.display,
|
|
1103
|
+
canonicalPriceRaw: i.raw,
|
|
1104
|
+
error: i.error,
|
|
1105
|
+
onInputChange: h,
|
|
1106
|
+
onPercentageChange: p,
|
|
1130
1107
|
onReset: u,
|
|
1131
1108
|
inputToken: t,
|
|
1132
1109
|
outputToken: n,
|
|
1133
1110
|
displayInputToken: a ? n : t,
|
|
1134
1111
|
displayOutputToken: a ? t : n,
|
|
1135
|
-
percentage:
|
|
1112
|
+
percentage: i.percentage,
|
|
1136
1113
|
isLoading: !!e,
|
|
1137
|
-
isEnabled:
|
|
1138
|
-
toggle:
|
|
1139
|
-
isTypedValue:
|
|
1114
|
+
isEnabled: g,
|
|
1115
|
+
toggle: E,
|
|
1116
|
+
isTypedValue: i.isTypedValue
|
|
1140
1117
|
}),
|
|
1141
1118
|
[
|
|
1142
1119
|
t,
|
|
1143
1120
|
a,
|
|
1144
|
-
|
|
1145
|
-
|
|
1121
|
+
g,
|
|
1122
|
+
i,
|
|
1146
1123
|
e,
|
|
1147
|
-
|
|
1148
|
-
|
|
1124
|
+
h,
|
|
1125
|
+
p,
|
|
1149
1126
|
u,
|
|
1150
1127
|
n,
|
|
1151
|
-
|
|
1128
|
+
E
|
|
1152
1129
|
]
|
|
1153
1130
|
);
|
|
1154
|
-
},
|
|
1131
|
+
}, rr = () => {
|
|
1155
1132
|
const { marketPriceLoading: e } = x(), { outputAmount: t } = W();
|
|
1156
|
-
return
|
|
1133
|
+
return R(
|
|
1157
1134
|
() => ({
|
|
1158
1135
|
amount: t,
|
|
1159
1136
|
isLoading: !!e
|
|
1160
1137
|
}),
|
|
1161
1138
|
[e, t]
|
|
1162
1139
|
);
|
|
1163
|
-
},
|
|
1164
|
-
const { inputToken: e, outputToken: t } = x(), n =
|
|
1140
|
+
}, nr = () => {
|
|
1141
|
+
const { inputToken: e, outputToken: t } = x(), n = A((c) => c.updateState), { isInverted: r, values: i } = W(), o = A((c) => c.state.triggerPriceUi), s = A((c) => c.state.limitPriceUi), a = v(() => {
|
|
1165
1142
|
n({
|
|
1166
1143
|
isPriceInverted: !r,
|
|
1167
|
-
...
|
|
1168
|
-
...s !== void 0 ? { limitPriceUi:
|
|
1144
|
+
...o !== void 0 ? { triggerPriceUi: fe(o) } : {},
|
|
1145
|
+
...s !== void 0 ? { limitPriceUi: fe(s) } : {}
|
|
1169
1146
|
});
|
|
1170
|
-
}, [n, r,
|
|
1171
|
-
return
|
|
1147
|
+
}, [n, r, o, s]);
|
|
1148
|
+
return R(
|
|
1172
1149
|
() => ({
|
|
1173
1150
|
onInvert: a,
|
|
1174
1151
|
isInverted: r,
|
|
@@ -1176,36 +1153,36 @@ const Et = ({
|
|
|
1176
1153
|
outputToken: t,
|
|
1177
1154
|
displayInputToken: r ? t : e,
|
|
1178
1155
|
displayOutputToken: r ? e : t,
|
|
1179
|
-
isMarketOrder:
|
|
1156
|
+
isMarketOrder: i.isMarketOrder
|
|
1180
1157
|
}),
|
|
1181
|
-
[e, r, a, t,
|
|
1158
|
+
[e, r, a, t, i.isMarketOrder]
|
|
1182
1159
|
);
|
|
1183
|
-
},
|
|
1160
|
+
}, pe = 3, Ut = 3e3, Dt = (e) => new Promise((t) => setTimeout(t, e)), de = (e, t) => {
|
|
1184
1161
|
if (!/^\d+$/.test(e))
|
|
1185
1162
|
throw new Error(
|
|
1186
1163
|
`${t} must be a non-negative integer base-unit amount`
|
|
1187
1164
|
);
|
|
1188
1165
|
return BigInt(e);
|
|
1189
|
-
},
|
|
1166
|
+
}, Ae = async ({
|
|
1190
1167
|
client: e,
|
|
1191
1168
|
walletInteractions: t,
|
|
1192
1169
|
tokenAddress: n,
|
|
1193
1170
|
inputAmountRaw: r
|
|
1194
1171
|
}) => {
|
|
1195
|
-
const
|
|
1172
|
+
const i = await t.getAllowance({
|
|
1196
1173
|
tokenAddress: n,
|
|
1197
1174
|
spenderAddress: e.spenderAddress
|
|
1198
1175
|
});
|
|
1199
|
-
return de(
|
|
1200
|
-
},
|
|
1176
|
+
return de(i || "0", "Allowance") >= de(r, "Input amount");
|
|
1177
|
+
}, Gt = (e) => {
|
|
1201
1178
|
if (!e.client) throw new Error("Spot client is unavailable");
|
|
1202
|
-
if (!e.
|
|
1179
|
+
if (!e.hasChainId || !e.chainId)
|
|
1203
1180
|
throw new Error("Spot is unavailable on the connected chain");
|
|
1204
1181
|
if (!e.account) throw new Error("missing account");
|
|
1205
1182
|
if (!e.inputToken) throw new Error("missing inputToken");
|
|
1206
1183
|
if (!e.outputToken) throw new Error("missing outputToken");
|
|
1207
|
-
const t =
|
|
1208
|
-
if (!t ||
|
|
1184
|
+
const t = Q(e.inputToken.address) ? e.wrappedNativeToken : e.inputToken;
|
|
1185
|
+
if (!t || Q(t.address))
|
|
1209
1186
|
throw new Error("missing wrappedNativeToken for native input");
|
|
1210
1187
|
if (!e.form.canSubmit)
|
|
1211
1188
|
throw new Error("Order form is not submittable");
|
|
@@ -1219,303 +1196,305 @@ const Et = ({
|
|
|
1219
1196
|
client: e.client,
|
|
1220
1197
|
inputAmountRaw: n
|
|
1221
1198
|
};
|
|
1222
|
-
},
|
|
1223
|
-
|
|
1224
|
-
|
|
1225
|
-
|
|
1226
|
-
|
|
1199
|
+
}, Mt = ({
|
|
1200
|
+
analytics: e,
|
|
1201
|
+
account: t,
|
|
1202
|
+
chainId: n,
|
|
1203
|
+
inputToken: r,
|
|
1204
|
+
outputToken: i,
|
|
1227
1205
|
preparedOrder: o
|
|
1228
1206
|
}) => {
|
|
1229
|
-
const { form:
|
|
1230
|
-
|
|
1231
|
-
() =>
|
|
1232
|
-
account:
|
|
1233
|
-
chainId:
|
|
1234
|
-
module:
|
|
1235
|
-
srcToken:
|
|
1236
|
-
dstToken:
|
|
1237
|
-
fromTokenAmount:
|
|
1238
|
-
srcChunkAmount:
|
|
1239
|
-
triggerPricePerTrade:
|
|
1240
|
-
deadline:
|
|
1241
|
-
fillDelay:
|
|
1242
|
-
minDstAmountOutPerTrade:
|
|
1243
|
-
slippage:
|
|
1244
|
-
isMarketOrder:
|
|
1245
|
-
chunksAmount:
|
|
1207
|
+
const { form: s, values: a } = o;
|
|
1208
|
+
I(
|
|
1209
|
+
() => e.onRequestOrder({
|
|
1210
|
+
account: t,
|
|
1211
|
+
chainId: n,
|
|
1212
|
+
module: s.module,
|
|
1213
|
+
srcToken: r,
|
|
1214
|
+
dstToken: i,
|
|
1215
|
+
fromTokenAmount: a.inputAmount,
|
|
1216
|
+
srcChunkAmount: a.inputAmountPerTrade,
|
|
1217
|
+
triggerPricePerTrade: a.triggerOutputAmountPerTrade,
|
|
1218
|
+
deadline: a.deadlineMillis,
|
|
1219
|
+
fillDelay: a.fillDelayMillis,
|
|
1220
|
+
minDstAmountOutPerTrade: a.minOutputAmountPerTrade,
|
|
1221
|
+
slippage: s.values.slippageBps / 100,
|
|
1222
|
+
isMarketOrder: a.isMarketOrder,
|
|
1223
|
+
chunksAmount: a.totalTrades
|
|
1246
1224
|
})
|
|
1247
1225
|
);
|
|
1248
|
-
},
|
|
1226
|
+
}, Bt = async (e) => {
|
|
1249
1227
|
const {
|
|
1250
1228
|
form: t,
|
|
1251
1229
|
walletInteractions: n,
|
|
1252
1230
|
callbacks: r,
|
|
1253
|
-
addNewOrder:
|
|
1254
|
-
refetchActiveOrders:
|
|
1231
|
+
addNewOrder: i,
|
|
1232
|
+
refetchActiveOrders: o,
|
|
1255
1233
|
getCurrentExecution: s,
|
|
1256
1234
|
beginExecution: a,
|
|
1257
1235
|
replaceExecution: c,
|
|
1258
|
-
wait:
|
|
1236
|
+
wait: h = Dt
|
|
1259
1237
|
} = e;
|
|
1260
|
-
let
|
|
1238
|
+
let p;
|
|
1261
1239
|
try {
|
|
1262
|
-
|
|
1263
|
-
} catch (
|
|
1264
|
-
const
|
|
1240
|
+
p = Gt(e);
|
|
1241
|
+
} catch (w) {
|
|
1242
|
+
const F = re(w), C = se(w), D = a({
|
|
1265
1243
|
form: t,
|
|
1266
1244
|
inputToken: e.inputToken,
|
|
1267
1245
|
outputToken: e.outputToken,
|
|
1268
1246
|
chainId: e.chainId
|
|
1269
1247
|
});
|
|
1270
|
-
throw
|
|
1271
|
-
...
|
|
1248
|
+
throw D && c(D.executionId, {
|
|
1249
|
+
...D,
|
|
1272
1250
|
phase: d.FAILED,
|
|
1273
|
-
error:
|
|
1274
|
-
parsedError:
|
|
1275
|
-
}),
|
|
1251
|
+
error: F,
|
|
1252
|
+
parsedError: C
|
|
1253
|
+
}), I(
|
|
1276
1254
|
() => {
|
|
1277
1255
|
var G;
|
|
1278
|
-
return (G = r == null ? void 0 : r.onSubmitOrderFailed) == null ? void 0 : G.call(r,
|
|
1256
|
+
return (G = r == null ? void 0 : r.onSubmitOrderFailed) == null ? void 0 : G.call(r, C);
|
|
1279
1257
|
}
|
|
1280
|
-
),
|
|
1258
|
+
), F;
|
|
1281
1259
|
}
|
|
1282
1260
|
const {
|
|
1283
1261
|
account: u,
|
|
1284
|
-
chainId:
|
|
1285
|
-
inputToken:
|
|
1262
|
+
chainId: g,
|
|
1263
|
+
inputToken: E,
|
|
1286
1264
|
orderInputToken: m,
|
|
1287
1265
|
outputToken: S,
|
|
1288
|
-
client:
|
|
1266
|
+
client: y,
|
|
1289
1267
|
inputAmountRaw: T
|
|
1290
|
-
} =
|
|
1268
|
+
} = p, { analytics: L } = y, K = s(), M = nt({
|
|
1291
1269
|
execution: K,
|
|
1292
1270
|
account: u,
|
|
1293
|
-
chainId:
|
|
1294
|
-
inputTokenAddress:
|
|
1271
|
+
chainId: g,
|
|
1272
|
+
inputTokenAddress: E.address,
|
|
1295
1273
|
inputAmountRaw: T
|
|
1296
|
-
}),
|
|
1274
|
+
}), l = a({
|
|
1297
1275
|
form: t,
|
|
1298
|
-
inputToken:
|
|
1276
|
+
inputToken: E,
|
|
1299
1277
|
outputToken: S,
|
|
1300
|
-
chainId:
|
|
1278
|
+
chainId: g,
|
|
1301
1279
|
completedWrap: M,
|
|
1302
1280
|
wrapTxHash: M == null ? void 0 : M.txHash
|
|
1303
1281
|
});
|
|
1304
|
-
if (!
|
|
1305
|
-
const
|
|
1306
|
-
let
|
|
1307
|
-
const
|
|
1308
|
-
const
|
|
1309
|
-
...
|
|
1310
|
-
...
|
|
1311
|
-
executionId:
|
|
1312
|
-
phase:
|
|
1282
|
+
if (!l) return;
|
|
1283
|
+
const P = l.executionId;
|
|
1284
|
+
let O = l;
|
|
1285
|
+
const f = (w, F = {}) => {
|
|
1286
|
+
const C = {
|
|
1287
|
+
...O,
|
|
1288
|
+
...F,
|
|
1289
|
+
executionId: P,
|
|
1290
|
+
phase: w
|
|
1313
1291
|
};
|
|
1314
|
-
if (!c(
|
|
1292
|
+
if (!c(P, C))
|
|
1315
1293
|
throw new Error("Execution is no longer current");
|
|
1316
|
-
|
|
1317
|
-
},
|
|
1318
|
-
const
|
|
1319
|
-
...
|
|
1320
|
-
...
|
|
1321
|
-
executionId:
|
|
1322
|
-
phase:
|
|
1294
|
+
O = C;
|
|
1295
|
+
}, B = (w, F = {}) => {
|
|
1296
|
+
const C = {
|
|
1297
|
+
...O,
|
|
1298
|
+
...F,
|
|
1299
|
+
executionId: P,
|
|
1300
|
+
phase: w
|
|
1323
1301
|
};
|
|
1324
|
-
return c(
|
|
1302
|
+
return c(P, C) ? (O = C, !0) : !1;
|
|
1325
1303
|
};
|
|
1326
1304
|
try {
|
|
1327
|
-
const
|
|
1328
|
-
client:
|
|
1305
|
+
const w = Q(E.address) && !M, F = !await Ae({
|
|
1306
|
+
client: y,
|
|
1329
1307
|
walletInteractions: n,
|
|
1330
1308
|
tokenAddress: m.address,
|
|
1331
1309
|
inputAmountRaw: T
|
|
1332
|
-
}),
|
|
1333
|
-
|
|
1334
|
-
let
|
|
1335
|
-
if (
|
|
1336
|
-
pendingSteps:
|
|
1337
|
-
totalSteps:
|
|
1338
|
-
stepIndex:
|
|
1339
|
-
hasApproval: !
|
|
1340
|
-
}),
|
|
1341
|
-
|
|
1342
|
-
const
|
|
1310
|
+
}), C = [];
|
|
1311
|
+
w && C.push(z.WRAP), F && C.push(z.APPROVE), C.push(z.CREATE);
|
|
1312
|
+
let D = 0;
|
|
1313
|
+
if (f(d.PREPARING, {
|
|
1314
|
+
pendingSteps: C,
|
|
1315
|
+
totalSteps: C.length,
|
|
1316
|
+
stepIndex: D,
|
|
1317
|
+
hasApproval: !F
|
|
1318
|
+
}), w) {
|
|
1319
|
+
f(d.WRAPPING), I(() => L.onWrapRequest()), I(r == null ? void 0 : r.onWrapRequest);
|
|
1320
|
+
const N = await n.wrapNativeToken(
|
|
1343
1321
|
T
|
|
1344
1322
|
);
|
|
1345
|
-
if (!
|
|
1323
|
+
if (!N) throw new Error("failed to wrap input token");
|
|
1346
1324
|
const j = {
|
|
1347
1325
|
account: u,
|
|
1348
|
-
chainId:
|
|
1349
|
-
inputTokenAddress:
|
|
1326
|
+
chainId: g,
|
|
1327
|
+
inputTokenAddress: E.address,
|
|
1350
1328
|
inputAmountRaw: T,
|
|
1351
|
-
txHash:
|
|
1329
|
+
txHash: N
|
|
1352
1330
|
};
|
|
1353
|
-
|
|
1354
|
-
wrapTxHash:
|
|
1331
|
+
D++, f(d.WRAPPING, {
|
|
1332
|
+
wrapTxHash: N,
|
|
1355
1333
|
completedWrap: j,
|
|
1356
|
-
stepIndex:
|
|
1357
|
-
}),
|
|
1334
|
+
stepIndex: D
|
|
1335
|
+
}), I(() => L.onWrapSuccess(N)), I(
|
|
1358
1336
|
() => {
|
|
1359
1337
|
var H;
|
|
1360
1338
|
return (H = r == null ? void 0 : r.onWrapSuccess) == null ? void 0 : H.call(r, {
|
|
1361
|
-
txHash:
|
|
1362
|
-
amount:
|
|
1339
|
+
txHash: N,
|
|
1340
|
+
amount: ne(T, m.decimals)
|
|
1363
1341
|
});
|
|
1364
1342
|
}
|
|
1365
1343
|
);
|
|
1366
1344
|
}
|
|
1367
|
-
if (
|
|
1368
|
-
|
|
1369
|
-
const
|
|
1345
|
+
if (F) {
|
|
1346
|
+
f(d.APPROVING), I(() => L.onApproveRequest()), I(r == null ? void 0 : r.onApproveRequest);
|
|
1347
|
+
const N = await n.approveToken({
|
|
1370
1348
|
tokenAddress: m.address,
|
|
1371
1349
|
amount: T,
|
|
1372
|
-
spenderAddress:
|
|
1350
|
+
spenderAddress: y.spenderAddress
|
|
1373
1351
|
});
|
|
1374
|
-
if (!
|
|
1375
|
-
|
|
1352
|
+
if (!N) throw new Error("failed to approve token");
|
|
1353
|
+
f(d.APPROVING, { approveTxHash: N });
|
|
1376
1354
|
let j = !1;
|
|
1377
|
-
for (let H = 0; H <
|
|
1378
|
-
client:
|
|
1355
|
+
for (let H = 0; H < pe && (j = await Ae({
|
|
1356
|
+
client: y,
|
|
1379
1357
|
walletInteractions: n,
|
|
1380
1358
|
tokenAddress: m.address,
|
|
1381
1359
|
inputAmountRaw: T
|
|
1382
1360
|
}), !j); H++)
|
|
1383
|
-
H <
|
|
1361
|
+
H < pe - 1 && await h(Ut);
|
|
1384
1362
|
if (!j)
|
|
1385
1363
|
throw new Error(
|
|
1386
1364
|
`Insufficient ${m.symbol} allowance to perform the swap. Please approve the token first.`
|
|
1387
1365
|
);
|
|
1388
|
-
|
|
1366
|
+
D++, f(d.APPROVING, {
|
|
1389
1367
|
hasApproval: !0,
|
|
1390
|
-
stepIndex:
|
|
1391
|
-
}),
|
|
1368
|
+
stepIndex: D
|
|
1369
|
+
}), I(() => L.onApproveSuccess(N)), I(
|
|
1392
1370
|
() => {
|
|
1393
1371
|
var H;
|
|
1394
1372
|
return (H = r == null ? void 0 : r.onApproveSuccess) == null ? void 0 : H.call(r, {
|
|
1395
|
-
txHash:
|
|
1373
|
+
txHash: N,
|
|
1396
1374
|
token: m,
|
|
1397
|
-
amount:
|
|
1375
|
+
amount: ne(T, m.decimals)
|
|
1398
1376
|
});
|
|
1399
1377
|
}
|
|
1400
1378
|
);
|
|
1401
1379
|
}
|
|
1402
|
-
|
|
1403
|
-
const G =
|
|
1380
|
+
f(d.SIGNING);
|
|
1381
|
+
const G = y.prepareOrder({
|
|
1404
1382
|
form: t,
|
|
1405
1383
|
inputTokenAddress: m.address,
|
|
1406
1384
|
outputTokenAddress: S.address,
|
|
1407
1385
|
swapperAddress: u
|
|
1408
1386
|
});
|
|
1409
|
-
|
|
1387
|
+
f(d.SIGNING, { preparedOrder: G }), Mt({
|
|
1388
|
+
analytics: L,
|
|
1410
1389
|
account: u,
|
|
1411
|
-
chainId:
|
|
1412
|
-
inputToken:
|
|
1390
|
+
chainId: g,
|
|
1391
|
+
inputToken: E,
|
|
1413
1392
|
outputToken: S,
|
|
1414
1393
|
preparedOrder: G
|
|
1415
|
-
}),
|
|
1416
|
-
let
|
|
1394
|
+
}), I(() => L.onSignOrderRequest(G.order)), I(r == null ? void 0 : r.onSignOrderRequest);
|
|
1395
|
+
let Z;
|
|
1417
1396
|
try {
|
|
1418
|
-
|
|
1397
|
+
Z = await n.signOrder(
|
|
1419
1398
|
G.signingRequest
|
|
1420
|
-
),
|
|
1421
|
-
var
|
|
1422
|
-
return (
|
|
1399
|
+
), I(() => L.onSignOrderSuccess(Z)), I(() => {
|
|
1400
|
+
var N;
|
|
1401
|
+
return (N = r == null ? void 0 : r.onSignOrderSuccess) == null ? void 0 : N.call(r, Z);
|
|
1423
1402
|
});
|
|
1424
|
-
} catch (
|
|
1425
|
-
throw
|
|
1403
|
+
} catch (N) {
|
|
1404
|
+
throw I(() => L.onSignOrderError(N)), I(() => {
|
|
1426
1405
|
var j;
|
|
1427
|
-
return (j = r == null ? void 0 : r.onSignOrderError) == null ? void 0 : j.call(r,
|
|
1428
|
-
}),
|
|
1406
|
+
return (j = r == null ? void 0 : r.onSignOrderError) == null ? void 0 : j.call(r, re(N));
|
|
1407
|
+
}), N;
|
|
1429
1408
|
}
|
|
1430
|
-
|
|
1431
|
-
const
|
|
1432
|
-
return
|
|
1433
|
-
orderId:
|
|
1434
|
-
}),
|
|
1435
|
-
var
|
|
1436
|
-
return (
|
|
1437
|
-
}),
|
|
1438
|
-
} catch (
|
|
1439
|
-
const
|
|
1440
|
-
throw
|
|
1441
|
-
|
|
1409
|
+
f(d.SUBMITTING);
|
|
1410
|
+
const b = await y.submitOrder(G.order, Z);
|
|
1411
|
+
return f(d.SUCCESS, {
|
|
1412
|
+
orderId: b.id.toString()
|
|
1413
|
+
}), I(() => i(b)), I(() => o()), I(() => {
|
|
1414
|
+
var N;
|
|
1415
|
+
return (N = r == null ? void 0 : r.onOrderCreated) == null ? void 0 : N.call(r, b);
|
|
1416
|
+
}), b;
|
|
1417
|
+
} catch (w) {
|
|
1418
|
+
const F = O.phase, C = re(w), D = ve(w);
|
|
1419
|
+
throw B(
|
|
1420
|
+
D ? d.REJECTED : d.FAILED,
|
|
1442
1421
|
{
|
|
1443
|
-
error:
|
|
1444
|
-
parsedError: se(
|
|
1422
|
+
error: C,
|
|
1423
|
+
parsedError: se(w)
|
|
1445
1424
|
}
|
|
1446
|
-
),
|
|
1425
|
+
), F === d.WRAPPING ? I(() => L.onWrapError(w)) : F === d.APPROVING && I(() => L.onApproveError(w)), I(D ? r == null ? void 0 : r.onSubmitOrderRejected : () => {
|
|
1447
1426
|
var G;
|
|
1448
|
-
return (G = r == null ? void 0 : r.onSubmitOrderFailed) == null ? void 0 : G.call(r, se(
|
|
1449
|
-
}),
|
|
1427
|
+
return (G = r == null ? void 0 : r.onSubmitOrderFailed) == null ? void 0 : G.call(r, se(w));
|
|
1428
|
+
}), C;
|
|
1450
1429
|
}
|
|
1451
|
-
},
|
|
1452
|
-
const {
|
|
1453
|
-
inputToken:
|
|
1454
|
-
outputToken:
|
|
1455
|
-
wrappedNativeToken:
|
|
1456
|
-
chainId:
|
|
1457
|
-
|
|
1458
|
-
callbacks:
|
|
1459
|
-
account:
|
|
1460
|
-
walletInteractions:
|
|
1461
|
-
} = x(),
|
|
1430
|
+
}, _t = () => {
|
|
1431
|
+
const { data: e } = Y(), {
|
|
1432
|
+
inputToken: t,
|
|
1433
|
+
outputToken: n,
|
|
1434
|
+
wrappedNativeToken: r,
|
|
1435
|
+
chainId: i,
|
|
1436
|
+
hasChainId: o,
|
|
1437
|
+
callbacks: s,
|
|
1438
|
+
account: a,
|
|
1439
|
+
walletInteractions: c
|
|
1440
|
+
} = x(), h = It(), p = St(), u = W(), g = V();
|
|
1462
1441
|
return v(() => {
|
|
1463
|
-
|
|
1464
|
-
account:
|
|
1465
|
-
chainId:
|
|
1466
|
-
|
|
1467
|
-
inputToken:
|
|
1468
|
-
outputToken:
|
|
1469
|
-
wrappedNativeToken:
|
|
1442
|
+
Bt({
|
|
1443
|
+
account: a,
|
|
1444
|
+
chainId: i,
|
|
1445
|
+
hasChainId: o,
|
|
1446
|
+
inputToken: t,
|
|
1447
|
+
outputToken: n,
|
|
1448
|
+
wrappedNativeToken: r,
|
|
1470
1449
|
form: u,
|
|
1471
|
-
client:
|
|
1472
|
-
walletInteractions:
|
|
1473
|
-
callbacks:
|
|
1474
|
-
addNewOrder:
|
|
1475
|
-
refetchActiveOrders:
|
|
1476
|
-
getCurrentExecution: () =>
|
|
1477
|
-
beginExecution:
|
|
1478
|
-
replaceExecution:
|
|
1450
|
+
client: e,
|
|
1451
|
+
walletInteractions: c,
|
|
1452
|
+
callbacks: s,
|
|
1453
|
+
addNewOrder: h,
|
|
1454
|
+
refetchActiveOrders: p,
|
|
1455
|
+
getCurrentExecution: () => g.getState().state.currentExecution,
|
|
1456
|
+
beginExecution: g.getState().beginExecution,
|
|
1457
|
+
replaceExecution: g.getState().replaceExecution
|
|
1479
1458
|
}).catch(() => {
|
|
1480
1459
|
});
|
|
1481
1460
|
}, [
|
|
1461
|
+
a,
|
|
1462
|
+
h,
|
|
1482
1463
|
s,
|
|
1483
|
-
f,
|
|
1484
1464
|
i,
|
|
1485
|
-
r,
|
|
1486
|
-
c,
|
|
1487
|
-
u,
|
|
1488
1465
|
e,
|
|
1489
|
-
|
|
1466
|
+
u,
|
|
1490
1467
|
t,
|
|
1468
|
+
o,
|
|
1491
1469
|
n,
|
|
1492
|
-
|
|
1493
|
-
|
|
1494
|
-
|
|
1470
|
+
r,
|
|
1471
|
+
p,
|
|
1472
|
+
g,
|
|
1473
|
+
c
|
|
1495
1474
|
]);
|
|
1496
|
-
},
|
|
1497
|
-
const e =
|
|
1475
|
+
}, qt = () => {
|
|
1476
|
+
const e = A((n) => n.state.currentExecution), t = A(
|
|
1498
1477
|
(n) => n.returnToOrderForm
|
|
1499
1478
|
);
|
|
1500
|
-
return
|
|
1479
|
+
return R(
|
|
1501
1480
|
() => ({ ...e, returnToOrderForm: t }),
|
|
1502
1481
|
[e, t]
|
|
1503
1482
|
);
|
|
1504
|
-
},
|
|
1505
|
-
const e =
|
|
1483
|
+
}, ir = () => {
|
|
1484
|
+
const e = qt(), {
|
|
1506
1485
|
inputToken: t,
|
|
1507
1486
|
outputToken: n,
|
|
1508
1487
|
chainId: r,
|
|
1509
|
-
|
|
1510
|
-
module:
|
|
1488
|
+
hasChainId: i,
|
|
1489
|
+
module: o,
|
|
1511
1490
|
overrides: s
|
|
1512
|
-
} = x(), { data: a, isLoading: c } =
|
|
1513
|
-
() =>
|
|
1514
|
-
[
|
|
1515
|
-
),
|
|
1516
|
-
return
|
|
1491
|
+
} = x(), { data: a, isLoading: c } = Y(), h = _t(), p = A((y) => y.startNewOrder), u = v(() => h(), [h]), g = v(
|
|
1492
|
+
() => p(ye({ module: o, overrides: s })),
|
|
1493
|
+
[o, s, p]
|
|
1494
|
+
), E = et(e.phase), m = tt(e.phase), S = $(e.phase);
|
|
1495
|
+
return R(() => ({
|
|
1517
1496
|
phase: e.phase,
|
|
1518
|
-
status:
|
|
1497
|
+
status: E,
|
|
1519
1498
|
error: e.parsedError,
|
|
1520
1499
|
currentStep: m,
|
|
1521
1500
|
currentStepIndex: e.stepIndex,
|
|
@@ -1527,13 +1506,13 @@ const Et = ({
|
|
|
1527
1506
|
outputToken: e.outputToken ?? n,
|
|
1528
1507
|
chainId: e.chainId ?? r,
|
|
1529
1508
|
submitOrder: u,
|
|
1530
|
-
startNewOrder:
|
|
1509
|
+
startNewOrder: g,
|
|
1531
1510
|
returnToOrderForm: e.returnToOrderForm,
|
|
1532
1511
|
isExecuting: S,
|
|
1533
1512
|
isSuccess: e.phase === d.SUCCESS,
|
|
1534
1513
|
isFailed: e.phase === d.FAILED,
|
|
1535
1514
|
isRejected: e.phase === d.REJECTED,
|
|
1536
|
-
isPreparingOrder: e.phase === d.PREPARING ||
|
|
1515
|
+
isPreparingOrder: e.phase === d.PREPARING || i && c && !a,
|
|
1537
1516
|
canDismiss: !S
|
|
1538
1517
|
}), [
|
|
1539
1518
|
a,
|
|
@@ -1543,76 +1522,76 @@ const Et = ({
|
|
|
1543
1522
|
r,
|
|
1544
1523
|
c,
|
|
1545
1524
|
S,
|
|
1546
|
-
|
|
1547
|
-
|
|
1525
|
+
i,
|
|
1526
|
+
g,
|
|
1548
1527
|
u,
|
|
1549
|
-
|
|
1528
|
+
E,
|
|
1550
1529
|
e
|
|
1551
1530
|
]);
|
|
1552
|
-
},
|
|
1531
|
+
}, or = () => {
|
|
1553
1532
|
const {
|
|
1554
1533
|
inputToken: e,
|
|
1555
1534
|
outputToken: t,
|
|
1556
1535
|
wrappedNativeToken: n,
|
|
1557
1536
|
inputBalanceRaw: r,
|
|
1558
|
-
noLiquidity:
|
|
1559
|
-
inputAmountUi:
|
|
1537
|
+
noLiquidity: i,
|
|
1538
|
+
inputAmountUi: o,
|
|
1560
1539
|
marketPriceLoading: s,
|
|
1561
|
-
|
|
1562
|
-
} = x(), c = W(), { data:
|
|
1540
|
+
hasChainId: a
|
|
1541
|
+
} = x(), c = W(), { data: h, isLoading: p } = Y(), u = A(
|
|
1563
1542
|
(T) => T.state.currentExecution.phase
|
|
1564
|
-
),
|
|
1565
|
-
return
|
|
1566
|
-
disabled:
|
|
1543
|
+
), g = $(u), E = !!(e && Q(e.address) && (!n || Q(n.address))), m = s || !c.isReady || r === void 0, S = g || a && p && !h || !!(e && t && o && m), y = !!(!c.canSubmit || g || !a || !h || i || S || !e || !t || E);
|
|
1544
|
+
return R(() => ({
|
|
1545
|
+
disabled: y,
|
|
1567
1546
|
loading: S
|
|
1568
|
-
}), [
|
|
1569
|
-
},
|
|
1570
|
-
const { inputToken: e, outputToken: t, callbacks: n } = x(), r =
|
|
1547
|
+
}), [y, S]);
|
|
1548
|
+
}, sr = () => {
|
|
1549
|
+
const { inputToken: e, outputToken: t, callbacks: n } = x(), r = A((s) => s.updateState), { trades: i } = W(), o = v(
|
|
1571
1550
|
(s) => {
|
|
1572
|
-
r({ tradeCount: s }),
|
|
1551
|
+
r({ tradeCount: s }), I(() => {
|
|
1573
1552
|
var a;
|
|
1574
1553
|
return (a = n == null ? void 0 : n.onTradeCountChange) == null ? void 0 : a.call(n, s);
|
|
1575
1554
|
});
|
|
1576
1555
|
},
|
|
1577
1556
|
[n, r]
|
|
1578
1557
|
);
|
|
1579
|
-
return
|
|
1558
|
+
return R(
|
|
1580
1559
|
() => ({
|
|
1581
|
-
totalTrades:
|
|
1582
|
-
maxTrades:
|
|
1583
|
-
inputAmountPerTrade:
|
|
1584
|
-
minOutputAmountPerTrade:
|
|
1585
|
-
triggerOutputAmountPerTrade:
|
|
1586
|
-
onChange:
|
|
1587
|
-
error:
|
|
1560
|
+
totalTrades: i.totalTrades,
|
|
1561
|
+
maxTrades: i.maxTrades,
|
|
1562
|
+
inputAmountPerTrade: i.inputAmountPerTrade,
|
|
1563
|
+
minOutputAmountPerTrade: i.minOutputAmountPerTrade,
|
|
1564
|
+
triggerOutputAmountPerTrade: i.triggerOutputAmountPerTrade,
|
|
1565
|
+
onChange: o,
|
|
1566
|
+
error: i.error,
|
|
1588
1567
|
inputToken: e,
|
|
1589
1568
|
outputToken: t
|
|
1590
1569
|
}),
|
|
1591
|
-
[e,
|
|
1570
|
+
[e, o, t, i]
|
|
1592
1571
|
);
|
|
1593
|
-
},
|
|
1594
|
-
const { marketPriceLoading: e, inputToken: t, outputToken: n, callbacks: r } = x(), { marketPrice:
|
|
1595
|
-
(
|
|
1596
|
-
c({ triggerPriceUi:
|
|
1597
|
-
var
|
|
1598
|
-
return (
|
|
1599
|
-
}),
|
|
1600
|
-
var
|
|
1601
|
-
return (
|
|
1572
|
+
}, ar = () => {
|
|
1573
|
+
const { marketPriceLoading: e, inputToken: t, outputToken: n, callbacks: r } = x(), { marketPrice: i, trades: o, triggerPrice: s, isInverted: a } = W(), c = A((g) => g.updateState), h = v(
|
|
1574
|
+
(g) => {
|
|
1575
|
+
c({ triggerPriceUi: g, triggerPricePercent: null }), I(() => {
|
|
1576
|
+
var E;
|
|
1577
|
+
return (E = r == null ? void 0 : r.onTriggerPriceChange) == null ? void 0 : E.call(r, g || "");
|
|
1578
|
+
}), I(() => {
|
|
1579
|
+
var E;
|
|
1580
|
+
return (E = r == null ? void 0 : r.onTriggerPricePercentChange) == null ? void 0 : E.call(r, "");
|
|
1602
1581
|
});
|
|
1603
1582
|
},
|
|
1604
1583
|
[r, c]
|
|
1605
|
-
),
|
|
1606
|
-
(
|
|
1584
|
+
), p = v(
|
|
1585
|
+
(g) => {
|
|
1607
1586
|
c({
|
|
1608
1587
|
triggerPriceUi: void 0,
|
|
1609
|
-
triggerPricePercent:
|
|
1610
|
-
}),
|
|
1611
|
-
var
|
|
1612
|
-
return (
|
|
1613
|
-
}),
|
|
1614
|
-
var
|
|
1615
|
-
return (
|
|
1588
|
+
triggerPricePercent: g
|
|
1589
|
+
}), I(() => {
|
|
1590
|
+
var E;
|
|
1591
|
+
return (E = r == null ? void 0 : r.onTriggerPriceChange) == null ? void 0 : E.call(r, "");
|
|
1592
|
+
}), I(() => {
|
|
1593
|
+
var E;
|
|
1594
|
+
return (E = r == null ? void 0 : r.onTriggerPricePercentChange) == null ? void 0 : E.call(r, g || "");
|
|
1616
1595
|
});
|
|
1617
1596
|
},
|
|
1618
1597
|
[r, c]
|
|
@@ -1622,87 +1601,84 @@ const Et = ({
|
|
|
1622
1601
|
triggerPriceUi: void 0
|
|
1623
1602
|
});
|
|
1624
1603
|
}, [c]);
|
|
1625
|
-
return
|
|
1604
|
+
return R(
|
|
1626
1605
|
() => ({
|
|
1627
1606
|
price: s.display,
|
|
1628
1607
|
canonicalPriceRaw: s.raw,
|
|
1629
|
-
outputAmountPerTrade:
|
|
1608
|
+
outputAmountPerTrade: o.triggerOutputAmountPerTrade,
|
|
1630
1609
|
error: s.error,
|
|
1631
|
-
onInputChange:
|
|
1632
|
-
onPercentageChange:
|
|
1610
|
+
onInputChange: h,
|
|
1611
|
+
onPercentageChange: p,
|
|
1633
1612
|
percentage: s.percentage,
|
|
1634
1613
|
onReset: u,
|
|
1635
1614
|
inputToken: t,
|
|
1636
1615
|
outputToken: n,
|
|
1637
1616
|
displayInputToken: a ? n : t,
|
|
1638
1617
|
displayOutputToken: a ? t : n,
|
|
1639
|
-
isLoading: !!(e || !
|
|
1618
|
+
isLoading: !!(e || !i.raw),
|
|
1640
1619
|
isTypedValue: s.isTypedValue
|
|
1641
1620
|
}),
|
|
1642
1621
|
[
|
|
1643
1622
|
t,
|
|
1644
1623
|
a,
|
|
1645
|
-
|
|
1624
|
+
i.raw,
|
|
1646
1625
|
e,
|
|
1647
|
-
|
|
1648
|
-
|
|
1626
|
+
h,
|
|
1627
|
+
p,
|
|
1649
1628
|
u,
|
|
1650
1629
|
n,
|
|
1651
|
-
|
|
1630
|
+
o.triggerOutputAmountPerTrade,
|
|
1652
1631
|
s
|
|
1653
1632
|
]
|
|
1654
1633
|
);
|
|
1655
1634
|
};
|
|
1656
|
-
|
|
1635
|
+
We(Qe.version);
|
|
1657
1636
|
export {
|
|
1658
|
-
|
|
1659
|
-
|
|
1637
|
+
ur as DISCLAIMER_URL,
|
|
1638
|
+
ee as Disclaimer,
|
|
1660
1639
|
d as ExecutionPhase,
|
|
1661
1640
|
q as ExecutionStatus,
|
|
1662
|
-
|
|
1663
|
-
|
|
1664
|
-
|
|
1665
|
-
|
|
1666
|
-
|
|
1667
|
-
|
|
1668
|
-
|
|
1669
|
-
|
|
1670
|
-
|
|
1671
|
-
|
|
1672
|
-
|
|
1673
|
-
|
|
1674
|
-
|
|
1675
|
-
|
|
1676
|
-
|
|
1677
|
-
|
|
1678
|
-
|
|
1679
|
-
|
|
1680
|
-
|
|
1681
|
-
Cr as getOrderLimitPriceRate,
|
|
1682
|
-
Rr as getPartnerChains,
|
|
1683
|
-
yr as getPartners,
|
|
1641
|
+
lr as InputErrors,
|
|
1642
|
+
mr as Module,
|
|
1643
|
+
gr as ORBS_LOGO,
|
|
1644
|
+
Pr as ORBS_SLTP_FAQ_URL,
|
|
1645
|
+
fr as ORBS_TWAP_FAQ_URL,
|
|
1646
|
+
hr as ORBS_WEBSITE_URL,
|
|
1647
|
+
Er as OrderFilter,
|
|
1648
|
+
Ir as OrderStatus,
|
|
1649
|
+
Sr as OrderType,
|
|
1650
|
+
Or as Partners,
|
|
1651
|
+
$t as SpotProvider,
|
|
1652
|
+
z as Steps,
|
|
1653
|
+
pr as TimeUnit,
|
|
1654
|
+
Ar as calculateOrderForm,
|
|
1655
|
+
vr as createClient,
|
|
1656
|
+
wr as eqIgnoreCase,
|
|
1657
|
+
Cr as getOrderExecutionRate,
|
|
1658
|
+
yr as getOrderFillDelayMillis,
|
|
1659
|
+
Rr as getOrderLimitPriceRate,
|
|
1684
1660
|
Tr as getTriggerPriceRate,
|
|
1685
1661
|
Nr as getTwapConfig,
|
|
1686
1662
|
Lr as invertPriceInput,
|
|
1687
|
-
|
|
1688
|
-
|
|
1663
|
+
xr as isNativeAddress,
|
|
1664
|
+
Fr as isTxRejected,
|
|
1689
1665
|
Ur as toAmountRaw,
|
|
1690
1666
|
Dr as toAmountUI,
|
|
1691
|
-
|
|
1692
|
-
|
|
1693
|
-
|
|
1694
|
-
|
|
1695
|
-
|
|
1696
|
-
|
|
1697
|
-
|
|
1698
|
-
|
|
1699
|
-
|
|
1700
|
-
|
|
1667
|
+
Qt as useAmountUi,
|
|
1668
|
+
Yt as useCancelOrder,
|
|
1669
|
+
Y as useClient,
|
|
1670
|
+
Xt as useDisclaimer,
|
|
1671
|
+
Zt as useDuration,
|
|
1672
|
+
ir as useExecution,
|
|
1673
|
+
bt as useFillDelay,
|
|
1674
|
+
kt as useHistoryOrder,
|
|
1675
|
+
er as useInputErrors,
|
|
1676
|
+
tr as useLimitPrice,
|
|
1701
1677
|
W as useOrderForm,
|
|
1702
1678
|
zt as useOrders,
|
|
1703
|
-
|
|
1704
|
-
|
|
1705
|
-
|
|
1706
|
-
|
|
1707
|
-
|
|
1679
|
+
rr as useOutputAmount,
|
|
1680
|
+
nr as usePriceDisplay,
|
|
1681
|
+
or as useSubmitButton,
|
|
1682
|
+
sr as useTrades,
|
|
1683
|
+
ar as useTriggerPrice
|
|
1708
1684
|
};
|