@proton/wrap-constants 0.2.193 → 0.3.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/index.cjs +2718 -0
- package/dist/index.d.cts +2579 -0
- package/dist/index.d.mts +2056 -12748
- package/dist/index.mjs +2522 -2757
- package/package.json +39 -19
- package/dist/index.d.ts +0 -13271
- package/dist/index.js +0 -2957
- package/src/coins.ts +0 -1632
- package/src/constants.ts +0 -202
- package/src/graph.ts +0 -126
- package/src/index.ts +0 -6
- package/src/math.ts +0 -147
- package/src/parsers/actions.ts +0 -82
- package/src/parsers/address.ts +0 -27
- package/src/parsers/auth.ts +0 -36
- package/src/parsers/base.ts +0 -24
- package/src/parsers/currency.ts +0 -89
- package/src/parsers/deposit.ts +0 -37
- package/src/parsers/dex.ts +0 -769
- package/src/parsers/index.ts +0 -13
- package/src/parsers/login.ts +0 -9
- package/src/parsers/otc.ts +0 -23
- package/src/parsers/pool.ts +0 -53
- package/src/parsers/withdraw.ts +0 -39
- package/src/parsers/withdrawalHistory.ts +0 -23
- package/src/parsers/wrap.ts +0 -41
- package/src/utils.ts +0 -22
package/dist/index.d.cts
ADDED
|
@@ -0,0 +1,2579 @@
|
|
|
1
|
+
import { Asset, ExtendedAsset as ExtendedAsset$1 } from "@bloks/numbers";
|
|
2
|
+
import * as z from "zod";
|
|
3
|
+
import BN from "bignumber.js";
|
|
4
|
+
declare enum Chains {
|
|
5
|
+
BitcoinMainnet = "Bitcoin",
|
|
6
|
+
BitcoinTestnet = "Bitcoin (Testnet)",
|
|
7
|
+
EthereumMainnet = "Ethereum",
|
|
8
|
+
EthereumSepolia = "Ethereum (Sepolia)",
|
|
9
|
+
LitecoinMainnet = "Litecoin",
|
|
10
|
+
LitecoinTestnet = "Litecoin (Testnet)",
|
|
11
|
+
BitcoinCashMainnet = "Bitcoin Cash",
|
|
12
|
+
BitcoinCashTestnet = "Bitcoin Cash (Testnet)",
|
|
13
|
+
StellarMainnet = "Stellar",
|
|
14
|
+
StellarTestnet = "Stellar (Testnet)",
|
|
15
|
+
ProtonMainnet = "Proton",
|
|
16
|
+
ProtonTestnet = "Proton (Testnet)",
|
|
17
|
+
PolkadotMainnet = "Polkadot",
|
|
18
|
+
BinanceBEP2 = "Binance (BEP2)",
|
|
19
|
+
BinanceBEP20 = "Binance (BEP20)",
|
|
20
|
+
EosMainnet = "EOS",
|
|
21
|
+
EosTestnet = "EOS (Jungle Testnet)",
|
|
22
|
+
HederaMainnet = "Hedera (Mainnet)",
|
|
23
|
+
HederaTestnet = "Hedera (Testnet)",
|
|
24
|
+
DogeMainnet = "Dogecoin",
|
|
25
|
+
CardanoMainnet = "Cardano",
|
|
26
|
+
AvalancheXChain = "Avalanche X-Chain",
|
|
27
|
+
AvalancheCChain = "Avalanche C-Chain",
|
|
28
|
+
PolygonMainnet = "Polygon",
|
|
29
|
+
TerraMainnet = "Terra",
|
|
30
|
+
RippleMainnet = "Ripple",
|
|
31
|
+
SolanaMainnet = "Solana",
|
|
32
|
+
XDCMainnet = "XDC Network",
|
|
33
|
+
MetalXTestnet = "Metal X-Chain (Testnet)",
|
|
34
|
+
MetalCTestnet = "Metal C-Chain (Testnet)",
|
|
35
|
+
MetalCMainnet = "Metal C-Chain",
|
|
36
|
+
MetalL2Mainnet = "Metal L2",
|
|
37
|
+
MetalL2Testnet = "Metal L2 (Testnet)"
|
|
38
|
+
}
|
|
39
|
+
declare enum Networks {
|
|
40
|
+
Mainnet = "mainnet",
|
|
41
|
+
Testnet = "testnet",
|
|
42
|
+
ERC20 = "erc20",
|
|
43
|
+
BEP20 = "bep20",
|
|
44
|
+
XLM = "xlm",
|
|
45
|
+
AVM = "avm",
|
|
46
|
+
EVM = "evm",
|
|
47
|
+
METALL2 = "metall2",
|
|
48
|
+
Sepolia = "sepolia"
|
|
49
|
+
}
|
|
50
|
+
declare const similarChains: {
|
|
51
|
+
Ethereum: Chains[];
|
|
52
|
+
"Binance (BEP20)": Chains[];
|
|
53
|
+
};
|
|
54
|
+
interface Coin {
|
|
55
|
+
allowSwap: boolean;
|
|
56
|
+
allowBridge: boolean;
|
|
57
|
+
allowLend: boolean;
|
|
58
|
+
allowBorrow: boolean;
|
|
59
|
+
name: string;
|
|
60
|
+
coin: string;
|
|
61
|
+
xtokenSymbol: string;
|
|
62
|
+
xtokenPrecision: number;
|
|
63
|
+
xtokenContract: string;
|
|
64
|
+
wallets: Wallet[];
|
|
65
|
+
image: string;
|
|
66
|
+
coingeckoId: string;
|
|
67
|
+
unifiedCryptoassetId: string;
|
|
68
|
+
balance?: Asset;
|
|
69
|
+
}
|
|
70
|
+
interface Wallet {
|
|
71
|
+
wallet: string;
|
|
72
|
+
symbol: string;
|
|
73
|
+
chain: Chains;
|
|
74
|
+
network: Networks;
|
|
75
|
+
precision: number;
|
|
76
|
+
contract: string | undefined;
|
|
77
|
+
provider: string;
|
|
78
|
+
hasWithdrawMemo: boolean;
|
|
79
|
+
}
|
|
80
|
+
declare enum Providers {
|
|
81
|
+
FIREBLOCKS = "fireblocks",
|
|
82
|
+
METAL = "metal",
|
|
83
|
+
METALL2 = "metall2"
|
|
84
|
+
}
|
|
85
|
+
type CoinWallet = Exclude<Coin, "wallets"> & Wallet;
|
|
86
|
+
declare const explorerLinkByChain: {
|
|
87
|
+
Bitcoin: (txid: string) => string;
|
|
88
|
+
"Bitcoin (Testnet)": (txid: string) => string;
|
|
89
|
+
Ethereum: (txid: string) => string;
|
|
90
|
+
"Ethereum (Sepolia)": (txid: string) => string;
|
|
91
|
+
Litecoin: (txid: string) => string;
|
|
92
|
+
"Litecoin (Testnet)": (txid: string) => string;
|
|
93
|
+
"Bitcoin Cash": (txid: string) => string;
|
|
94
|
+
"Bitcoin Cash (Testnet)": (txid: string) => string;
|
|
95
|
+
Stellar: (txid: string) => string;
|
|
96
|
+
"Stellar (Testnet)": (txid: string) => string;
|
|
97
|
+
Proton: (txid: string, traces?: boolean) => string;
|
|
98
|
+
"Proton (Testnet)": (txid: string, traces?: boolean) => string;
|
|
99
|
+
Polkadot: (txid: string) => string;
|
|
100
|
+
"Binance (BEP2)": (txid: string) => string;
|
|
101
|
+
"Binance (BEP20)": (txid: string) => string;
|
|
102
|
+
EOS: (txid: string) => string;
|
|
103
|
+
"EOS (Jungle Testnet)": (txid: string) => string;
|
|
104
|
+
"Hedera (Mainnet)": (txid: string) => string;
|
|
105
|
+
"Hedera (Testnet)": (txid: string) => string;
|
|
106
|
+
Dogecoin: (txid: string) => string;
|
|
107
|
+
Cardano: (txid: string) => string;
|
|
108
|
+
"Avalanche X-Chain": (txid: string) => string;
|
|
109
|
+
"Avalanche C-Chain": (txid: string) => string;
|
|
110
|
+
Polygon: (txid: string) => string;
|
|
111
|
+
Terra: (txid: string) => string;
|
|
112
|
+
Ripple: (txid: string) => string;
|
|
113
|
+
Solana: (txid: string) => string;
|
|
114
|
+
"Metal X-Chain (Testnet)": (txid: string) => string;
|
|
115
|
+
"Metal C-Chain (Testnet)": (txid: string) => string;
|
|
116
|
+
"Metal C-Chain": (txid: string) => string;
|
|
117
|
+
"XDC Network": (txid: string) => string;
|
|
118
|
+
"Metal L2 (Testnet)": (txid: string) => string;
|
|
119
|
+
"Metal L2": (txid: string) => string;
|
|
120
|
+
};
|
|
121
|
+
declare const protonExplorerTxUrl: (chain: string, txId: string, traces?: boolean) => string;
|
|
122
|
+
declare const initializeCoins: (protonChain: string) => {
|
|
123
|
+
allCoins: Coin[];
|
|
124
|
+
swapCoins: Coin[];
|
|
125
|
+
bridgeCoins: Coin[];
|
|
126
|
+
lendCoins: Coin[];
|
|
127
|
+
borrowCoins: Coin[];
|
|
128
|
+
loanCoins: Coin[];
|
|
129
|
+
allEnabledCoins: Coin[];
|
|
130
|
+
};
|
|
131
|
+
declare const baseActionParser: <T extends z.ZodRawShape>(contract: string, action: string, data: T) => z.ZodObject<{
|
|
132
|
+
account: z.ZodString | z.ZodLiteral<string>;
|
|
133
|
+
name: z.ZodLiteral<string>;
|
|
134
|
+
data: z.ZodObject<{ -readonly [P in keyof T]: T[P]; }, z.core.$strip>;
|
|
135
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
136
|
+
actor: z.ZodString;
|
|
137
|
+
permission: z.ZodString;
|
|
138
|
+
}, z.core.$strip>>;
|
|
139
|
+
}, z.core.$strip>;
|
|
140
|
+
declare const baseActionSerializedParser: <T extends z.ZodRawShape>(contract: string, action: string, data: T) => z.ZodObject<{
|
|
141
|
+
account: z.ZodString | z.ZodLiteral<string>;
|
|
142
|
+
name: z.ZodLiteral<string>;
|
|
143
|
+
data: z.ZodUnion<[z.ZodString, z.ZodObject<{ -readonly [P in keyof T]: T[P]; }, z.core.$strip>]>;
|
|
144
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
145
|
+
actor: z.ZodString;
|
|
146
|
+
permission: z.ZodString;
|
|
147
|
+
}, z.core.$strip>>;
|
|
148
|
+
}, z.core.$strip>;
|
|
149
|
+
declare const webauthActionParser: <T extends z.ZodRawShape>(contract: string, action: string, data: T) => z.ZodObject<{
|
|
150
|
+
account: z.ZodLiteral<"webauthn">;
|
|
151
|
+
name: z.ZodLiteral<"exec">;
|
|
152
|
+
data: z.ZodObject<{
|
|
153
|
+
account: z.ZodString;
|
|
154
|
+
key: z.ZodObject<{
|
|
155
|
+
key: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
|
|
156
|
+
modulus: z.ZodString;
|
|
157
|
+
exponent: z.ZodString;
|
|
158
|
+
}, z.core.$strip>]>>;
|
|
159
|
+
user_presence: z.ZodNumber;
|
|
160
|
+
rpid: z.ZodString;
|
|
161
|
+
}, z.core.$strip>;
|
|
162
|
+
nonce: z.ZodNumber;
|
|
163
|
+
permissions: z.ZodArray<z.ZodObject<{
|
|
164
|
+
actor: z.ZodString;
|
|
165
|
+
permission: z.ZodString;
|
|
166
|
+
}, z.core.$strip>>;
|
|
167
|
+
signature: z.ZodObject<{
|
|
168
|
+
auth_data: z.ZodString;
|
|
169
|
+
client_json: z.ZodString;
|
|
170
|
+
signature: z.ZodString;
|
|
171
|
+
}, z.core.$strip>;
|
|
172
|
+
trx: z.ZodObject<{
|
|
173
|
+
expiration: z.ZodString;
|
|
174
|
+
ref_block_num: z.ZodNumber;
|
|
175
|
+
ref_block_prefix: z.ZodNumber;
|
|
176
|
+
max_net_usage_words: z.ZodNumber;
|
|
177
|
+
max_cpu_usage_ms: z.ZodNumber;
|
|
178
|
+
delay_sec: z.ZodNumber;
|
|
179
|
+
context_free_actions: z.ZodArray<z.ZodObject<{
|
|
180
|
+
account: z.ZodString;
|
|
181
|
+
name: z.ZodString;
|
|
182
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
183
|
+
actor: z.ZodString;
|
|
184
|
+
permission: z.ZodString;
|
|
185
|
+
}, z.core.$strip>>;
|
|
186
|
+
data: z.ZodAny;
|
|
187
|
+
hex_data: z.ZodOptional<z.ZodString>;
|
|
188
|
+
}, z.core.$strip>>;
|
|
189
|
+
transaction_extensions: z.ZodArray<z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString]>>>>;
|
|
190
|
+
actions: z.ZodArray<z.ZodObject<{
|
|
191
|
+
account: z.ZodString | z.ZodLiteral<string>;
|
|
192
|
+
name: z.ZodLiteral<string>;
|
|
193
|
+
data: z.ZodUnion<[z.ZodString, z.ZodObject<{ -readonly [P in keyof T]: T[P]; }, z.core.$strip>]>;
|
|
194
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
195
|
+
actor: z.ZodString;
|
|
196
|
+
permission: z.ZodString;
|
|
197
|
+
}, z.core.$strip>>;
|
|
198
|
+
}, z.core.$strip>>;
|
|
199
|
+
}, z.core.$strip>;
|
|
200
|
+
}, z.core.$strip>;
|
|
201
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
202
|
+
actor: z.ZodString;
|
|
203
|
+
permission: z.ZodString;
|
|
204
|
+
}, z.core.$strip>>;
|
|
205
|
+
}, z.core.$strip>;
|
|
206
|
+
declare const singleActionTransactionParser: <T extends z.ZodRawShape>(contract: string, action: string, data: T) => z.ZodObject<{
|
|
207
|
+
expiration: z.ZodString;
|
|
208
|
+
ref_block_num: z.ZodNumber;
|
|
209
|
+
ref_block_prefix: z.ZodNumber;
|
|
210
|
+
max_net_usage_words: z.ZodNumber;
|
|
211
|
+
max_cpu_usage_ms: z.ZodNumber;
|
|
212
|
+
delay_sec: z.ZodNumber;
|
|
213
|
+
context_free_actions: z.ZodArray<z.ZodObject<{
|
|
214
|
+
account: z.ZodString;
|
|
215
|
+
name: z.ZodString;
|
|
216
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
217
|
+
actor: z.ZodString;
|
|
218
|
+
permission: z.ZodString;
|
|
219
|
+
}, z.core.$strip>>;
|
|
220
|
+
data: z.ZodAny;
|
|
221
|
+
hex_data: z.ZodOptional<z.ZodString>;
|
|
222
|
+
}, z.core.$strip>>;
|
|
223
|
+
transaction_extensions: z.ZodArray<z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString]>>>>;
|
|
224
|
+
actions: z.ZodArray<z.ZodUnion<[z.ZodObject<{
|
|
225
|
+
account: z.ZodString | z.ZodLiteral<string>;
|
|
226
|
+
name: z.ZodLiteral<string>;
|
|
227
|
+
data: z.ZodObject<{ -readonly [P in keyof T]: T[P]; }, z.core.$strip>;
|
|
228
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
229
|
+
actor: z.ZodString;
|
|
230
|
+
permission: z.ZodString;
|
|
231
|
+
}, z.core.$strip>>;
|
|
232
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
233
|
+
account: z.ZodLiteral<"webauthn">;
|
|
234
|
+
name: z.ZodLiteral<"exec">;
|
|
235
|
+
data: z.ZodObject<{
|
|
236
|
+
account: z.ZodString;
|
|
237
|
+
key: z.ZodObject<{
|
|
238
|
+
key: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
|
|
239
|
+
modulus: z.ZodString;
|
|
240
|
+
exponent: z.ZodString;
|
|
241
|
+
}, z.core.$strip>]>>;
|
|
242
|
+
user_presence: z.ZodNumber;
|
|
243
|
+
rpid: z.ZodString;
|
|
244
|
+
}, z.core.$strip>;
|
|
245
|
+
nonce: z.ZodNumber;
|
|
246
|
+
permissions: z.ZodArray<z.ZodObject<{
|
|
247
|
+
actor: z.ZodString;
|
|
248
|
+
permission: z.ZodString;
|
|
249
|
+
}, z.core.$strip>>;
|
|
250
|
+
signature: z.ZodObject<{
|
|
251
|
+
auth_data: z.ZodString;
|
|
252
|
+
client_json: z.ZodString;
|
|
253
|
+
signature: z.ZodString;
|
|
254
|
+
}, z.core.$strip>;
|
|
255
|
+
trx: z.ZodObject<{
|
|
256
|
+
expiration: z.ZodString;
|
|
257
|
+
ref_block_num: z.ZodNumber;
|
|
258
|
+
ref_block_prefix: z.ZodNumber;
|
|
259
|
+
max_net_usage_words: z.ZodNumber;
|
|
260
|
+
max_cpu_usage_ms: z.ZodNumber;
|
|
261
|
+
delay_sec: z.ZodNumber;
|
|
262
|
+
context_free_actions: z.ZodArray<z.ZodObject<{
|
|
263
|
+
account: z.ZodString;
|
|
264
|
+
name: z.ZodString;
|
|
265
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
266
|
+
actor: z.ZodString;
|
|
267
|
+
permission: z.ZodString;
|
|
268
|
+
}, z.core.$strip>>;
|
|
269
|
+
data: z.ZodAny;
|
|
270
|
+
hex_data: z.ZodOptional<z.ZodString>;
|
|
271
|
+
}, z.core.$strip>>;
|
|
272
|
+
transaction_extensions: z.ZodArray<z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString]>>>>;
|
|
273
|
+
actions: z.ZodArray<z.ZodObject<{
|
|
274
|
+
account: z.ZodString | z.ZodLiteral<string>;
|
|
275
|
+
name: z.ZodLiteral<string>;
|
|
276
|
+
data: z.ZodUnion<[z.ZodString, z.ZodObject<{ -readonly [P in keyof T]: T[P]; }, z.core.$strip>]>;
|
|
277
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
278
|
+
actor: z.ZodString;
|
|
279
|
+
permission: z.ZodString;
|
|
280
|
+
}, z.core.$strip>>;
|
|
281
|
+
}, z.core.$strip>>;
|
|
282
|
+
}, z.core.$strip>;
|
|
283
|
+
}, z.core.$strip>;
|
|
284
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
285
|
+
actor: z.ZodString;
|
|
286
|
+
permission: z.ZodString;
|
|
287
|
+
}, z.core.$strip>>;
|
|
288
|
+
}, z.core.$strip>]>>;
|
|
289
|
+
}, z.core.$strip>;
|
|
290
|
+
declare const addressParser: z.ZodObject<{
|
|
291
|
+
index: z.ZodNumber;
|
|
292
|
+
account: z.ZodString;
|
|
293
|
+
chain: z.ZodString;
|
|
294
|
+
address: z.ZodString;
|
|
295
|
+
address_hash: z.ZodString;
|
|
296
|
+
}, z.core.$strip>;
|
|
297
|
+
type Address = z.infer<typeof addressParser>;
|
|
298
|
+
declare const generateAddressBodyParser: z.ZodObject<{
|
|
299
|
+
signer: z.ZodObject<{
|
|
300
|
+
actor: z.ZodString;
|
|
301
|
+
permission: z.ZodString;
|
|
302
|
+
}, z.core.$strip>;
|
|
303
|
+
signatures: z.ZodArray<z.ZodString>;
|
|
304
|
+
transaction: z.ZodObject<{
|
|
305
|
+
expiration: z.ZodString;
|
|
306
|
+
ref_block_num: z.ZodNumber;
|
|
307
|
+
ref_block_prefix: z.ZodNumber;
|
|
308
|
+
max_net_usage_words: z.ZodNumber;
|
|
309
|
+
max_cpu_usage_ms: z.ZodNumber;
|
|
310
|
+
delay_sec: z.ZodNumber;
|
|
311
|
+
context_free_actions: z.ZodArray<z.ZodObject<{
|
|
312
|
+
account: z.ZodString;
|
|
313
|
+
name: z.ZodString;
|
|
314
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
315
|
+
actor: z.ZodString;
|
|
316
|
+
permission: z.ZodString;
|
|
317
|
+
}, z.core.$strip>>;
|
|
318
|
+
data: z.ZodAny;
|
|
319
|
+
hex_data: z.ZodOptional<z.ZodString>;
|
|
320
|
+
}, z.core.$strip>>;
|
|
321
|
+
transaction_extensions: z.ZodArray<z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString]>>>>;
|
|
322
|
+
actions: z.ZodArray<z.ZodUnion<[z.ZodObject<{
|
|
323
|
+
account: z.ZodString | z.ZodLiteral<string>;
|
|
324
|
+
name: z.ZodLiteral<string>;
|
|
325
|
+
data: z.ZodObject<{
|
|
326
|
+
[x: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
|
|
327
|
+
}, z.core.$strip>;
|
|
328
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
329
|
+
actor: z.ZodString;
|
|
330
|
+
permission: z.ZodString;
|
|
331
|
+
}, z.core.$strip>>;
|
|
332
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
333
|
+
account: z.ZodLiteral<"webauthn">;
|
|
334
|
+
name: z.ZodLiteral<"exec">;
|
|
335
|
+
data: z.ZodObject<{
|
|
336
|
+
account: z.ZodString;
|
|
337
|
+
key: z.ZodObject<{
|
|
338
|
+
key: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
|
|
339
|
+
modulus: z.ZodString;
|
|
340
|
+
exponent: z.ZodString;
|
|
341
|
+
}, z.core.$strip>]>>;
|
|
342
|
+
user_presence: z.ZodNumber;
|
|
343
|
+
rpid: z.ZodString;
|
|
344
|
+
}, z.core.$strip>;
|
|
345
|
+
nonce: z.ZodNumber;
|
|
346
|
+
permissions: z.ZodArray<z.ZodObject<{
|
|
347
|
+
actor: z.ZodString;
|
|
348
|
+
permission: z.ZodString;
|
|
349
|
+
}, z.core.$strip>>;
|
|
350
|
+
signature: z.ZodObject<{
|
|
351
|
+
auth_data: z.ZodString;
|
|
352
|
+
client_json: z.ZodString;
|
|
353
|
+
signature: z.ZodString;
|
|
354
|
+
}, z.core.$strip>;
|
|
355
|
+
trx: z.ZodObject<{
|
|
356
|
+
expiration: z.ZodString;
|
|
357
|
+
ref_block_num: z.ZodNumber;
|
|
358
|
+
ref_block_prefix: z.ZodNumber;
|
|
359
|
+
max_net_usage_words: z.ZodNumber;
|
|
360
|
+
max_cpu_usage_ms: z.ZodNumber;
|
|
361
|
+
delay_sec: z.ZodNumber;
|
|
362
|
+
context_free_actions: z.ZodArray<z.ZodObject<{
|
|
363
|
+
account: z.ZodString;
|
|
364
|
+
name: z.ZodString;
|
|
365
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
366
|
+
actor: z.ZodString;
|
|
367
|
+
permission: z.ZodString;
|
|
368
|
+
}, z.core.$strip>>;
|
|
369
|
+
data: z.ZodAny;
|
|
370
|
+
hex_data: z.ZodOptional<z.ZodString>;
|
|
371
|
+
}, z.core.$strip>>;
|
|
372
|
+
transaction_extensions: z.ZodArray<z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString]>>>>;
|
|
373
|
+
actions: z.ZodArray<z.ZodObject<{
|
|
374
|
+
account: z.ZodString | z.ZodLiteral<string>;
|
|
375
|
+
name: z.ZodLiteral<string>;
|
|
376
|
+
data: z.ZodUnion<[z.ZodString, z.ZodObject<{
|
|
377
|
+
[x: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
|
|
378
|
+
}, z.core.$strip>]>;
|
|
379
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
380
|
+
actor: z.ZodString;
|
|
381
|
+
permission: z.ZodString;
|
|
382
|
+
}, z.core.$strip>>;
|
|
383
|
+
}, z.core.$strip>>;
|
|
384
|
+
}, z.core.$strip>;
|
|
385
|
+
}, z.core.$strip>;
|
|
386
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
387
|
+
actor: z.ZodString;
|
|
388
|
+
permission: z.ZodString;
|
|
389
|
+
}, z.core.$strip>>;
|
|
390
|
+
}, z.core.$strip>]>>;
|
|
391
|
+
}, z.core.$strip>;
|
|
392
|
+
coin: z.ZodString;
|
|
393
|
+
wallet: z.ZodString;
|
|
394
|
+
}, z.core.$strip>;
|
|
395
|
+
type GenerateAddressBody = z.infer<typeof generateAddressBodyParser>;
|
|
396
|
+
declare const generateAddressResponse: z.ZodObject<{
|
|
397
|
+
id: z.ZodString;
|
|
398
|
+
address: z.ZodString;
|
|
399
|
+
coin: z.ZodString;
|
|
400
|
+
wallet: z.ZodString;
|
|
401
|
+
memo: z.ZodOptional<z.ZodString>;
|
|
402
|
+
}, z.core.$strip>;
|
|
403
|
+
type GenerateAddressResponse = z.infer<typeof generateAddressResponse>;
|
|
404
|
+
declare const createAbstractAuthParser: (contract: string, action: string, data: z.ZodRawShape) => z.ZodObject<{
|
|
405
|
+
signer: z.ZodObject<{
|
|
406
|
+
actor: z.ZodString;
|
|
407
|
+
permission: z.ZodString;
|
|
408
|
+
}, z.core.$strip>;
|
|
409
|
+
signatures: z.ZodArray<z.ZodString>;
|
|
410
|
+
transaction: z.ZodObject<{
|
|
411
|
+
expiration: z.ZodString;
|
|
412
|
+
ref_block_num: z.ZodNumber;
|
|
413
|
+
ref_block_prefix: z.ZodNumber;
|
|
414
|
+
max_net_usage_words: z.ZodNumber;
|
|
415
|
+
max_cpu_usage_ms: z.ZodNumber;
|
|
416
|
+
delay_sec: z.ZodNumber;
|
|
417
|
+
context_free_actions: z.ZodArray<z.ZodObject<{
|
|
418
|
+
account: z.ZodString;
|
|
419
|
+
name: z.ZodString;
|
|
420
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
421
|
+
actor: z.ZodString;
|
|
422
|
+
permission: z.ZodString;
|
|
423
|
+
}, z.core.$strip>>;
|
|
424
|
+
data: z.ZodAny;
|
|
425
|
+
hex_data: z.ZodOptional<z.ZodString>;
|
|
426
|
+
}, z.core.$strip>>;
|
|
427
|
+
transaction_extensions: z.ZodArray<z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString]>>>>;
|
|
428
|
+
actions: z.ZodArray<z.ZodUnion<[z.ZodObject<{
|
|
429
|
+
account: z.ZodString | z.ZodLiteral<string>;
|
|
430
|
+
name: z.ZodLiteral<string>;
|
|
431
|
+
data: z.ZodObject<{
|
|
432
|
+
[x: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
|
|
433
|
+
}, z.core.$strip>;
|
|
434
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
435
|
+
actor: z.ZodString;
|
|
436
|
+
permission: z.ZodString;
|
|
437
|
+
}, z.core.$strip>>;
|
|
438
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
439
|
+
account: z.ZodLiteral<"webauthn">;
|
|
440
|
+
name: z.ZodLiteral<"exec">;
|
|
441
|
+
data: z.ZodObject<{
|
|
442
|
+
account: z.ZodString;
|
|
443
|
+
key: z.ZodObject<{
|
|
444
|
+
key: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
|
|
445
|
+
modulus: z.ZodString;
|
|
446
|
+
exponent: z.ZodString;
|
|
447
|
+
}, z.core.$strip>]>>;
|
|
448
|
+
user_presence: z.ZodNumber;
|
|
449
|
+
rpid: z.ZodString;
|
|
450
|
+
}, z.core.$strip>;
|
|
451
|
+
nonce: z.ZodNumber;
|
|
452
|
+
permissions: z.ZodArray<z.ZodObject<{
|
|
453
|
+
actor: z.ZodString;
|
|
454
|
+
permission: z.ZodString;
|
|
455
|
+
}, z.core.$strip>>;
|
|
456
|
+
signature: z.ZodObject<{
|
|
457
|
+
auth_data: z.ZodString;
|
|
458
|
+
client_json: z.ZodString;
|
|
459
|
+
signature: z.ZodString;
|
|
460
|
+
}, z.core.$strip>;
|
|
461
|
+
trx: z.ZodObject<{
|
|
462
|
+
expiration: z.ZodString;
|
|
463
|
+
ref_block_num: z.ZodNumber;
|
|
464
|
+
ref_block_prefix: z.ZodNumber;
|
|
465
|
+
max_net_usage_words: z.ZodNumber;
|
|
466
|
+
max_cpu_usage_ms: z.ZodNumber;
|
|
467
|
+
delay_sec: z.ZodNumber;
|
|
468
|
+
context_free_actions: z.ZodArray<z.ZodObject<{
|
|
469
|
+
account: z.ZodString;
|
|
470
|
+
name: z.ZodString;
|
|
471
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
472
|
+
actor: z.ZodString;
|
|
473
|
+
permission: z.ZodString;
|
|
474
|
+
}, z.core.$strip>>;
|
|
475
|
+
data: z.ZodAny;
|
|
476
|
+
hex_data: z.ZodOptional<z.ZodString>;
|
|
477
|
+
}, z.core.$strip>>;
|
|
478
|
+
transaction_extensions: z.ZodArray<z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString]>>>>;
|
|
479
|
+
actions: z.ZodArray<z.ZodObject<{
|
|
480
|
+
account: z.ZodString | z.ZodLiteral<string>;
|
|
481
|
+
name: z.ZodLiteral<string>;
|
|
482
|
+
data: z.ZodUnion<[z.ZodString, z.ZodObject<{
|
|
483
|
+
[x: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
|
|
484
|
+
}, z.core.$strip>]>;
|
|
485
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
486
|
+
actor: z.ZodString;
|
|
487
|
+
permission: z.ZodString;
|
|
488
|
+
}, z.core.$strip>>;
|
|
489
|
+
}, z.core.$strip>>;
|
|
490
|
+
}, z.core.$strip>;
|
|
491
|
+
}, z.core.$strip>;
|
|
492
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
493
|
+
actor: z.ZodString;
|
|
494
|
+
permission: z.ZodString;
|
|
495
|
+
}, z.core.$strip>>;
|
|
496
|
+
}, z.core.$strip>]>>;
|
|
497
|
+
}, z.core.$strip>;
|
|
498
|
+
}, z.core.$strip>;
|
|
499
|
+
declare const generateAuthActionsBaseParser: z.ZodObject<{
|
|
500
|
+
account: z.ZodString | z.ZodLiteral<string>;
|
|
501
|
+
name: z.ZodLiteral<string>;
|
|
502
|
+
data: z.ZodObject<{
|
|
503
|
+
time: z.ZodString;
|
|
504
|
+
protonAccount: z.ZodString;
|
|
505
|
+
}, z.core.$strip>;
|
|
506
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
507
|
+
actor: z.ZodString;
|
|
508
|
+
permission: z.ZodString;
|
|
509
|
+
}, z.core.$strip>>;
|
|
510
|
+
}, z.core.$strip>;
|
|
511
|
+
type GenerateAuthBaseAction = z.infer<typeof generateAuthActionsBaseParser>;
|
|
512
|
+
declare const generateAuthParser: z.ZodObject<{
|
|
513
|
+
signer: z.ZodObject<{
|
|
514
|
+
actor: z.ZodString;
|
|
515
|
+
permission: z.ZodString;
|
|
516
|
+
}, z.core.$strip>;
|
|
517
|
+
signatures: z.ZodArray<z.ZodString>;
|
|
518
|
+
transaction: z.ZodObject<{
|
|
519
|
+
expiration: z.ZodString;
|
|
520
|
+
ref_block_num: z.ZodNumber;
|
|
521
|
+
ref_block_prefix: z.ZodNumber;
|
|
522
|
+
max_net_usage_words: z.ZodNumber;
|
|
523
|
+
max_cpu_usage_ms: z.ZodNumber;
|
|
524
|
+
delay_sec: z.ZodNumber;
|
|
525
|
+
context_free_actions: z.ZodArray<z.ZodObject<{
|
|
526
|
+
account: z.ZodString;
|
|
527
|
+
name: z.ZodString;
|
|
528
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
529
|
+
actor: z.ZodString;
|
|
530
|
+
permission: z.ZodString;
|
|
531
|
+
}, z.core.$strip>>;
|
|
532
|
+
data: z.ZodAny;
|
|
533
|
+
hex_data: z.ZodOptional<z.ZodString>;
|
|
534
|
+
}, z.core.$strip>>;
|
|
535
|
+
transaction_extensions: z.ZodArray<z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString]>>>>;
|
|
536
|
+
actions: z.ZodArray<z.ZodUnion<[z.ZodObject<{
|
|
537
|
+
account: z.ZodString | z.ZodLiteral<string>;
|
|
538
|
+
name: z.ZodLiteral<string>;
|
|
539
|
+
data: z.ZodObject<{
|
|
540
|
+
[x: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
|
|
541
|
+
}, z.core.$strip>;
|
|
542
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
543
|
+
actor: z.ZodString;
|
|
544
|
+
permission: z.ZodString;
|
|
545
|
+
}, z.core.$strip>>;
|
|
546
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
547
|
+
account: z.ZodLiteral<"webauthn">;
|
|
548
|
+
name: z.ZodLiteral<"exec">;
|
|
549
|
+
data: z.ZodObject<{
|
|
550
|
+
account: z.ZodString;
|
|
551
|
+
key: z.ZodObject<{
|
|
552
|
+
key: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
|
|
553
|
+
modulus: z.ZodString;
|
|
554
|
+
exponent: z.ZodString;
|
|
555
|
+
}, z.core.$strip>]>>;
|
|
556
|
+
user_presence: z.ZodNumber;
|
|
557
|
+
rpid: z.ZodString;
|
|
558
|
+
}, z.core.$strip>;
|
|
559
|
+
nonce: z.ZodNumber;
|
|
560
|
+
permissions: z.ZodArray<z.ZodObject<{
|
|
561
|
+
actor: z.ZodString;
|
|
562
|
+
permission: z.ZodString;
|
|
563
|
+
}, z.core.$strip>>;
|
|
564
|
+
signature: z.ZodObject<{
|
|
565
|
+
auth_data: z.ZodString;
|
|
566
|
+
client_json: z.ZodString;
|
|
567
|
+
signature: z.ZodString;
|
|
568
|
+
}, z.core.$strip>;
|
|
569
|
+
trx: z.ZodObject<{
|
|
570
|
+
expiration: z.ZodString;
|
|
571
|
+
ref_block_num: z.ZodNumber;
|
|
572
|
+
ref_block_prefix: z.ZodNumber;
|
|
573
|
+
max_net_usage_words: z.ZodNumber;
|
|
574
|
+
max_cpu_usage_ms: z.ZodNumber;
|
|
575
|
+
delay_sec: z.ZodNumber;
|
|
576
|
+
context_free_actions: z.ZodArray<z.ZodObject<{
|
|
577
|
+
account: z.ZodString;
|
|
578
|
+
name: z.ZodString;
|
|
579
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
580
|
+
actor: z.ZodString;
|
|
581
|
+
permission: z.ZodString;
|
|
582
|
+
}, z.core.$strip>>;
|
|
583
|
+
data: z.ZodAny;
|
|
584
|
+
hex_data: z.ZodOptional<z.ZodString>;
|
|
585
|
+
}, z.core.$strip>>;
|
|
586
|
+
transaction_extensions: z.ZodArray<z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString]>>>>;
|
|
587
|
+
actions: z.ZodArray<z.ZodObject<{
|
|
588
|
+
account: z.ZodString | z.ZodLiteral<string>;
|
|
589
|
+
name: z.ZodLiteral<string>;
|
|
590
|
+
data: z.ZodUnion<[z.ZodString, z.ZodObject<{
|
|
591
|
+
[x: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
|
|
592
|
+
}, z.core.$strip>]>;
|
|
593
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
594
|
+
actor: z.ZodString;
|
|
595
|
+
permission: z.ZodString;
|
|
596
|
+
}, z.core.$strip>>;
|
|
597
|
+
}, z.core.$strip>>;
|
|
598
|
+
}, z.core.$strip>;
|
|
599
|
+
}, z.core.$strip>;
|
|
600
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
601
|
+
actor: z.ZodString;
|
|
602
|
+
permission: z.ZodString;
|
|
603
|
+
}, z.core.$strip>>;
|
|
604
|
+
}, z.core.$strip>]>>;
|
|
605
|
+
}, z.core.$strip>;
|
|
606
|
+
}, z.core.$strip>;
|
|
607
|
+
type GenerateAuth = z.infer<typeof generateAuthParser>;
|
|
608
|
+
declare const accountParser: z.ZodString;
|
|
609
|
+
declare const authorizationParser: z.ZodObject<{
|
|
610
|
+
actor: z.ZodString;
|
|
611
|
+
permission: z.ZodString;
|
|
612
|
+
}, z.core.$strip>;
|
|
613
|
+
type Authorization = z.infer<typeof authorizationParser>;
|
|
614
|
+
declare const authorizationsParser: z.ZodArray<z.ZodObject<{
|
|
615
|
+
actor: z.ZodString;
|
|
616
|
+
permission: z.ZodString;
|
|
617
|
+
}, z.core.$strip>>;
|
|
618
|
+
type Authorizations = z.infer<typeof authorizationsParser>;
|
|
619
|
+
declare const ExtendedAssetParser: z.ZodObject<{
|
|
620
|
+
quantity: z.ZodString;
|
|
621
|
+
contract: z.ZodString;
|
|
622
|
+
}, z.core.$strip>;
|
|
623
|
+
type ExtendedAsset = z.infer<typeof ExtendedAssetParser>;
|
|
624
|
+
declare const accountRamDeltaParser: z.ZodObject<{
|
|
625
|
+
account: z.ZodString;
|
|
626
|
+
delta: z.ZodString;
|
|
627
|
+
}, z.core.$strip>;
|
|
628
|
+
type HistoryAccountRamDelta = z.infer<typeof accountRamDeltaParser>;
|
|
629
|
+
interface CurrencyStat {
|
|
630
|
+
supply: string;
|
|
631
|
+
max_supply: string;
|
|
632
|
+
issuer: string;
|
|
633
|
+
}
|
|
634
|
+
interface CurrencyStats {
|
|
635
|
+
[key: string]: CurrencyStat;
|
|
636
|
+
}
|
|
637
|
+
declare const rateParser: z.ZodObject<{
|
|
638
|
+
counterCurrency: z.ZodString;
|
|
639
|
+
price: z.ZodNumber;
|
|
640
|
+
priceChangePercent: z.ZodNumber;
|
|
641
|
+
marketCap: z.ZodNumber;
|
|
642
|
+
volume: z.ZodNumber;
|
|
643
|
+
timestamp: z.ZodNumber;
|
|
644
|
+
}, z.core.$strip>;
|
|
645
|
+
type Rate = z.infer<typeof rateParser>;
|
|
646
|
+
declare const exchangeRateParser: z.ZodObject<{
|
|
647
|
+
contract: z.ZodString;
|
|
648
|
+
symbol: z.ZodString;
|
|
649
|
+
rank: z.ZodNumber;
|
|
650
|
+
rates: z.ZodArray<z.ZodObject<{
|
|
651
|
+
counterCurrency: z.ZodString;
|
|
652
|
+
price: z.ZodNumber;
|
|
653
|
+
priceChangePercent: z.ZodNumber;
|
|
654
|
+
marketCap: z.ZodNumber;
|
|
655
|
+
volume: z.ZodNumber;
|
|
656
|
+
timestamp: z.ZodNumber;
|
|
657
|
+
}, z.core.$strip>>;
|
|
658
|
+
}, z.core.$strip>;
|
|
659
|
+
type ExchangeRate = z.infer<typeof exchangeRateParser>;
|
|
660
|
+
declare const exchangeRatesParser: z.ZodArray<z.ZodObject<{
|
|
661
|
+
contract: z.ZodString;
|
|
662
|
+
symbol: z.ZodString;
|
|
663
|
+
rank: z.ZodNumber;
|
|
664
|
+
rates: z.ZodArray<z.ZodObject<{
|
|
665
|
+
counterCurrency: z.ZodString;
|
|
666
|
+
price: z.ZodNumber;
|
|
667
|
+
priceChangePercent: z.ZodNumber;
|
|
668
|
+
marketCap: z.ZodNumber;
|
|
669
|
+
volume: z.ZodNumber;
|
|
670
|
+
timestamp: z.ZodNumber;
|
|
671
|
+
}, z.core.$strip>>;
|
|
672
|
+
}, z.core.$strip>>;
|
|
673
|
+
type ExchangeRates = z.infer<typeof exchangeRatesParser>;
|
|
674
|
+
declare const bloksRatesParser: z.ZodArray<z.ZodObject<{
|
|
675
|
+
contract: z.ZodString;
|
|
676
|
+
symbol: z.ZodString;
|
|
677
|
+
rank: z.ZodNumber;
|
|
678
|
+
rates: z.ZodArray<z.ZodObject<{
|
|
679
|
+
counterCurrency: z.ZodString;
|
|
680
|
+
price: z.ZodNumber;
|
|
681
|
+
priceChangePercent: z.ZodNumber;
|
|
682
|
+
marketCap: z.ZodNumber;
|
|
683
|
+
volume: z.ZodNumber;
|
|
684
|
+
timestamp: z.ZodNumber;
|
|
685
|
+
}, z.core.$strip>>;
|
|
686
|
+
}, z.core.$strip>>;
|
|
687
|
+
type BloksRate = {
|
|
688
|
+
key: string;
|
|
689
|
+
symbol: string;
|
|
690
|
+
account: string;
|
|
691
|
+
chain: string;
|
|
692
|
+
supply: {
|
|
693
|
+
circulating: number;
|
|
694
|
+
max: number;
|
|
695
|
+
precision: number;
|
|
696
|
+
last_update: string;
|
|
697
|
+
};
|
|
698
|
+
metadata: {
|
|
699
|
+
name: string;
|
|
700
|
+
website: string;
|
|
701
|
+
logo: string;
|
|
702
|
+
created_at: string;
|
|
703
|
+
desc: string;
|
|
704
|
+
};
|
|
705
|
+
pairs: [{
|
|
706
|
+
id: string;
|
|
707
|
+
pair_base: string;
|
|
708
|
+
pair_quote: string;
|
|
709
|
+
exchange: string;
|
|
710
|
+
quote: {
|
|
711
|
+
price: number;
|
|
712
|
+
volume_base_24h: number;
|
|
713
|
+
volume_quote_24h: number;
|
|
714
|
+
market_cap: number;
|
|
715
|
+
price_usd: number;
|
|
716
|
+
volume_usd_24h: number;
|
|
717
|
+
};
|
|
718
|
+
percentage_daily_volume: number;
|
|
719
|
+
}];
|
|
720
|
+
price: {
|
|
721
|
+
quotes: {
|
|
722
|
+
[key: string]: number;
|
|
723
|
+
};
|
|
724
|
+
usd: number;
|
|
725
|
+
volume_base_24h: number;
|
|
726
|
+
volume_usd_24h: number;
|
|
727
|
+
marketcap_usd: number;
|
|
728
|
+
change_24hr: number;
|
|
729
|
+
};
|
|
730
|
+
rank: number;
|
|
731
|
+
chain_rank: number;
|
|
732
|
+
};
|
|
733
|
+
type BloksRates = BloksRate[];
|
|
734
|
+
declare enum Type {
|
|
735
|
+
RECEIVE = "receive",
|
|
736
|
+
SEND = "send"
|
|
737
|
+
}
|
|
738
|
+
declare const depositBodyParser: z.ZodObject<{
|
|
739
|
+
id: z.ZodString;
|
|
740
|
+
type: z.ZodEnum<typeof Type>;
|
|
741
|
+
hash: z.ZodString;
|
|
742
|
+
coin: z.ZodString;
|
|
743
|
+
wallet: z.ZodString;
|
|
744
|
+
network: z.ZodString;
|
|
745
|
+
}, z.core.$strip>;
|
|
746
|
+
type DepositBody = z.infer<typeof depositBodyParser>;
|
|
747
|
+
declare const metalTransactionParser: z.ZodObject<{
|
|
748
|
+
id: z.ZodString;
|
|
749
|
+
wallet: z.ZodString;
|
|
750
|
+
value: z.ZodNumber;
|
|
751
|
+
valueString: z.ZodString;
|
|
752
|
+
address: z.ZodString;
|
|
753
|
+
type: z.ZodEnum<typeof Type>;
|
|
754
|
+
state: z.ZodString;
|
|
755
|
+
confirmations: z.ZodNumber;
|
|
756
|
+
hash: z.ZodString;
|
|
757
|
+
blockHash: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
758
|
+
blockHeight: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
|
|
759
|
+
}, z.core.$strip>;
|
|
760
|
+
type MetalTransaction = z.infer<typeof metalTransactionParser>;
|
|
761
|
+
declare const otcOrderResponseParser: z.ZodObject<{
|
|
762
|
+
success: z.ZodBoolean;
|
|
763
|
+
transaction_id: z.ZodString;
|
|
764
|
+
errormsg: z.ZodOptional<z.ZodString>;
|
|
765
|
+
}, z.core.$strip>;
|
|
766
|
+
type OtcOrderResponse = z.infer<typeof otcOrderResponseParser>;
|
|
767
|
+
declare const otcQuoteBodyParser: z.ZodObject<{
|
|
768
|
+
baseAmount: z.ZodNumber;
|
|
769
|
+
baseSymbol: z.ZodString;
|
|
770
|
+
quoteSymbol: z.ZodString;
|
|
771
|
+
}, z.core.$strip>;
|
|
772
|
+
type OtcQuoteBody = z.infer<typeof otcQuoteBodyParser>;
|
|
773
|
+
declare const otcQuoteResponseParser: z.ZodObject<{
|
|
774
|
+
success: z.ZodBoolean;
|
|
775
|
+
token: z.ZodString;
|
|
776
|
+
qty: z.ZodNumber;
|
|
777
|
+
errormsg: z.ZodOptional<z.ZodString>;
|
|
778
|
+
}, z.core.$strip>;
|
|
779
|
+
type OtcQuoteResponse = z.infer<typeof otcQuoteResponseParser>;
|
|
780
|
+
declare class INode<T> {
|
|
781
|
+
key: string;
|
|
782
|
+
data: T;
|
|
783
|
+
constructor(key: string, data?: T);
|
|
784
|
+
}
|
|
785
|
+
declare class ILink<T> {
|
|
786
|
+
from: INode<T>;
|
|
787
|
+
to: INode<T>;
|
|
788
|
+
data: T;
|
|
789
|
+
constructor(from: INode<T>, to: INode<T>, data?: T);
|
|
790
|
+
}
|
|
791
|
+
declare class Graph<T> {
|
|
792
|
+
nodes: INode<T>[];
|
|
793
|
+
links: ILink<T>[];
|
|
794
|
+
lastPathFound: INode<T>[];
|
|
795
|
+
isEquals: (a: INode<T>, b: INode<T>) => boolean;
|
|
796
|
+
addNode(k: string, v?: T): void;
|
|
797
|
+
addNodes(...nodes: (string | [string, T?])[]): void;
|
|
798
|
+
findNode(k: string): INode<T> | undefined;
|
|
799
|
+
findNodes(...keys: string[]): (INode<T> | undefined)[];
|
|
800
|
+
requireFindNodes(...keys: string[]): INode<T>[];
|
|
801
|
+
addLink(nodeA: string, nodeB: string, data?: T): void;
|
|
802
|
+
addLinks(...links: [nodeA: string, nodeB: string, data?: T][]): void;
|
|
803
|
+
/**
|
|
804
|
+
* Get all nodes linked
|
|
805
|
+
* to from `node`.
|
|
806
|
+
*/
|
|
807
|
+
findLinkedNodes(node: INode<T>): INode<T>[];
|
|
808
|
+
findAllPaths(from: string, to: string): INode<T>[][];
|
|
809
|
+
}
|
|
810
|
+
interface RawPool {
|
|
811
|
+
lt_symbol: string;
|
|
812
|
+
creator: string;
|
|
813
|
+
memo: string;
|
|
814
|
+
pool1: {
|
|
815
|
+
quantity: string;
|
|
816
|
+
contract: string;
|
|
817
|
+
};
|
|
818
|
+
pool2: {
|
|
819
|
+
quantity: string;
|
|
820
|
+
contract: string;
|
|
821
|
+
};
|
|
822
|
+
hash: string;
|
|
823
|
+
fee: {
|
|
824
|
+
exchange_fee: number;
|
|
825
|
+
add_liquidity_fee: number;
|
|
826
|
+
remove_liquidity_fee: number;
|
|
827
|
+
};
|
|
828
|
+
active: boolean;
|
|
829
|
+
amplifier: number;
|
|
830
|
+
}
|
|
831
|
+
interface Pool extends Omit<RawPool, "pool1" | "pool2"> {
|
|
832
|
+
lt_symbol: string;
|
|
833
|
+
creator: string;
|
|
834
|
+
memo: string;
|
|
835
|
+
pool1: ExtendedTokenWithRate;
|
|
836
|
+
pool2: ExtendedTokenWithRate;
|
|
837
|
+
hash: string;
|
|
838
|
+
fee: {
|
|
839
|
+
exchange_fee: number;
|
|
840
|
+
add_liquidity_fee: number;
|
|
841
|
+
remove_liquidity_fee: number;
|
|
842
|
+
};
|
|
843
|
+
liquidityUsd: number;
|
|
844
|
+
liquidityApr: number;
|
|
845
|
+
}
|
|
846
|
+
type ExtendedToken = Coin & ExtendedAsset$1 & {
|
|
847
|
+
key: string;
|
|
848
|
+
};
|
|
849
|
+
type ExtendedTokenWithRate = ExtendedToken & {
|
|
850
|
+
rate: number;
|
|
851
|
+
};
|
|
852
|
+
type PoolTable = {
|
|
853
|
+
pool1: ExtendedTokenWithRate;
|
|
854
|
+
pool2: ExtendedTokenWithRate;
|
|
855
|
+
path: INode<Pool>[];
|
|
856
|
+
shortestPath: INode<Pool>[];
|
|
857
|
+
getPathString: () => string;
|
|
858
|
+
} | undefined;
|
|
859
|
+
declare const withdrawBodyBaseAction: z.ZodObject<{
|
|
860
|
+
account: z.ZodString | z.ZodLiteral<string>;
|
|
861
|
+
name: z.ZodLiteral<string>;
|
|
862
|
+
data: z.ZodObject<{
|
|
863
|
+
from: z.ZodString;
|
|
864
|
+
to: z.ZodLiteral<"proton.wrap">;
|
|
865
|
+
quantity: z.ZodString;
|
|
866
|
+
memo: z.ZodString;
|
|
867
|
+
}, z.core.$strip>;
|
|
868
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
869
|
+
actor: z.ZodString;
|
|
870
|
+
permission: z.ZodString;
|
|
871
|
+
}, z.core.$strip>>;
|
|
872
|
+
}, z.core.$strip>;
|
|
873
|
+
type WithdrawBodyBaseAction = z.infer<typeof withdrawBodyBaseAction>;
|
|
874
|
+
declare const withdrawBodyParser: z.ZodObject<{
|
|
875
|
+
signer: z.ZodObject<{
|
|
876
|
+
actor: z.ZodString;
|
|
877
|
+
permission: z.ZodString;
|
|
878
|
+
}, z.core.$strip>;
|
|
879
|
+
signatures: z.ZodArray<z.ZodString>;
|
|
880
|
+
transaction: z.ZodObject<{
|
|
881
|
+
expiration: z.ZodString;
|
|
882
|
+
ref_block_num: z.ZodNumber;
|
|
883
|
+
ref_block_prefix: z.ZodNumber;
|
|
884
|
+
max_net_usage_words: z.ZodNumber;
|
|
885
|
+
max_cpu_usage_ms: z.ZodNumber;
|
|
886
|
+
delay_sec: z.ZodNumber;
|
|
887
|
+
context_free_actions: z.ZodArray<z.ZodObject<{
|
|
888
|
+
account: z.ZodString;
|
|
889
|
+
name: z.ZodString;
|
|
890
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
891
|
+
actor: z.ZodString;
|
|
892
|
+
permission: z.ZodString;
|
|
893
|
+
}, z.core.$strip>>;
|
|
894
|
+
data: z.ZodAny;
|
|
895
|
+
hex_data: z.ZodOptional<z.ZodString>;
|
|
896
|
+
}, z.core.$strip>>;
|
|
897
|
+
transaction_extensions: z.ZodArray<z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString]>>>>;
|
|
898
|
+
actions: z.ZodArray<z.ZodUnion<[z.ZodObject<{
|
|
899
|
+
account: z.ZodString | z.ZodLiteral<string>;
|
|
900
|
+
name: z.ZodLiteral<string>;
|
|
901
|
+
data: z.ZodObject<{
|
|
902
|
+
from: z.ZodString;
|
|
903
|
+
to: z.ZodLiteral<"proton.wrap">;
|
|
904
|
+
quantity: z.ZodString;
|
|
905
|
+
memo: z.ZodString;
|
|
906
|
+
}, z.core.$strip>;
|
|
907
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
908
|
+
actor: z.ZodString;
|
|
909
|
+
permission: z.ZodString;
|
|
910
|
+
}, z.core.$strip>>;
|
|
911
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
912
|
+
account: z.ZodLiteral<"webauthn">;
|
|
913
|
+
name: z.ZodLiteral<"exec">;
|
|
914
|
+
data: z.ZodObject<{
|
|
915
|
+
account: z.ZodString;
|
|
916
|
+
key: z.ZodObject<{
|
|
917
|
+
key: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
|
|
918
|
+
modulus: z.ZodString;
|
|
919
|
+
exponent: z.ZodString;
|
|
920
|
+
}, z.core.$strip>]>>;
|
|
921
|
+
user_presence: z.ZodNumber;
|
|
922
|
+
rpid: z.ZodString;
|
|
923
|
+
}, z.core.$strip>;
|
|
924
|
+
nonce: z.ZodNumber;
|
|
925
|
+
permissions: z.ZodArray<z.ZodObject<{
|
|
926
|
+
actor: z.ZodString;
|
|
927
|
+
permission: z.ZodString;
|
|
928
|
+
}, z.core.$strip>>;
|
|
929
|
+
signature: z.ZodObject<{
|
|
930
|
+
auth_data: z.ZodString;
|
|
931
|
+
client_json: z.ZodString;
|
|
932
|
+
signature: z.ZodString;
|
|
933
|
+
}, z.core.$strip>;
|
|
934
|
+
trx: z.ZodObject<{
|
|
935
|
+
expiration: z.ZodString;
|
|
936
|
+
ref_block_num: z.ZodNumber;
|
|
937
|
+
ref_block_prefix: z.ZodNumber;
|
|
938
|
+
max_net_usage_words: z.ZodNumber;
|
|
939
|
+
max_cpu_usage_ms: z.ZodNumber;
|
|
940
|
+
delay_sec: z.ZodNumber;
|
|
941
|
+
context_free_actions: z.ZodArray<z.ZodObject<{
|
|
942
|
+
account: z.ZodString;
|
|
943
|
+
name: z.ZodString;
|
|
944
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
945
|
+
actor: z.ZodString;
|
|
946
|
+
permission: z.ZodString;
|
|
947
|
+
}, z.core.$strip>>;
|
|
948
|
+
data: z.ZodAny;
|
|
949
|
+
hex_data: z.ZodOptional<z.ZodString>;
|
|
950
|
+
}, z.core.$strip>>;
|
|
951
|
+
transaction_extensions: z.ZodArray<z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString]>>>>;
|
|
952
|
+
actions: z.ZodArray<z.ZodObject<{
|
|
953
|
+
account: z.ZodString | z.ZodLiteral<string>;
|
|
954
|
+
name: z.ZodLiteral<string>;
|
|
955
|
+
data: z.ZodUnion<[z.ZodString, z.ZodObject<{
|
|
956
|
+
from: z.ZodString;
|
|
957
|
+
to: z.ZodLiteral<"proton.wrap">;
|
|
958
|
+
quantity: z.ZodString;
|
|
959
|
+
memo: z.ZodString;
|
|
960
|
+
}, z.core.$strip>]>;
|
|
961
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
962
|
+
actor: z.ZodString;
|
|
963
|
+
permission: z.ZodString;
|
|
964
|
+
}, z.core.$strip>>;
|
|
965
|
+
}, z.core.$strip>>;
|
|
966
|
+
}, z.core.$strip>;
|
|
967
|
+
}, z.core.$strip>;
|
|
968
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
969
|
+
actor: z.ZodString;
|
|
970
|
+
permission: z.ZodString;
|
|
971
|
+
}, z.core.$strip>>;
|
|
972
|
+
}, z.core.$strip>]>>;
|
|
973
|
+
}, z.core.$strip>;
|
|
974
|
+
quoteId: z.ZodString;
|
|
975
|
+
provider: z.ZodOptional<z.ZodString>;
|
|
976
|
+
}, z.core.$strip>;
|
|
977
|
+
type WithdrawBody = z.infer<typeof withdrawBodyParser>;
|
|
978
|
+
declare const withdrawMetalResponseParser: z.ZodObject<{
|
|
979
|
+
success: z.ZodBoolean;
|
|
980
|
+
id: z.ZodString;
|
|
981
|
+
}, z.core.$strip>;
|
|
982
|
+
type WithdrawMetalResponse = z.infer<typeof withdrawMetalResponseParser>;
|
|
983
|
+
declare const withdrawalFeeQuoteParser: z.ZodObject<{
|
|
984
|
+
quoteId: z.ZodString;
|
|
985
|
+
estimatedFee: z.ZodString;
|
|
986
|
+
currency: z.ZodString;
|
|
987
|
+
network: z.ZodString;
|
|
988
|
+
}, z.core.$strip>;
|
|
989
|
+
type WithdrawalFeeQuote = z.infer<typeof withdrawalFeeQuoteParser>;
|
|
990
|
+
declare const withdrawHistoryMetalSwapParser: z.ZodObject<{
|
|
991
|
+
id: z.ZodString;
|
|
992
|
+
status: z.ZodString;
|
|
993
|
+
amount: z.ZodString;
|
|
994
|
+
currency: z.ZodString;
|
|
995
|
+
network: z.ZodString;
|
|
996
|
+
created: z.ZodString;
|
|
997
|
+
withdrawalAddress: z.ZodString;
|
|
998
|
+
withdrawalHash: z.ZodOptional<z.ZodString>;
|
|
999
|
+
}, z.core.$strip>;
|
|
1000
|
+
type WithdrawHistoryMetalSwap = z.infer<typeof withdrawHistoryMetalSwapParser>;
|
|
1001
|
+
declare const withdrawHistoryMetalResponseParser: z.ZodObject<{
|
|
1002
|
+
swaps: z.ZodArray<z.ZodObject<{
|
|
1003
|
+
id: z.ZodString;
|
|
1004
|
+
status: z.ZodString;
|
|
1005
|
+
amount: z.ZodString;
|
|
1006
|
+
currency: z.ZodString;
|
|
1007
|
+
network: z.ZodString;
|
|
1008
|
+
created: z.ZodString;
|
|
1009
|
+
withdrawalAddress: z.ZodString;
|
|
1010
|
+
withdrawalHash: z.ZodOptional<z.ZodString>;
|
|
1011
|
+
}, z.core.$strip>>;
|
|
1012
|
+
page: z.ZodNumber;
|
|
1013
|
+
pageSize: z.ZodNumber;
|
|
1014
|
+
numberOfElements: z.ZodNumber;
|
|
1015
|
+
totalPages: z.ZodNumber;
|
|
1016
|
+
totalElements: z.ZodNumber;
|
|
1017
|
+
}, z.core.$strip>;
|
|
1018
|
+
type WithdrawHistoryMetalResponse = z.infer<typeof withdrawHistoryMetalResponseParser>;
|
|
1019
|
+
declare enum Status {
|
|
1020
|
+
PENDING = "pending",
|
|
1021
|
+
SUCCESS = "success",
|
|
1022
|
+
FAIL = "fail",
|
|
1023
|
+
PROCESSING = "processing"
|
|
1024
|
+
}
|
|
1025
|
+
declare const wrapStartParser: z.ZodObject<{
|
|
1026
|
+
balance: z.ZodObject<{
|
|
1027
|
+
quantity: z.ZodString;
|
|
1028
|
+
contract: z.ZodString;
|
|
1029
|
+
}, z.core.$strip>;
|
|
1030
|
+
id: z.ZodString;
|
|
1031
|
+
txid: z.ZodString;
|
|
1032
|
+
chain: z.ZodString;
|
|
1033
|
+
deposit_address: z.ZodString;
|
|
1034
|
+
confirmations: z.ZodNumber;
|
|
1035
|
+
}, z.core.$strip>;
|
|
1036
|
+
type WrapStart = z.infer<typeof wrapStartParser>;
|
|
1037
|
+
declare const wrapSetConfParser: z.ZodObject<{
|
|
1038
|
+
wrap_hash: z.ZodString;
|
|
1039
|
+
confirmations: z.ZodNumber;
|
|
1040
|
+
}, z.core.$strip>;
|
|
1041
|
+
type WrapSetConf = z.infer<typeof wrapSetConfParser>;
|
|
1042
|
+
declare const wrapParser: z.ZodObject<{
|
|
1043
|
+
index: z.ZodNumber;
|
|
1044
|
+
proton_account: z.ZodString;
|
|
1045
|
+
balance: z.ZodObject<{
|
|
1046
|
+
quantity: z.ZodString;
|
|
1047
|
+
contract: z.ZodString;
|
|
1048
|
+
}, z.core.$strip>;
|
|
1049
|
+
id: z.ZodString;
|
|
1050
|
+
txid: z.ZodString;
|
|
1051
|
+
chain: z.ZodString;
|
|
1052
|
+
deposit_address: z.ZodString;
|
|
1053
|
+
status: z.ZodEnum<typeof Status>;
|
|
1054
|
+
finish_txid: z.ZodString;
|
|
1055
|
+
wrap_hash: z.ZodString;
|
|
1056
|
+
confirmations: z.ZodNumber;
|
|
1057
|
+
}, z.core.$strip>;
|
|
1058
|
+
type Wrap = z.infer<typeof wrapParser>;
|
|
1059
|
+
declare const sortDirectionEnum: z.ZodEnum<{
|
|
1060
|
+
asc: "asc";
|
|
1061
|
+
desc: "desc";
|
|
1062
|
+
}>;
|
|
1063
|
+
type SortDirection = z.input<typeof sortDirectionEnum>;
|
|
1064
|
+
/**
|
|
1065
|
+
* OHLCV
|
|
1066
|
+
*/
|
|
1067
|
+
declare const ohlcvParser: z.ZodObject<{
|
|
1068
|
+
time: z.ZodNumber;
|
|
1069
|
+
open: z.ZodNumber;
|
|
1070
|
+
high: z.ZodNumber;
|
|
1071
|
+
low: z.ZodNumber;
|
|
1072
|
+
close: z.ZodNumber;
|
|
1073
|
+
volume: z.ZodNumber;
|
|
1074
|
+
volume_bid: z.ZodNumber;
|
|
1075
|
+
count: z.ZodNumber;
|
|
1076
|
+
}, z.core.$strip>;
|
|
1077
|
+
type OHLCV = z.infer<typeof ohlcvParser>;
|
|
1078
|
+
declare const getOhlcvParser: z.ZodObject<{
|
|
1079
|
+
interval: z.ZodString;
|
|
1080
|
+
from: z.ZodString;
|
|
1081
|
+
to: z.ZodString;
|
|
1082
|
+
symbol: z.ZodString;
|
|
1083
|
+
limit: z.ZodDefault<z.ZodCoercedNumber<number>>;
|
|
1084
|
+
}, z.core.$strip>;
|
|
1085
|
+
type GetOHLCV = z.input<typeof getOhlcvParser>;
|
|
1086
|
+
type GetOHLCVParsed = z.output<typeof getOhlcvParser>;
|
|
1087
|
+
declare const getOhlcvResponseParser: z.ZodObject<{
|
|
1088
|
+
sync: z.ZodNumber;
|
|
1089
|
+
data: z.ZodArray<z.ZodObject<{
|
|
1090
|
+
time: z.ZodNumber;
|
|
1091
|
+
open: z.ZodNumber;
|
|
1092
|
+
high: z.ZodNumber;
|
|
1093
|
+
low: z.ZodNumber;
|
|
1094
|
+
close: z.ZodNumber;
|
|
1095
|
+
volume: z.ZodNumber;
|
|
1096
|
+
volume_bid: z.ZodNumber;
|
|
1097
|
+
count: z.ZodNumber;
|
|
1098
|
+
}, z.core.$strip>>;
|
|
1099
|
+
}, z.core.$strip>;
|
|
1100
|
+
type GetOHLCVResponse = z.infer<typeof getOhlcvResponseParser>;
|
|
1101
|
+
/**
|
|
1102
|
+
* Order History
|
|
1103
|
+
*/
|
|
1104
|
+
declare const openOrderParser: z.ZodObject<{
|
|
1105
|
+
block_time: z.ZodString;
|
|
1106
|
+
order_id: z.ZodString;
|
|
1107
|
+
ordinal_order_id: z.ZodString;
|
|
1108
|
+
market_id: z.ZodNumber;
|
|
1109
|
+
quantity_init: z.ZodOptional<z.ZodNumber>;
|
|
1110
|
+
quantity_curr: z.ZodNumber;
|
|
1111
|
+
price: z.ZodNumber;
|
|
1112
|
+
account_name: z.ZodString;
|
|
1113
|
+
order_side: z.ZodNumber;
|
|
1114
|
+
order_type: z.ZodNumber;
|
|
1115
|
+
trigger_price: z.ZodNumber;
|
|
1116
|
+
fill_type: z.ZodNumber;
|
|
1117
|
+
status: z.ZodString;
|
|
1118
|
+
filled_total: z.ZodOptional<z.ZodNumber>;
|
|
1119
|
+
filled_amount: z.ZodOptional<z.ZodNumber>;
|
|
1120
|
+
filled_fee: z.ZodOptional<z.ZodNumber>;
|
|
1121
|
+
created_at: z.ZodString;
|
|
1122
|
+
updated_at: z.ZodString;
|
|
1123
|
+
}, z.core.$strip>;
|
|
1124
|
+
type OpenOrder = z.infer<typeof openOrderParser>;
|
|
1125
|
+
declare const orderLogParser: z.ZodObject<{
|
|
1126
|
+
seq: z.ZodString;
|
|
1127
|
+
block_num: z.ZodString;
|
|
1128
|
+
block_time: z.ZodString;
|
|
1129
|
+
order_id: z.ZodString;
|
|
1130
|
+
market_id: z.ZodNumber;
|
|
1131
|
+
quantity: z.ZodString;
|
|
1132
|
+
price: z.ZodString;
|
|
1133
|
+
account_name: z.ZodString;
|
|
1134
|
+
order_side: z.ZodNumber;
|
|
1135
|
+
order_type: z.ZodNumber;
|
|
1136
|
+
trigger_price: z.ZodString;
|
|
1137
|
+
fill_type: z.ZodNumber;
|
|
1138
|
+
status: z.ZodString;
|
|
1139
|
+
quantity_change: z.ZodString;
|
|
1140
|
+
trx_id: z.ZodString;
|
|
1141
|
+
}, z.core.$strip>;
|
|
1142
|
+
type OrderLog = z.infer<typeof orderLogParser>;
|
|
1143
|
+
declare const orderHistoryParser: z.ZodObject<{
|
|
1144
|
+
block_num: z.ZodString;
|
|
1145
|
+
block_time: z.ZodString;
|
|
1146
|
+
order_id: z.ZodString;
|
|
1147
|
+
ordinal_order_id: z.ZodString;
|
|
1148
|
+
market_id: z.ZodNumber;
|
|
1149
|
+
quantity_init: z.ZodOptional<z.ZodNumber>;
|
|
1150
|
+
quantity_curr: z.ZodNumber;
|
|
1151
|
+
price: z.ZodNumber;
|
|
1152
|
+
account_name: z.ZodString;
|
|
1153
|
+
order_side: z.ZodNumber;
|
|
1154
|
+
order_type: z.ZodNumber;
|
|
1155
|
+
trigger_price: z.ZodNumber;
|
|
1156
|
+
fill_type: z.ZodNumber;
|
|
1157
|
+
status: z.ZodString;
|
|
1158
|
+
quantity_change: z.ZodNumber;
|
|
1159
|
+
filled_total: z.ZodOptional<z.ZodNumber>;
|
|
1160
|
+
filled_amount: z.ZodOptional<z.ZodNumber>;
|
|
1161
|
+
filled_fee: z.ZodOptional<z.ZodNumber>;
|
|
1162
|
+
seq: z.ZodString;
|
|
1163
|
+
trx_id: z.ZodString;
|
|
1164
|
+
}, z.core.$strip>;
|
|
1165
|
+
type OrderHistory = z.infer<typeof orderHistoryParser>;
|
|
1166
|
+
declare const getOpenOrdersParser: z.ZodObject<{
|
|
1167
|
+
account: z.ZodString;
|
|
1168
|
+
symbol: z.ZodOptional<z.ZodString>;
|
|
1169
|
+
offset: z.ZodDefault<z.ZodCoercedNumber<number>>;
|
|
1170
|
+
limit: z.ZodDefault<z.ZodCoercedNumber<number>>;
|
|
1171
|
+
ordinal_order_ids: z.ZodPipe<z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString>, z.ZodString]>>, z.ZodTransform<string[], string | string[] | undefined>>;
|
|
1172
|
+
}, z.core.$strip>;
|
|
1173
|
+
type GetOpenOrders = z.input<typeof getOpenOrdersParser>;
|
|
1174
|
+
type GetOpenOrdersParsed = z.output<typeof getOpenOrdersParser>;
|
|
1175
|
+
declare const getOpenOrdersResponseParser: z.ZodObject<{
|
|
1176
|
+
sync: z.ZodNumber;
|
|
1177
|
+
count: z.ZodNumber;
|
|
1178
|
+
data: z.ZodArray<z.ZodObject<{
|
|
1179
|
+
block_time: z.ZodString;
|
|
1180
|
+
order_id: z.ZodString;
|
|
1181
|
+
ordinal_order_id: z.ZodString;
|
|
1182
|
+
market_id: z.ZodNumber;
|
|
1183
|
+
quantity_init: z.ZodOptional<z.ZodNumber>;
|
|
1184
|
+
quantity_curr: z.ZodNumber;
|
|
1185
|
+
price: z.ZodNumber;
|
|
1186
|
+
account_name: z.ZodString;
|
|
1187
|
+
order_side: z.ZodNumber;
|
|
1188
|
+
order_type: z.ZodNumber;
|
|
1189
|
+
trigger_price: z.ZodNumber;
|
|
1190
|
+
fill_type: z.ZodNumber;
|
|
1191
|
+
status: z.ZodString;
|
|
1192
|
+
filled_total: z.ZodOptional<z.ZodNumber>;
|
|
1193
|
+
filled_amount: z.ZodOptional<z.ZodNumber>;
|
|
1194
|
+
filled_fee: z.ZodOptional<z.ZodNumber>;
|
|
1195
|
+
created_at: z.ZodString;
|
|
1196
|
+
updated_at: z.ZodString;
|
|
1197
|
+
}, z.core.$strip>>;
|
|
1198
|
+
}, z.core.$strip>;
|
|
1199
|
+
type GetOpenOrdersResponse = z.infer<typeof getOpenOrdersResponseParser>;
|
|
1200
|
+
declare const getOrderHistoryParser: z.ZodObject<{
|
|
1201
|
+
account: z.ZodString;
|
|
1202
|
+
symbol: z.ZodOptional<z.ZodString>;
|
|
1203
|
+
offset: z.ZodDefault<z.ZodCoercedNumber<number>>;
|
|
1204
|
+
limit: z.ZodDefault<z.ZodCoercedNumber<number>>;
|
|
1205
|
+
ordinal_order_ids: z.ZodPipe<z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString>, z.ZodString]>>, z.ZodTransform<string[], string | string[] | undefined>>;
|
|
1206
|
+
trx_id: z.ZodOptional<z.ZodString>;
|
|
1207
|
+
status: z.ZodOptional<z.ZodString>;
|
|
1208
|
+
}, z.core.$strip>;
|
|
1209
|
+
type GetOrderHistory = z.input<typeof getOrderHistoryParser>;
|
|
1210
|
+
type GetOrderHistoryParsed = z.output<typeof getOrderHistoryParser>;
|
|
1211
|
+
declare const getOrderHistoryResponseParser: z.ZodObject<{
|
|
1212
|
+
sync: z.ZodNumber;
|
|
1213
|
+
count: z.ZodNumber;
|
|
1214
|
+
data: z.ZodArray<z.ZodObject<{
|
|
1215
|
+
block_num: z.ZodString;
|
|
1216
|
+
block_time: z.ZodString;
|
|
1217
|
+
order_id: z.ZodString;
|
|
1218
|
+
ordinal_order_id: z.ZodString;
|
|
1219
|
+
market_id: z.ZodNumber;
|
|
1220
|
+
quantity_init: z.ZodOptional<z.ZodNumber>;
|
|
1221
|
+
quantity_curr: z.ZodNumber;
|
|
1222
|
+
price: z.ZodNumber;
|
|
1223
|
+
account_name: z.ZodString;
|
|
1224
|
+
order_side: z.ZodNumber;
|
|
1225
|
+
order_type: z.ZodNumber;
|
|
1226
|
+
trigger_price: z.ZodNumber;
|
|
1227
|
+
fill_type: z.ZodNumber;
|
|
1228
|
+
status: z.ZodString;
|
|
1229
|
+
quantity_change: z.ZodNumber;
|
|
1230
|
+
filled_total: z.ZodOptional<z.ZodNumber>;
|
|
1231
|
+
filled_amount: z.ZodOptional<z.ZodNumber>;
|
|
1232
|
+
filled_fee: z.ZodOptional<z.ZodNumber>;
|
|
1233
|
+
seq: z.ZodString;
|
|
1234
|
+
trx_id: z.ZodString;
|
|
1235
|
+
}, z.core.$strip>>;
|
|
1236
|
+
}, z.core.$strip>;
|
|
1237
|
+
type GetOrderHistoryResponse = z.infer<typeof getOrderHistoryResponseParser>;
|
|
1238
|
+
declare const getOrderLifecycleParser: z.ZodObject<{
|
|
1239
|
+
order_id: z.ZodOptional<z.ZodString>;
|
|
1240
|
+
ordinal_order_id: z.ZodOptional<z.ZodString>;
|
|
1241
|
+
}, z.core.$strip>;
|
|
1242
|
+
type GetOrderLifecycle = z.input<typeof getOrderLifecycleParser>;
|
|
1243
|
+
type GetOrderLifecycleParsed = z.output<typeof getOrderLifecycleParser>;
|
|
1244
|
+
declare const getOrderLifecycleResponseParser: z.ZodObject<{
|
|
1245
|
+
sync: z.ZodNumber;
|
|
1246
|
+
data: z.ZodArray<z.ZodObject<{
|
|
1247
|
+
block_num: z.ZodString;
|
|
1248
|
+
block_time: z.ZodString;
|
|
1249
|
+
order_id: z.ZodString;
|
|
1250
|
+
ordinal_order_id: z.ZodString;
|
|
1251
|
+
market_id: z.ZodNumber;
|
|
1252
|
+
quantity_init: z.ZodOptional<z.ZodNumber>;
|
|
1253
|
+
quantity_curr: z.ZodNumber;
|
|
1254
|
+
price: z.ZodNumber;
|
|
1255
|
+
account_name: z.ZodString;
|
|
1256
|
+
order_side: z.ZodNumber;
|
|
1257
|
+
order_type: z.ZodNumber;
|
|
1258
|
+
trigger_price: z.ZodNumber;
|
|
1259
|
+
fill_type: z.ZodNumber;
|
|
1260
|
+
status: z.ZodString;
|
|
1261
|
+
quantity_change: z.ZodNumber;
|
|
1262
|
+
filled_total: z.ZodOptional<z.ZodNumber>;
|
|
1263
|
+
filled_amount: z.ZodOptional<z.ZodNumber>;
|
|
1264
|
+
filled_fee: z.ZodOptional<z.ZodNumber>;
|
|
1265
|
+
seq: z.ZodString;
|
|
1266
|
+
trx_id: z.ZodString;
|
|
1267
|
+
}, z.core.$strip>>;
|
|
1268
|
+
}, z.core.$strip>;
|
|
1269
|
+
type GetOrderLifecycleResponse = z.infer<typeof getOrderLifecycleResponseParser>;
|
|
1270
|
+
/**
|
|
1271
|
+
* Submit Order
|
|
1272
|
+
*/
|
|
1273
|
+
declare const postSubmitOrderParser: z.ZodObject<{
|
|
1274
|
+
serialized_tx_hex: z.ZodString;
|
|
1275
|
+
signatures: z.ZodArray<z.ZodString>;
|
|
1276
|
+
}, z.core.$strip>;
|
|
1277
|
+
type PostSubmitOrder = z.infer<typeof postSubmitOrderParser>;
|
|
1278
|
+
declare const postSubmitOrderResponseParser: z.ZodObject<{
|
|
1279
|
+
sync: z.ZodNumber;
|
|
1280
|
+
data: z.ZodObject<{
|
|
1281
|
+
trx_id: z.ZodString;
|
|
1282
|
+
block_time: z.ZodString;
|
|
1283
|
+
orders: z.ZodArray<z.ZodObject<{
|
|
1284
|
+
ordinal_order_id: z.ZodString;
|
|
1285
|
+
order_id: z.ZodString;
|
|
1286
|
+
status: z.ZodString;
|
|
1287
|
+
}, z.core.$strip>>;
|
|
1288
|
+
}, z.core.$strip>;
|
|
1289
|
+
}, z.core.$strip>;
|
|
1290
|
+
type PostSubmitOrderResponse = z.infer<typeof postSubmitOrderResponseParser>;
|
|
1291
|
+
/**
|
|
1292
|
+
* Serialize Order
|
|
1293
|
+
*/
|
|
1294
|
+
declare const postSerializeOrderParser: z.ZodObject<{
|
|
1295
|
+
transaction: z.ZodObject<{
|
|
1296
|
+
actions: z.ZodArray<z.ZodObject<{
|
|
1297
|
+
account: z.ZodString;
|
|
1298
|
+
name: z.ZodString;
|
|
1299
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
1300
|
+
actor: z.ZodString;
|
|
1301
|
+
permission: z.ZodString;
|
|
1302
|
+
}, z.core.$strip>>;
|
|
1303
|
+
data: z.ZodRecord<z.ZodString, z.ZodAny>;
|
|
1304
|
+
}, z.core.$strip>>;
|
|
1305
|
+
}, z.core.$strip>;
|
|
1306
|
+
}, z.core.$strip>;
|
|
1307
|
+
type PostSerializeOrder = z.infer<typeof postSerializeOrderParser>;
|
|
1308
|
+
declare const postSerializeOrderResponseParser: z.ZodObject<{
|
|
1309
|
+
data: z.ZodObject<{
|
|
1310
|
+
serialized_tx_hex: z.ZodString;
|
|
1311
|
+
digest_hex: z.ZodString;
|
|
1312
|
+
}, z.core.$strip>;
|
|
1313
|
+
}, z.core.$strip>;
|
|
1314
|
+
type PostSerializeOrderResponse = z.infer<typeof postSerializeOrderResponseParser>;
|
|
1315
|
+
/**
|
|
1316
|
+
* Depth
|
|
1317
|
+
*/
|
|
1318
|
+
declare const depthParser: z.ZodObject<{
|
|
1319
|
+
level: z.ZodNumber;
|
|
1320
|
+
ask: z.ZodNumber;
|
|
1321
|
+
bid: z.ZodNumber;
|
|
1322
|
+
count: z.ZodNumber;
|
|
1323
|
+
}, z.core.$strip>;
|
|
1324
|
+
type Depth = z.infer<typeof depthParser>;
|
|
1325
|
+
declare const getDepthParser: z.ZodObject<{
|
|
1326
|
+
symbol: z.ZodString;
|
|
1327
|
+
step: z.ZodCoercedNumber<number>;
|
|
1328
|
+
limit: z.ZodDefault<z.ZodCoercedNumber<number>>;
|
|
1329
|
+
}, z.core.$strip>;
|
|
1330
|
+
type GetDepth = z.input<typeof getDepthParser>;
|
|
1331
|
+
type GetDepthParsed = z.output<typeof getDepthParser>;
|
|
1332
|
+
declare const getDepthResponseParser: z.ZodObject<{
|
|
1333
|
+
sync: z.ZodNumber;
|
|
1334
|
+
data: z.ZodObject<{
|
|
1335
|
+
bids: z.ZodArray<z.ZodObject<{
|
|
1336
|
+
level: z.ZodNumber;
|
|
1337
|
+
ask: z.ZodNumber;
|
|
1338
|
+
bid: z.ZodNumber;
|
|
1339
|
+
count: z.ZodNumber;
|
|
1340
|
+
}, z.core.$strip>>;
|
|
1341
|
+
asks: z.ZodArray<z.ZodObject<{
|
|
1342
|
+
level: z.ZodNumber;
|
|
1343
|
+
ask: z.ZodNumber;
|
|
1344
|
+
bid: z.ZodNumber;
|
|
1345
|
+
count: z.ZodNumber;
|
|
1346
|
+
}, z.core.$strip>>;
|
|
1347
|
+
}, z.core.$strip>;
|
|
1348
|
+
}, z.core.$strip>;
|
|
1349
|
+
type GetDepthResponse = z.infer<typeof getDepthResponseParser>;
|
|
1350
|
+
/**
|
|
1351
|
+
* Daily
|
|
1352
|
+
*/
|
|
1353
|
+
declare const dailyParser: z.ZodObject<{
|
|
1354
|
+
market_id: z.ZodNumber;
|
|
1355
|
+
symbol: z.ZodString;
|
|
1356
|
+
open: z.ZodNumber;
|
|
1357
|
+
high: z.ZodNumber;
|
|
1358
|
+
low: z.ZodNumber;
|
|
1359
|
+
close: z.ZodNumber;
|
|
1360
|
+
volume_bid: z.ZodNumber;
|
|
1361
|
+
volume_ask: z.ZodNumber;
|
|
1362
|
+
change_percentage: z.ZodNumber;
|
|
1363
|
+
}, z.core.$strip>;
|
|
1364
|
+
type Daily = z.infer<typeof dailyParser>;
|
|
1365
|
+
declare const getDailyResponseParser: z.ZodObject<{
|
|
1366
|
+
sync: z.ZodNumber;
|
|
1367
|
+
data: z.ZodArray<z.ZodObject<{
|
|
1368
|
+
market_id: z.ZodNumber;
|
|
1369
|
+
symbol: z.ZodString;
|
|
1370
|
+
open: z.ZodNumber;
|
|
1371
|
+
high: z.ZodNumber;
|
|
1372
|
+
low: z.ZodNumber;
|
|
1373
|
+
close: z.ZodNumber;
|
|
1374
|
+
volume_bid: z.ZodNumber;
|
|
1375
|
+
volume_ask: z.ZodNumber;
|
|
1376
|
+
change_percentage: z.ZodNumber;
|
|
1377
|
+
}, z.core.$strip>>;
|
|
1378
|
+
}, z.core.$strip>;
|
|
1379
|
+
type GetDailyResponse = z.infer<typeof getDailyResponseParser>;
|
|
1380
|
+
/**
|
|
1381
|
+
* Markets
|
|
1382
|
+
*/
|
|
1383
|
+
declare const marketParser: z.ZodObject<{
|
|
1384
|
+
market_id: z.ZodNumber;
|
|
1385
|
+
symbol: z.ZodString;
|
|
1386
|
+
status_code: z.ZodNumber;
|
|
1387
|
+
type: z.ZodString;
|
|
1388
|
+
maker_fee: z.ZodNumber;
|
|
1389
|
+
taker_fee: z.ZodNumber;
|
|
1390
|
+
order_min: z.ZodNumber;
|
|
1391
|
+
bid_token: z.ZodObject<{
|
|
1392
|
+
code: z.ZodString;
|
|
1393
|
+
precision: z.ZodNumber;
|
|
1394
|
+
contract: z.ZodString;
|
|
1395
|
+
multiplier: z.ZodNumber;
|
|
1396
|
+
}, z.core.$strip>;
|
|
1397
|
+
ask_token: z.ZodObject<{
|
|
1398
|
+
code: z.ZodString;
|
|
1399
|
+
precision: z.ZodNumber;
|
|
1400
|
+
contract: z.ZodString;
|
|
1401
|
+
multiplier: z.ZodNumber;
|
|
1402
|
+
}, z.core.$strip>;
|
|
1403
|
+
}, z.core.$strip>;
|
|
1404
|
+
type Market = z.infer<typeof marketParser>;
|
|
1405
|
+
declare const dbMarketParser: z.ZodObject<{
|
|
1406
|
+
market_id: z.ZodNumber;
|
|
1407
|
+
order_min: z.ZodString;
|
|
1408
|
+
status_code: z.ZodNumber;
|
|
1409
|
+
ask_oracle_index: z.ZodString;
|
|
1410
|
+
bid_token_c: z.ZodString;
|
|
1411
|
+
bid_token_s: z.ZodString;
|
|
1412
|
+
bid_token_m: z.ZodString;
|
|
1413
|
+
ask_token_c: z.ZodString;
|
|
1414
|
+
ask_token_s: z.ZodString;
|
|
1415
|
+
ask_token_m: z.ZodString;
|
|
1416
|
+
created_at: z.ZodDate;
|
|
1417
|
+
updated_at: z.ZodDate;
|
|
1418
|
+
}, z.core.$strip>;
|
|
1419
|
+
type DbMarket = z.infer<typeof dbMarketParser>;
|
|
1420
|
+
declare const getMarketsResponseParser: z.ZodObject<{
|
|
1421
|
+
sync: z.ZodNumber;
|
|
1422
|
+
data: z.ZodArray<z.ZodObject<{
|
|
1423
|
+
market_id: z.ZodNumber;
|
|
1424
|
+
symbol: z.ZodString;
|
|
1425
|
+
status_code: z.ZodNumber;
|
|
1426
|
+
type: z.ZodString;
|
|
1427
|
+
maker_fee: z.ZodNumber;
|
|
1428
|
+
taker_fee: z.ZodNumber;
|
|
1429
|
+
order_min: z.ZodNumber;
|
|
1430
|
+
bid_token: z.ZodObject<{
|
|
1431
|
+
code: z.ZodString;
|
|
1432
|
+
precision: z.ZodNumber;
|
|
1433
|
+
contract: z.ZodString;
|
|
1434
|
+
multiplier: z.ZodNumber;
|
|
1435
|
+
}, z.core.$strip>;
|
|
1436
|
+
ask_token: z.ZodObject<{
|
|
1437
|
+
code: z.ZodString;
|
|
1438
|
+
precision: z.ZodNumber;
|
|
1439
|
+
contract: z.ZodString;
|
|
1440
|
+
multiplier: z.ZodNumber;
|
|
1441
|
+
}, z.core.$strip>;
|
|
1442
|
+
}, z.core.$strip>>;
|
|
1443
|
+
}, z.core.$strip>;
|
|
1444
|
+
type GetMarketsResponse = z.infer<typeof getMarketsResponseParser>;
|
|
1445
|
+
/**
|
|
1446
|
+
* Trades
|
|
1447
|
+
*/
|
|
1448
|
+
declare const tradeLogParser: z.ZodObject<{
|
|
1449
|
+
block_num: z.ZodString;
|
|
1450
|
+
block_time: z.ZodString;
|
|
1451
|
+
trade_id: z.ZodString;
|
|
1452
|
+
market_id: z.ZodNumber;
|
|
1453
|
+
price: z.ZodString;
|
|
1454
|
+
bid_user: z.ZodString;
|
|
1455
|
+
bid_user_order_id: z.ZodString;
|
|
1456
|
+
bid_total: z.ZodString;
|
|
1457
|
+
bid_amount: z.ZodString;
|
|
1458
|
+
bid_fee: z.ZodString;
|
|
1459
|
+
bid_referrer: z.ZodString;
|
|
1460
|
+
bid_referrer_fee: z.ZodString;
|
|
1461
|
+
ask_user: z.ZodString;
|
|
1462
|
+
ask_user_order_id: z.ZodString;
|
|
1463
|
+
ask_total: z.ZodString;
|
|
1464
|
+
ask_amount: z.ZodString;
|
|
1465
|
+
ask_fee: z.ZodString;
|
|
1466
|
+
ask_referrer: z.ZodString;
|
|
1467
|
+
ask_referrer_fee: z.ZodString;
|
|
1468
|
+
order_side: z.ZodNumber;
|
|
1469
|
+
trx_id: z.ZodString;
|
|
1470
|
+
}, z.core.$strip>;
|
|
1471
|
+
type TradeLog = z.infer<typeof tradeLogParser>;
|
|
1472
|
+
declare const tradeParser: z.ZodObject<{
|
|
1473
|
+
block_num: z.ZodString;
|
|
1474
|
+
block_time: z.ZodString;
|
|
1475
|
+
trade_id: z.ZodString;
|
|
1476
|
+
market_id: z.ZodNumber;
|
|
1477
|
+
price: z.ZodNumber;
|
|
1478
|
+
bid_user: z.ZodString;
|
|
1479
|
+
bid_user_order_id: z.ZodString;
|
|
1480
|
+
bid_user_ordinal_order_id: z.ZodString;
|
|
1481
|
+
bid_total: z.ZodNumber;
|
|
1482
|
+
bid_amount: z.ZodNumber;
|
|
1483
|
+
bid_fee: z.ZodNumber;
|
|
1484
|
+
bid_referrer: z.ZodString;
|
|
1485
|
+
bid_referrer_fee: z.ZodNumber;
|
|
1486
|
+
ask_user: z.ZodString;
|
|
1487
|
+
ask_user_order_id: z.ZodString;
|
|
1488
|
+
ask_user_ordinal_order_id: z.ZodString;
|
|
1489
|
+
ask_total: z.ZodNumber;
|
|
1490
|
+
ask_amount: z.ZodNumber;
|
|
1491
|
+
ask_fee: z.ZodNumber;
|
|
1492
|
+
ask_referrer: z.ZodString;
|
|
1493
|
+
ask_referrer_fee: z.ZodNumber;
|
|
1494
|
+
order_side: z.ZodNumber;
|
|
1495
|
+
trx_id: z.ZodString;
|
|
1496
|
+
}, z.core.$strip>;
|
|
1497
|
+
type Trade = z.infer<typeof tradeParser>;
|
|
1498
|
+
declare const getTradesParser: z.ZodObject<{
|
|
1499
|
+
symbol: z.ZodString;
|
|
1500
|
+
offset: z.ZodDefault<z.ZodCoercedNumber<number>>;
|
|
1501
|
+
limit: z.ZodDefault<z.ZodCoercedNumber<number>>;
|
|
1502
|
+
}, z.core.$strip>;
|
|
1503
|
+
type GetTrades = z.input<typeof getTradesParser>;
|
|
1504
|
+
type GetTradesParsed = z.output<typeof getTradesParser>;
|
|
1505
|
+
declare const getTradesResponseParser: z.ZodObject<{
|
|
1506
|
+
sync: z.ZodNumber;
|
|
1507
|
+
data: z.ZodArray<z.ZodObject<{
|
|
1508
|
+
block_num: z.ZodString;
|
|
1509
|
+
block_time: z.ZodString;
|
|
1510
|
+
trade_id: z.ZodString;
|
|
1511
|
+
market_id: z.ZodNumber;
|
|
1512
|
+
price: z.ZodNumber;
|
|
1513
|
+
bid_user: z.ZodString;
|
|
1514
|
+
bid_user_order_id: z.ZodString;
|
|
1515
|
+
bid_user_ordinal_order_id: z.ZodString;
|
|
1516
|
+
bid_total: z.ZodNumber;
|
|
1517
|
+
bid_amount: z.ZodNumber;
|
|
1518
|
+
bid_fee: z.ZodNumber;
|
|
1519
|
+
bid_referrer: z.ZodString;
|
|
1520
|
+
bid_referrer_fee: z.ZodNumber;
|
|
1521
|
+
ask_user: z.ZodString;
|
|
1522
|
+
ask_user_order_id: z.ZodString;
|
|
1523
|
+
ask_user_ordinal_order_id: z.ZodString;
|
|
1524
|
+
ask_total: z.ZodNumber;
|
|
1525
|
+
ask_amount: z.ZodNumber;
|
|
1526
|
+
ask_fee: z.ZodNumber;
|
|
1527
|
+
ask_referrer: z.ZodString;
|
|
1528
|
+
ask_referrer_fee: z.ZodNumber;
|
|
1529
|
+
order_side: z.ZodNumber;
|
|
1530
|
+
trx_id: z.ZodString;
|
|
1531
|
+
}, z.core.$strip>>;
|
|
1532
|
+
}, z.core.$strip>;
|
|
1533
|
+
type GetTradesResponse = z.infer<typeof getTradesResponseParser>;
|
|
1534
|
+
declare const getTradeHistoryParser: z.ZodObject<{
|
|
1535
|
+
account: z.ZodString;
|
|
1536
|
+
symbol: z.ZodOptional<z.ZodString>;
|
|
1537
|
+
offset: z.ZodDefault<z.ZodCoercedNumber<number>>;
|
|
1538
|
+
ordinal_order_ids: z.ZodPipe<z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString>, z.ZodString]>>, z.ZodTransform<string[], string | string[] | undefined>>;
|
|
1539
|
+
limit: z.ZodDefault<z.ZodCoercedNumber<number>>;
|
|
1540
|
+
}, z.core.$strip>;
|
|
1541
|
+
type GetTradeHistory = z.input<typeof getTradeHistoryParser>;
|
|
1542
|
+
type GetTradeHistoryParsed = z.output<typeof getTradeHistoryParser>;
|
|
1543
|
+
declare const getTradeHistoryResponseParser: z.ZodObject<{
|
|
1544
|
+
sync: z.ZodNumber;
|
|
1545
|
+
count: z.ZodNumber;
|
|
1546
|
+
data: z.ZodArray<z.ZodObject<{
|
|
1547
|
+
block_num: z.ZodString;
|
|
1548
|
+
block_time: z.ZodString;
|
|
1549
|
+
trade_id: z.ZodString;
|
|
1550
|
+
market_id: z.ZodNumber;
|
|
1551
|
+
price: z.ZodNumber;
|
|
1552
|
+
bid_user: z.ZodString;
|
|
1553
|
+
bid_user_order_id: z.ZodString;
|
|
1554
|
+
bid_user_ordinal_order_id: z.ZodString;
|
|
1555
|
+
bid_total: z.ZodNumber;
|
|
1556
|
+
bid_amount: z.ZodNumber;
|
|
1557
|
+
bid_fee: z.ZodNumber;
|
|
1558
|
+
bid_referrer: z.ZodString;
|
|
1559
|
+
bid_referrer_fee: z.ZodNumber;
|
|
1560
|
+
ask_user: z.ZodString;
|
|
1561
|
+
ask_user_order_id: z.ZodString;
|
|
1562
|
+
ask_user_ordinal_order_id: z.ZodString;
|
|
1563
|
+
ask_total: z.ZodNumber;
|
|
1564
|
+
ask_amount: z.ZodNumber;
|
|
1565
|
+
ask_fee: z.ZodNumber;
|
|
1566
|
+
ask_referrer: z.ZodString;
|
|
1567
|
+
ask_referrer_fee: z.ZodNumber;
|
|
1568
|
+
order_side: z.ZodNumber;
|
|
1569
|
+
trx_id: z.ZodString;
|
|
1570
|
+
}, z.core.$strip>>;
|
|
1571
|
+
}, z.core.$strip>;
|
|
1572
|
+
type GetTradeHistoryResponse = z.infer<typeof getTradeHistoryResponseParser>;
|
|
1573
|
+
/**
|
|
1574
|
+
* SYNC
|
|
1575
|
+
*/
|
|
1576
|
+
declare const syncParser: z.ZodObject<{
|
|
1577
|
+
sourceid: z.ZodNumber;
|
|
1578
|
+
block_num: z.ZodString;
|
|
1579
|
+
block_time: z.ZodString;
|
|
1580
|
+
irreversible: z.ZodString;
|
|
1581
|
+
is_master: z.ZodNumber;
|
|
1582
|
+
last_updated: z.ZodString;
|
|
1583
|
+
}, z.core.$strip>;
|
|
1584
|
+
type Sync = z.infer<typeof syncParser>;
|
|
1585
|
+
declare const getSyncResponseParser: z.ZodObject<{
|
|
1586
|
+
dbSecondsBehind: z.ZodNumber;
|
|
1587
|
+
chronicleSecondsBehind: z.ZodNumber;
|
|
1588
|
+
maxSecondsBehind: z.ZodNumber;
|
|
1589
|
+
}, z.core.$strip>;
|
|
1590
|
+
type GetSyncResponse = z.infer<typeof getSyncResponseParser>;
|
|
1591
|
+
/**
|
|
1592
|
+
* Referral Totals
|
|
1593
|
+
*/
|
|
1594
|
+
declare const refferalTotalParser: z.ZodObject<{
|
|
1595
|
+
referrer: z.ZodString;
|
|
1596
|
+
market_id: z.ZodNumber;
|
|
1597
|
+
bid_fee: z.ZodNumber;
|
|
1598
|
+
bid_total: z.ZodNumber;
|
|
1599
|
+
ask_fee: z.ZodNumber;
|
|
1600
|
+
ask_total: z.ZodNumber;
|
|
1601
|
+
}, z.core.$strip>;
|
|
1602
|
+
type ReferralTotal = z.infer<typeof refferalTotalParser>;
|
|
1603
|
+
declare const getReferralTotalsParser: z.ZodObject<{
|
|
1604
|
+
referrer: z.ZodString;
|
|
1605
|
+
}, z.core.$strip>;
|
|
1606
|
+
type GetReferralTotals = z.input<typeof getReferralTotalsParser>;
|
|
1607
|
+
type GetReferralTotalsParsed = z.output<typeof getReferralTotalsParser>;
|
|
1608
|
+
declare const getReferralTotalsResponseParser: z.ZodObject<{
|
|
1609
|
+
sync: z.ZodNumber;
|
|
1610
|
+
data: z.ZodArray<z.ZodObject<{
|
|
1611
|
+
referrer: z.ZodString;
|
|
1612
|
+
market_id: z.ZodNumber;
|
|
1613
|
+
bid_fee: z.ZodNumber;
|
|
1614
|
+
bid_total: z.ZodNumber;
|
|
1615
|
+
ask_fee: z.ZodNumber;
|
|
1616
|
+
ask_total: z.ZodNumber;
|
|
1617
|
+
}, z.core.$strip>>;
|
|
1618
|
+
}, z.core.$strip>;
|
|
1619
|
+
type GetReferralTotalsResponse = z.infer<typeof getReferralTotalsResponseParser>;
|
|
1620
|
+
/**
|
|
1621
|
+
* Referrals
|
|
1622
|
+
*/
|
|
1623
|
+
declare const refferalParser: z.ZodObject<{
|
|
1624
|
+
referred_user: z.ZodString;
|
|
1625
|
+
}, z.core.$strip>;
|
|
1626
|
+
type Referral = z.infer<typeof refferalParser>;
|
|
1627
|
+
declare const getReferralsParser: z.ZodObject<{
|
|
1628
|
+
referrer: z.ZodString;
|
|
1629
|
+
}, z.core.$strip>;
|
|
1630
|
+
type GetReferrals = z.input<typeof getReferralsParser>;
|
|
1631
|
+
type GetReferralsParsed = z.output<typeof getReferralsParser>;
|
|
1632
|
+
declare const getReferralsResponseParser: z.ZodObject<{
|
|
1633
|
+
sync: z.ZodNumber;
|
|
1634
|
+
data: z.ZodArray<z.ZodObject<{
|
|
1635
|
+
referred_user: z.ZodString;
|
|
1636
|
+
}, z.core.$strip>>;
|
|
1637
|
+
}, z.core.$strip>;
|
|
1638
|
+
type GetReferralsResponse = z.infer<typeof getReferralsResponseParser>;
|
|
1639
|
+
/**
|
|
1640
|
+
* Leaderboard
|
|
1641
|
+
*/
|
|
1642
|
+
declare const leaderboardParser: z.ZodObject<{
|
|
1643
|
+
user: z.ZodString;
|
|
1644
|
+
total: z.ZodNumber;
|
|
1645
|
+
}, z.core.$strip>;
|
|
1646
|
+
type Leaderboard = z.infer<typeof leaderboardParser>;
|
|
1647
|
+
declare const getLeaderboardParser: z.ZodObject<{
|
|
1648
|
+
market_ids: z.ZodPipe<z.ZodUnion<[z.ZodArray<z.ZodCoercedNumber<number>>, z.ZodCoercedNumber<number>]>, z.ZodTransform<number[], number | number[]>>;
|
|
1649
|
+
from: z.ZodString;
|
|
1650
|
+
to: z.ZodString;
|
|
1651
|
+
exclude_zero_fee: z.ZodPrefault<z.ZodUnion<[z.ZodBoolean, z.ZodPipe<z.ZodEnum<{
|
|
1652
|
+
true: "true";
|
|
1653
|
+
false: "false";
|
|
1654
|
+
}>, z.ZodTransform<boolean, "true" | "false">>]>>;
|
|
1655
|
+
}, z.core.$strip>;
|
|
1656
|
+
type GetLeaderboard = z.input<typeof getLeaderboardParser>;
|
|
1657
|
+
type GetLeaderboardParsed = z.output<typeof getLeaderboardParser>;
|
|
1658
|
+
declare const getLeaderboardResponseParser: z.ZodObject<{
|
|
1659
|
+
sync: z.ZodNumber;
|
|
1660
|
+
data: z.ZodArray<z.ZodObject<{
|
|
1661
|
+
user: z.ZodString;
|
|
1662
|
+
total: z.ZodNumber;
|
|
1663
|
+
}, z.core.$strip>>;
|
|
1664
|
+
}, z.core.$strip>;
|
|
1665
|
+
type GetLeaderboardResponse = z.infer<typeof getLeaderboardResponseParser>;
|
|
1666
|
+
/**
|
|
1667
|
+
* History Transaction
|
|
1668
|
+
*/
|
|
1669
|
+
declare const historyPartialParser: z.ZodObject<{
|
|
1670
|
+
expiration: z.ZodObject<{
|
|
1671
|
+
utc_seconds: z.ZodString;
|
|
1672
|
+
}, z.core.$strip>;
|
|
1673
|
+
ref_block_num: z.ZodString;
|
|
1674
|
+
ref_block_prefix: z.ZodString;
|
|
1675
|
+
max_net_usage_words: z.ZodString;
|
|
1676
|
+
max_cpu_usage_ms: z.ZodString;
|
|
1677
|
+
delay_sec: z.ZodString;
|
|
1678
|
+
transaction_extensions: z.ZodArray<z.ZodUnknown>;
|
|
1679
|
+
signatures: z.ZodArray<z.ZodString>;
|
|
1680
|
+
context_free_data: z.ZodArray<z.ZodUnknown>;
|
|
1681
|
+
}, z.core.$strip>;
|
|
1682
|
+
type HistoryPartial = z.infer<typeof historyPartialParser>;
|
|
1683
|
+
declare const actParser: z.ZodObject<{
|
|
1684
|
+
account: z.ZodString;
|
|
1685
|
+
name: z.ZodString;
|
|
1686
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
1687
|
+
actor: z.ZodString;
|
|
1688
|
+
permission: z.ZodString;
|
|
1689
|
+
}, z.core.$strip>>;
|
|
1690
|
+
data: z.ZodAny;
|
|
1691
|
+
}, z.core.$strip>;
|
|
1692
|
+
type HistoryAct = z.infer<typeof actParser>;
|
|
1693
|
+
declare const receiptParser: z.ZodObject<{
|
|
1694
|
+
receiver: z.ZodString;
|
|
1695
|
+
act_digest: z.ZodString;
|
|
1696
|
+
global_sequence: z.ZodString;
|
|
1697
|
+
recv_sequence: z.ZodString;
|
|
1698
|
+
auth_sequence: z.ZodArray<z.ZodObject<{
|
|
1699
|
+
account: z.ZodString;
|
|
1700
|
+
sequence: z.ZodString;
|
|
1701
|
+
}, z.core.$strip>>;
|
|
1702
|
+
code_sequence: z.ZodString;
|
|
1703
|
+
abi_sequence: z.ZodString;
|
|
1704
|
+
}, z.core.$strip>;
|
|
1705
|
+
type HistoryReceipt = z.infer<typeof receiptParser>;
|
|
1706
|
+
declare const actionTraceParser: z.ZodObject<{
|
|
1707
|
+
action_ordinal: z.ZodString;
|
|
1708
|
+
creator_action_ordinal: z.ZodString;
|
|
1709
|
+
receipt: z.ZodObject<{
|
|
1710
|
+
receiver: z.ZodString;
|
|
1711
|
+
act_digest: z.ZodString;
|
|
1712
|
+
global_sequence: z.ZodString;
|
|
1713
|
+
recv_sequence: z.ZodString;
|
|
1714
|
+
auth_sequence: z.ZodArray<z.ZodObject<{
|
|
1715
|
+
account: z.ZodString;
|
|
1716
|
+
sequence: z.ZodString;
|
|
1717
|
+
}, z.core.$strip>>;
|
|
1718
|
+
code_sequence: z.ZodString;
|
|
1719
|
+
abi_sequence: z.ZodString;
|
|
1720
|
+
}, z.core.$strip>;
|
|
1721
|
+
receiver: z.ZodString;
|
|
1722
|
+
act: z.ZodObject<{
|
|
1723
|
+
account: z.ZodString;
|
|
1724
|
+
name: z.ZodString;
|
|
1725
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
1726
|
+
actor: z.ZodString;
|
|
1727
|
+
permission: z.ZodString;
|
|
1728
|
+
}, z.core.$strip>>;
|
|
1729
|
+
data: z.ZodAny;
|
|
1730
|
+
}, z.core.$strip>;
|
|
1731
|
+
context_free: z.ZodString;
|
|
1732
|
+
elapsed: z.ZodString;
|
|
1733
|
+
console: z.ZodString;
|
|
1734
|
+
account_ram_deltas: z.ZodArray<z.ZodObject<{
|
|
1735
|
+
account: z.ZodString;
|
|
1736
|
+
delta: z.ZodString;
|
|
1737
|
+
}, z.core.$strip>>;
|
|
1738
|
+
except: z.ZodString;
|
|
1739
|
+
error_code: z.ZodNullable<z.ZodString>;
|
|
1740
|
+
return_value: z.ZodString;
|
|
1741
|
+
}, z.core.$strip>;
|
|
1742
|
+
type HistoryActionTrace = z.infer<typeof actionTraceParser>;
|
|
1743
|
+
declare const traceParser: z.ZodObject<{
|
|
1744
|
+
id: z.ZodString;
|
|
1745
|
+
status: z.ZodString;
|
|
1746
|
+
cpu_usage_us: z.ZodString;
|
|
1747
|
+
net_usage_words: z.ZodString;
|
|
1748
|
+
elapsed: z.ZodString;
|
|
1749
|
+
net_usage: z.ZodString;
|
|
1750
|
+
scheduled: z.ZodString;
|
|
1751
|
+
action_traces: z.ZodArray<z.ZodObject<{
|
|
1752
|
+
action_ordinal: z.ZodString;
|
|
1753
|
+
creator_action_ordinal: z.ZodString;
|
|
1754
|
+
receipt: z.ZodObject<{
|
|
1755
|
+
receiver: z.ZodString;
|
|
1756
|
+
act_digest: z.ZodString;
|
|
1757
|
+
global_sequence: z.ZodString;
|
|
1758
|
+
recv_sequence: z.ZodString;
|
|
1759
|
+
auth_sequence: z.ZodArray<z.ZodObject<{
|
|
1760
|
+
account: z.ZodString;
|
|
1761
|
+
sequence: z.ZodString;
|
|
1762
|
+
}, z.core.$strip>>;
|
|
1763
|
+
code_sequence: z.ZodString;
|
|
1764
|
+
abi_sequence: z.ZodString;
|
|
1765
|
+
}, z.core.$strip>;
|
|
1766
|
+
receiver: z.ZodString;
|
|
1767
|
+
act: z.ZodObject<{
|
|
1768
|
+
account: z.ZodString;
|
|
1769
|
+
name: z.ZodString;
|
|
1770
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
1771
|
+
actor: z.ZodString;
|
|
1772
|
+
permission: z.ZodString;
|
|
1773
|
+
}, z.core.$strip>>;
|
|
1774
|
+
data: z.ZodAny;
|
|
1775
|
+
}, z.core.$strip>;
|
|
1776
|
+
context_free: z.ZodString;
|
|
1777
|
+
elapsed: z.ZodString;
|
|
1778
|
+
console: z.ZodString;
|
|
1779
|
+
account_ram_deltas: z.ZodArray<z.ZodObject<{
|
|
1780
|
+
account: z.ZodString;
|
|
1781
|
+
delta: z.ZodString;
|
|
1782
|
+
}, z.core.$strip>>;
|
|
1783
|
+
except: z.ZodString;
|
|
1784
|
+
error_code: z.ZodNullable<z.ZodString>;
|
|
1785
|
+
return_value: z.ZodString;
|
|
1786
|
+
}, z.core.$strip>>;
|
|
1787
|
+
account_ram_delta: z.ZodNullable<z.ZodArray<z.ZodObject<{
|
|
1788
|
+
account: z.ZodString;
|
|
1789
|
+
delta: z.ZodString;
|
|
1790
|
+
}, z.core.$strip>>>;
|
|
1791
|
+
except: z.ZodString;
|
|
1792
|
+
error_code: z.ZodNullable<z.ZodString>;
|
|
1793
|
+
failed_dtrx_trace: z.ZodArray<z.ZodUnknown>;
|
|
1794
|
+
partial: z.ZodObject<{
|
|
1795
|
+
expiration: z.ZodObject<{
|
|
1796
|
+
utc_seconds: z.ZodString;
|
|
1797
|
+
}, z.core.$strip>;
|
|
1798
|
+
ref_block_num: z.ZodString;
|
|
1799
|
+
ref_block_prefix: z.ZodString;
|
|
1800
|
+
max_net_usage_words: z.ZodString;
|
|
1801
|
+
max_cpu_usage_ms: z.ZodString;
|
|
1802
|
+
delay_sec: z.ZodString;
|
|
1803
|
+
transaction_extensions: z.ZodArray<z.ZodUnknown>;
|
|
1804
|
+
signatures: z.ZodArray<z.ZodString>;
|
|
1805
|
+
context_free_data: z.ZodArray<z.ZodUnknown>;
|
|
1806
|
+
}, z.core.$strip>;
|
|
1807
|
+
}, z.core.$strip>;
|
|
1808
|
+
type HistoryTrace = z.infer<typeof traceParser>;
|
|
1809
|
+
declare const historyTransactionParser: z.ZodObject<{
|
|
1810
|
+
seq: z.ZodString;
|
|
1811
|
+
block_num: z.ZodString;
|
|
1812
|
+
block_time: z.ZodString;
|
|
1813
|
+
trx_id: z.ZodString;
|
|
1814
|
+
trace: z.ZodObject<{
|
|
1815
|
+
block_num: z.ZodString;
|
|
1816
|
+
block_timestamp: z.ZodString;
|
|
1817
|
+
trace: z.ZodObject<{
|
|
1818
|
+
id: z.ZodString;
|
|
1819
|
+
status: z.ZodString;
|
|
1820
|
+
cpu_usage_us: z.ZodString;
|
|
1821
|
+
net_usage_words: z.ZodString;
|
|
1822
|
+
elapsed: z.ZodString;
|
|
1823
|
+
net_usage: z.ZodString;
|
|
1824
|
+
scheduled: z.ZodString;
|
|
1825
|
+
action_traces: z.ZodArray<z.ZodObject<{
|
|
1826
|
+
action_ordinal: z.ZodString;
|
|
1827
|
+
creator_action_ordinal: z.ZodString;
|
|
1828
|
+
receipt: z.ZodObject<{
|
|
1829
|
+
receiver: z.ZodString;
|
|
1830
|
+
act_digest: z.ZodString;
|
|
1831
|
+
global_sequence: z.ZodString;
|
|
1832
|
+
recv_sequence: z.ZodString;
|
|
1833
|
+
auth_sequence: z.ZodArray<z.ZodObject<{
|
|
1834
|
+
account: z.ZodString;
|
|
1835
|
+
sequence: z.ZodString;
|
|
1836
|
+
}, z.core.$strip>>;
|
|
1837
|
+
code_sequence: z.ZodString;
|
|
1838
|
+
abi_sequence: z.ZodString;
|
|
1839
|
+
}, z.core.$strip>;
|
|
1840
|
+
receiver: z.ZodString;
|
|
1841
|
+
act: z.ZodObject<{
|
|
1842
|
+
account: z.ZodString;
|
|
1843
|
+
name: z.ZodString;
|
|
1844
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
1845
|
+
actor: z.ZodString;
|
|
1846
|
+
permission: z.ZodString;
|
|
1847
|
+
}, z.core.$strip>>;
|
|
1848
|
+
data: z.ZodAny;
|
|
1849
|
+
}, z.core.$strip>;
|
|
1850
|
+
context_free: z.ZodString;
|
|
1851
|
+
elapsed: z.ZodString;
|
|
1852
|
+
console: z.ZodString;
|
|
1853
|
+
account_ram_deltas: z.ZodArray<z.ZodObject<{
|
|
1854
|
+
account: z.ZodString;
|
|
1855
|
+
delta: z.ZodString;
|
|
1856
|
+
}, z.core.$strip>>;
|
|
1857
|
+
except: z.ZodString;
|
|
1858
|
+
error_code: z.ZodNullable<z.ZodString>;
|
|
1859
|
+
return_value: z.ZodString;
|
|
1860
|
+
}, z.core.$strip>>;
|
|
1861
|
+
account_ram_delta: z.ZodNullable<z.ZodArray<z.ZodObject<{
|
|
1862
|
+
account: z.ZodString;
|
|
1863
|
+
delta: z.ZodString;
|
|
1864
|
+
}, z.core.$strip>>>;
|
|
1865
|
+
except: z.ZodString;
|
|
1866
|
+
error_code: z.ZodNullable<z.ZodString>;
|
|
1867
|
+
failed_dtrx_trace: z.ZodArray<z.ZodUnknown>;
|
|
1868
|
+
partial: z.ZodObject<{
|
|
1869
|
+
expiration: z.ZodObject<{
|
|
1870
|
+
utc_seconds: z.ZodString;
|
|
1871
|
+
}, z.core.$strip>;
|
|
1872
|
+
ref_block_num: z.ZodString;
|
|
1873
|
+
ref_block_prefix: z.ZodString;
|
|
1874
|
+
max_net_usage_words: z.ZodString;
|
|
1875
|
+
max_cpu_usage_ms: z.ZodString;
|
|
1876
|
+
delay_sec: z.ZodString;
|
|
1877
|
+
transaction_extensions: z.ZodArray<z.ZodUnknown>;
|
|
1878
|
+
signatures: z.ZodArray<z.ZodString>;
|
|
1879
|
+
context_free_data: z.ZodArray<z.ZodUnknown>;
|
|
1880
|
+
}, z.core.$strip>;
|
|
1881
|
+
}, z.core.$strip>;
|
|
1882
|
+
}, z.core.$strip>;
|
|
1883
|
+
irreversible: z.ZodBoolean;
|
|
1884
|
+
}, z.core.$strip>;
|
|
1885
|
+
type HistoryTransaction = z.infer<typeof historyTransactionParser>;
|
|
1886
|
+
declare const getHistoryTransactionResponseParser: z.ZodObject<{
|
|
1887
|
+
data: z.ZodNullable<z.ZodObject<{
|
|
1888
|
+
seq: z.ZodString;
|
|
1889
|
+
block_num: z.ZodString;
|
|
1890
|
+
block_time: z.ZodString;
|
|
1891
|
+
trx_id: z.ZodString;
|
|
1892
|
+
trace: z.ZodObject<{
|
|
1893
|
+
block_num: z.ZodString;
|
|
1894
|
+
block_timestamp: z.ZodString;
|
|
1895
|
+
trace: z.ZodObject<{
|
|
1896
|
+
id: z.ZodString;
|
|
1897
|
+
status: z.ZodString;
|
|
1898
|
+
cpu_usage_us: z.ZodString;
|
|
1899
|
+
net_usage_words: z.ZodString;
|
|
1900
|
+
elapsed: z.ZodString;
|
|
1901
|
+
net_usage: z.ZodString;
|
|
1902
|
+
scheduled: z.ZodString;
|
|
1903
|
+
action_traces: z.ZodArray<z.ZodObject<{
|
|
1904
|
+
action_ordinal: z.ZodString;
|
|
1905
|
+
creator_action_ordinal: z.ZodString;
|
|
1906
|
+
receipt: z.ZodObject<{
|
|
1907
|
+
receiver: z.ZodString;
|
|
1908
|
+
act_digest: z.ZodString;
|
|
1909
|
+
global_sequence: z.ZodString;
|
|
1910
|
+
recv_sequence: z.ZodString;
|
|
1911
|
+
auth_sequence: z.ZodArray<z.ZodObject<{
|
|
1912
|
+
account: z.ZodString;
|
|
1913
|
+
sequence: z.ZodString;
|
|
1914
|
+
}, z.core.$strip>>;
|
|
1915
|
+
code_sequence: z.ZodString;
|
|
1916
|
+
abi_sequence: z.ZodString;
|
|
1917
|
+
}, z.core.$strip>;
|
|
1918
|
+
receiver: z.ZodString;
|
|
1919
|
+
act: z.ZodObject<{
|
|
1920
|
+
account: z.ZodString;
|
|
1921
|
+
name: z.ZodString;
|
|
1922
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
1923
|
+
actor: z.ZodString;
|
|
1924
|
+
permission: z.ZodString;
|
|
1925
|
+
}, z.core.$strip>>;
|
|
1926
|
+
data: z.ZodAny;
|
|
1927
|
+
}, z.core.$strip>;
|
|
1928
|
+
context_free: z.ZodString;
|
|
1929
|
+
elapsed: z.ZodString;
|
|
1930
|
+
console: z.ZodString;
|
|
1931
|
+
account_ram_deltas: z.ZodArray<z.ZodObject<{
|
|
1932
|
+
account: z.ZodString;
|
|
1933
|
+
delta: z.ZodString;
|
|
1934
|
+
}, z.core.$strip>>;
|
|
1935
|
+
except: z.ZodString;
|
|
1936
|
+
error_code: z.ZodNullable<z.ZodString>;
|
|
1937
|
+
return_value: z.ZodString;
|
|
1938
|
+
}, z.core.$strip>>;
|
|
1939
|
+
account_ram_delta: z.ZodNullable<z.ZodArray<z.ZodObject<{
|
|
1940
|
+
account: z.ZodString;
|
|
1941
|
+
delta: z.ZodString;
|
|
1942
|
+
}, z.core.$strip>>>;
|
|
1943
|
+
except: z.ZodString;
|
|
1944
|
+
error_code: z.ZodNullable<z.ZodString>;
|
|
1945
|
+
failed_dtrx_trace: z.ZodArray<z.ZodUnknown>;
|
|
1946
|
+
partial: z.ZodObject<{
|
|
1947
|
+
expiration: z.ZodObject<{
|
|
1948
|
+
utc_seconds: z.ZodString;
|
|
1949
|
+
}, z.core.$strip>;
|
|
1950
|
+
ref_block_num: z.ZodString;
|
|
1951
|
+
ref_block_prefix: z.ZodString;
|
|
1952
|
+
max_net_usage_words: z.ZodString;
|
|
1953
|
+
max_cpu_usage_ms: z.ZodString;
|
|
1954
|
+
delay_sec: z.ZodString;
|
|
1955
|
+
transaction_extensions: z.ZodArray<z.ZodUnknown>;
|
|
1956
|
+
signatures: z.ZodArray<z.ZodString>;
|
|
1957
|
+
context_free_data: z.ZodArray<z.ZodUnknown>;
|
|
1958
|
+
}, z.core.$strip>;
|
|
1959
|
+
}, z.core.$strip>;
|
|
1960
|
+
}, z.core.$strip>;
|
|
1961
|
+
irreversible: z.ZodBoolean;
|
|
1962
|
+
}, z.core.$strip>>;
|
|
1963
|
+
}, z.core.$strip>;
|
|
1964
|
+
type GetHistoryTransactionResponse = z.input<typeof getHistoryTransactionResponseParser>;
|
|
1965
|
+
declare const chronicleTransactionParser: z.ZodObject<{
|
|
1966
|
+
block_num: z.ZodString;
|
|
1967
|
+
block_timestamp: z.ZodString;
|
|
1968
|
+
trace: z.ZodObject<{
|
|
1969
|
+
id: z.ZodString;
|
|
1970
|
+
status: z.ZodString;
|
|
1971
|
+
cpu_usage_us: z.ZodString;
|
|
1972
|
+
net_usage_words: z.ZodString;
|
|
1973
|
+
elapsed: z.ZodString;
|
|
1974
|
+
net_usage: z.ZodString;
|
|
1975
|
+
scheduled: z.ZodString;
|
|
1976
|
+
action_traces: z.ZodArray<z.ZodObject<{
|
|
1977
|
+
action_ordinal: z.ZodString;
|
|
1978
|
+
creator_action_ordinal: z.ZodString;
|
|
1979
|
+
receipt: z.ZodObject<{
|
|
1980
|
+
receiver: z.ZodString;
|
|
1981
|
+
act_digest: z.ZodString;
|
|
1982
|
+
global_sequence: z.ZodString;
|
|
1983
|
+
recv_sequence: z.ZodString;
|
|
1984
|
+
auth_sequence: z.ZodArray<z.ZodObject<{
|
|
1985
|
+
account: z.ZodString;
|
|
1986
|
+
sequence: z.ZodString;
|
|
1987
|
+
}, z.core.$strip>>;
|
|
1988
|
+
code_sequence: z.ZodString;
|
|
1989
|
+
abi_sequence: z.ZodString;
|
|
1990
|
+
}, z.core.$strip>;
|
|
1991
|
+
receiver: z.ZodString;
|
|
1992
|
+
act: z.ZodObject<{
|
|
1993
|
+
account: z.ZodString;
|
|
1994
|
+
name: z.ZodString;
|
|
1995
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
1996
|
+
actor: z.ZodString;
|
|
1997
|
+
permission: z.ZodString;
|
|
1998
|
+
}, z.core.$strip>>;
|
|
1999
|
+
data: z.ZodAny;
|
|
2000
|
+
}, z.core.$strip>;
|
|
2001
|
+
context_free: z.ZodString;
|
|
2002
|
+
elapsed: z.ZodString;
|
|
2003
|
+
console: z.ZodString;
|
|
2004
|
+
account_ram_deltas: z.ZodArray<z.ZodObject<{
|
|
2005
|
+
account: z.ZodString;
|
|
2006
|
+
delta: z.ZodString;
|
|
2007
|
+
}, z.core.$strip>>;
|
|
2008
|
+
except: z.ZodString;
|
|
2009
|
+
error_code: z.ZodNullable<z.ZodString>;
|
|
2010
|
+
return_value: z.ZodString;
|
|
2011
|
+
}, z.core.$strip>>;
|
|
2012
|
+
account_ram_delta: z.ZodNullable<z.ZodArray<z.ZodObject<{
|
|
2013
|
+
account: z.ZodString;
|
|
2014
|
+
delta: z.ZodString;
|
|
2015
|
+
}, z.core.$strip>>>;
|
|
2016
|
+
except: z.ZodString;
|
|
2017
|
+
error_code: z.ZodNullable<z.ZodString>;
|
|
2018
|
+
failed_dtrx_trace: z.ZodArray<z.ZodUnknown>;
|
|
2019
|
+
partial: z.ZodObject<{
|
|
2020
|
+
expiration: z.ZodObject<{
|
|
2021
|
+
utc_seconds: z.ZodString;
|
|
2022
|
+
}, z.core.$strip>;
|
|
2023
|
+
ref_block_num: z.ZodString;
|
|
2024
|
+
ref_block_prefix: z.ZodString;
|
|
2025
|
+
max_net_usage_words: z.ZodString;
|
|
2026
|
+
max_cpu_usage_ms: z.ZodString;
|
|
2027
|
+
delay_sec: z.ZodString;
|
|
2028
|
+
transaction_extensions: z.ZodArray<z.ZodUnknown>;
|
|
2029
|
+
signatures: z.ZodArray<z.ZodString>;
|
|
2030
|
+
context_free_data: z.ZodArray<z.ZodUnknown>;
|
|
2031
|
+
}, z.core.$strip>;
|
|
2032
|
+
}, z.core.$strip>;
|
|
2033
|
+
}, z.core.$strip>;
|
|
2034
|
+
type ChronicleTransaction = z.infer<typeof chronicleTransactionParser>;
|
|
2035
|
+
declare const dbHistoryTransactionParser: z.ZodObject<{
|
|
2036
|
+
seq: z.ZodString;
|
|
2037
|
+
block_num: z.ZodString;
|
|
2038
|
+
block_time: z.ZodString;
|
|
2039
|
+
trx_id: z.ZodString;
|
|
2040
|
+
trace: z.ZodAny;
|
|
2041
|
+
}, z.core.$strip>;
|
|
2042
|
+
type DbHistoryTransaction = z.infer<typeof dbHistoryTransactionParser>;
|
|
2043
|
+
/**
|
|
2044
|
+
* History Actions
|
|
2045
|
+
*/
|
|
2046
|
+
declare const getHistoryActionsParser: z.ZodObject<{
|
|
2047
|
+
account: z.ZodString;
|
|
2048
|
+
contract_filters: z.ZodPipe<z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString>, z.ZodString]>>, z.ZodTransform<string[], string | string[] | undefined>>;
|
|
2049
|
+
account_seq_from: z.ZodOptional<z.ZodString>;
|
|
2050
|
+
account_seq_to: z.ZodOptional<z.ZodString>;
|
|
2051
|
+
date_from: z.ZodOptional<z.ZodString>;
|
|
2052
|
+
date_to: z.ZodOptional<z.ZodString>;
|
|
2053
|
+
direction: z.ZodOptional<z.ZodEnum<{
|
|
2054
|
+
asc: "asc";
|
|
2055
|
+
desc: "desc";
|
|
2056
|
+
}>>;
|
|
2057
|
+
limit: z.ZodDefault<z.ZodCoercedNumber<number>>;
|
|
2058
|
+
}, z.core.$strip>;
|
|
2059
|
+
type GetHistoryActions = z.input<typeof getHistoryActionsParser>;
|
|
2060
|
+
type GetHistoryActionsParsed = z.output<typeof getHistoryActionsParser>;
|
|
2061
|
+
declare const historyActionParser: z.ZodObject<{
|
|
2062
|
+
block_num: z.ZodNumber;
|
|
2063
|
+
block_time: z.ZodString;
|
|
2064
|
+
trx_id: z.ZodString;
|
|
2065
|
+
account_action_seq: z.ZodNumber;
|
|
2066
|
+
global_action_seq: z.ZodNumber;
|
|
2067
|
+
action_trace: z.ZodObject<{
|
|
2068
|
+
action_ordinal: z.ZodString;
|
|
2069
|
+
creator_action_ordinal: z.ZodString;
|
|
2070
|
+
receipt: z.ZodObject<{
|
|
2071
|
+
receiver: z.ZodString;
|
|
2072
|
+
act_digest: z.ZodString;
|
|
2073
|
+
global_sequence: z.ZodString;
|
|
2074
|
+
recv_sequence: z.ZodString;
|
|
2075
|
+
auth_sequence: z.ZodArray<z.ZodObject<{
|
|
2076
|
+
account: z.ZodString;
|
|
2077
|
+
sequence: z.ZodString;
|
|
2078
|
+
}, z.core.$strip>>;
|
|
2079
|
+
code_sequence: z.ZodString;
|
|
2080
|
+
abi_sequence: z.ZodString;
|
|
2081
|
+
}, z.core.$strip>;
|
|
2082
|
+
receiver: z.ZodString;
|
|
2083
|
+
act: z.ZodObject<{
|
|
2084
|
+
account: z.ZodString;
|
|
2085
|
+
name: z.ZodString;
|
|
2086
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
2087
|
+
actor: z.ZodString;
|
|
2088
|
+
permission: z.ZodString;
|
|
2089
|
+
}, z.core.$strip>>;
|
|
2090
|
+
data: z.ZodAny;
|
|
2091
|
+
}, z.core.$strip>;
|
|
2092
|
+
context_free: z.ZodString;
|
|
2093
|
+
elapsed: z.ZodString;
|
|
2094
|
+
console: z.ZodString;
|
|
2095
|
+
account_ram_deltas: z.ZodArray<z.ZodObject<{
|
|
2096
|
+
account: z.ZodString;
|
|
2097
|
+
delta: z.ZodString;
|
|
2098
|
+
}, z.core.$strip>>;
|
|
2099
|
+
except: z.ZodString;
|
|
2100
|
+
error_code: z.ZodNullable<z.ZodString>;
|
|
2101
|
+
return_value: z.ZodString;
|
|
2102
|
+
}, z.core.$strip>;
|
|
2103
|
+
irreversible: z.ZodBoolean;
|
|
2104
|
+
}, z.core.$strip>;
|
|
2105
|
+
type HistoryAction = z.infer<typeof historyActionParser>;
|
|
2106
|
+
declare const getHistoryActionsResponseParser: z.ZodObject<{
|
|
2107
|
+
sync: z.ZodNumber;
|
|
2108
|
+
last_irreversible_block_num: z.ZodNumber;
|
|
2109
|
+
data: z.ZodArray<z.ZodObject<{
|
|
2110
|
+
block_num: z.ZodNumber;
|
|
2111
|
+
block_time: z.ZodString;
|
|
2112
|
+
trx_id: z.ZodString;
|
|
2113
|
+
account_action_seq: z.ZodNumber;
|
|
2114
|
+
global_action_seq: z.ZodNumber;
|
|
2115
|
+
action_trace: z.ZodObject<{
|
|
2116
|
+
action_ordinal: z.ZodString;
|
|
2117
|
+
creator_action_ordinal: z.ZodString;
|
|
2118
|
+
receipt: z.ZodObject<{
|
|
2119
|
+
receiver: z.ZodString;
|
|
2120
|
+
act_digest: z.ZodString;
|
|
2121
|
+
global_sequence: z.ZodString;
|
|
2122
|
+
recv_sequence: z.ZodString;
|
|
2123
|
+
auth_sequence: z.ZodArray<z.ZodObject<{
|
|
2124
|
+
account: z.ZodString;
|
|
2125
|
+
sequence: z.ZodString;
|
|
2126
|
+
}, z.core.$strip>>;
|
|
2127
|
+
code_sequence: z.ZodString;
|
|
2128
|
+
abi_sequence: z.ZodString;
|
|
2129
|
+
}, z.core.$strip>;
|
|
2130
|
+
receiver: z.ZodString;
|
|
2131
|
+
act: z.ZodObject<{
|
|
2132
|
+
account: z.ZodString;
|
|
2133
|
+
name: z.ZodString;
|
|
2134
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
2135
|
+
actor: z.ZodString;
|
|
2136
|
+
permission: z.ZodString;
|
|
2137
|
+
}, z.core.$strip>>;
|
|
2138
|
+
data: z.ZodAny;
|
|
2139
|
+
}, z.core.$strip>;
|
|
2140
|
+
context_free: z.ZodString;
|
|
2141
|
+
elapsed: z.ZodString;
|
|
2142
|
+
console: z.ZodString;
|
|
2143
|
+
account_ram_deltas: z.ZodArray<z.ZodObject<{
|
|
2144
|
+
account: z.ZodString;
|
|
2145
|
+
delta: z.ZodString;
|
|
2146
|
+
}, z.core.$strip>>;
|
|
2147
|
+
except: z.ZodString;
|
|
2148
|
+
error_code: z.ZodNullable<z.ZodString>;
|
|
2149
|
+
return_value: z.ZodString;
|
|
2150
|
+
}, z.core.$strip>;
|
|
2151
|
+
irreversible: z.ZodBoolean;
|
|
2152
|
+
}, z.core.$strip>>;
|
|
2153
|
+
}, z.core.$strip>;
|
|
2154
|
+
type GetHistoryActionsResponse = z.infer<typeof getHistoryActionsResponseParser>;
|
|
2155
|
+
/**
|
|
2156
|
+
* History transfers
|
|
2157
|
+
*/
|
|
2158
|
+
declare const getHistoryTransfersParser: z.ZodObject<{
|
|
2159
|
+
transfer_from: z.ZodOptional<z.ZodString>;
|
|
2160
|
+
transfer_to: z.ZodOptional<z.ZodString>;
|
|
2161
|
+
contract: z.ZodOptional<z.ZodString>;
|
|
2162
|
+
symbol: z.ZodOptional<z.ZodString>;
|
|
2163
|
+
amount_precision: z.ZodOptional<z.ZodString>;
|
|
2164
|
+
amount_min: z.ZodOptional<z.ZodString>;
|
|
2165
|
+
amount_max: z.ZodOptional<z.ZodString>;
|
|
2166
|
+
date_from: z.ZodOptional<z.ZodString>;
|
|
2167
|
+
date_to: z.ZodOptional<z.ZodString>;
|
|
2168
|
+
global_seq_from: z.ZodOptional<z.ZodString>;
|
|
2169
|
+
global_seq_to: z.ZodOptional<z.ZodString>;
|
|
2170
|
+
direction: z.ZodOptional<z.ZodEnum<{
|
|
2171
|
+
asc: "asc";
|
|
2172
|
+
desc: "desc";
|
|
2173
|
+
}>>;
|
|
2174
|
+
limit: z.ZodDefault<z.ZodCoercedNumber<number>>;
|
|
2175
|
+
}, z.core.$strip>;
|
|
2176
|
+
type GetHistoryTransfers = z.input<typeof getHistoryTransfersParser>;
|
|
2177
|
+
type GetHistoryTransfersParsed = z.output<typeof getHistoryTransfersParser>;
|
|
2178
|
+
declare const historyTransferParser: z.ZodObject<{
|
|
2179
|
+
block_num: z.ZodNumber;
|
|
2180
|
+
block_time: z.ZodString;
|
|
2181
|
+
trx_id: z.ZodString;
|
|
2182
|
+
account_action_seq: z.ZodNumber;
|
|
2183
|
+
global_action_seq: z.ZodNumber;
|
|
2184
|
+
action_trace: z.ZodObject<{
|
|
2185
|
+
action_ordinal: z.ZodString;
|
|
2186
|
+
creator_action_ordinal: z.ZodString;
|
|
2187
|
+
receipt: z.ZodObject<{
|
|
2188
|
+
receiver: z.ZodString;
|
|
2189
|
+
act_digest: z.ZodString;
|
|
2190
|
+
global_sequence: z.ZodString;
|
|
2191
|
+
recv_sequence: z.ZodString;
|
|
2192
|
+
auth_sequence: z.ZodArray<z.ZodObject<{
|
|
2193
|
+
account: z.ZodString;
|
|
2194
|
+
sequence: z.ZodString;
|
|
2195
|
+
}, z.core.$strip>>;
|
|
2196
|
+
code_sequence: z.ZodString;
|
|
2197
|
+
abi_sequence: z.ZodString;
|
|
2198
|
+
}, z.core.$strip>;
|
|
2199
|
+
receiver: z.ZodString;
|
|
2200
|
+
act: z.ZodObject<{
|
|
2201
|
+
account: z.ZodString;
|
|
2202
|
+
name: z.ZodString;
|
|
2203
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
2204
|
+
actor: z.ZodString;
|
|
2205
|
+
permission: z.ZodString;
|
|
2206
|
+
}, z.core.$strip>>;
|
|
2207
|
+
data: z.ZodAny;
|
|
2208
|
+
}, z.core.$strip>;
|
|
2209
|
+
context_free: z.ZodString;
|
|
2210
|
+
elapsed: z.ZodString;
|
|
2211
|
+
console: z.ZodString;
|
|
2212
|
+
account_ram_deltas: z.ZodArray<z.ZodObject<{
|
|
2213
|
+
account: z.ZodString;
|
|
2214
|
+
delta: z.ZodString;
|
|
2215
|
+
}, z.core.$strip>>;
|
|
2216
|
+
except: z.ZodString;
|
|
2217
|
+
error_code: z.ZodNullable<z.ZodString>;
|
|
2218
|
+
return_value: z.ZodString;
|
|
2219
|
+
}, z.core.$strip>;
|
|
2220
|
+
irreversible: z.ZodBoolean;
|
|
2221
|
+
}, z.core.$strip>;
|
|
2222
|
+
type HistoryTransfer = z.infer<typeof historyTransferParser>;
|
|
2223
|
+
declare const getHistoryTransfersResponseParser: z.ZodObject<{
|
|
2224
|
+
sync: z.ZodNumber;
|
|
2225
|
+
last_irreversible_block_num: z.ZodNumber;
|
|
2226
|
+
data: z.ZodArray<z.ZodObject<{
|
|
2227
|
+
block_num: z.ZodNumber;
|
|
2228
|
+
block_time: z.ZodString;
|
|
2229
|
+
trx_id: z.ZodString;
|
|
2230
|
+
account_action_seq: z.ZodNumber;
|
|
2231
|
+
global_action_seq: z.ZodNumber;
|
|
2232
|
+
action_trace: z.ZodObject<{
|
|
2233
|
+
action_ordinal: z.ZodString;
|
|
2234
|
+
creator_action_ordinal: z.ZodString;
|
|
2235
|
+
receipt: z.ZodObject<{
|
|
2236
|
+
receiver: z.ZodString;
|
|
2237
|
+
act_digest: z.ZodString;
|
|
2238
|
+
global_sequence: z.ZodString;
|
|
2239
|
+
recv_sequence: z.ZodString;
|
|
2240
|
+
auth_sequence: z.ZodArray<z.ZodObject<{
|
|
2241
|
+
account: z.ZodString;
|
|
2242
|
+
sequence: z.ZodString;
|
|
2243
|
+
}, z.core.$strip>>;
|
|
2244
|
+
code_sequence: z.ZodString;
|
|
2245
|
+
abi_sequence: z.ZodString;
|
|
2246
|
+
}, z.core.$strip>;
|
|
2247
|
+
receiver: z.ZodString;
|
|
2248
|
+
act: z.ZodObject<{
|
|
2249
|
+
account: z.ZodString;
|
|
2250
|
+
name: z.ZodString;
|
|
2251
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
2252
|
+
actor: z.ZodString;
|
|
2253
|
+
permission: z.ZodString;
|
|
2254
|
+
}, z.core.$strip>>;
|
|
2255
|
+
data: z.ZodAny;
|
|
2256
|
+
}, z.core.$strip>;
|
|
2257
|
+
context_free: z.ZodString;
|
|
2258
|
+
elapsed: z.ZodString;
|
|
2259
|
+
console: z.ZodString;
|
|
2260
|
+
account_ram_deltas: z.ZodArray<z.ZodObject<{
|
|
2261
|
+
account: z.ZodString;
|
|
2262
|
+
delta: z.ZodString;
|
|
2263
|
+
}, z.core.$strip>>;
|
|
2264
|
+
except: z.ZodString;
|
|
2265
|
+
error_code: z.ZodNullable<z.ZodString>;
|
|
2266
|
+
return_value: z.ZodString;
|
|
2267
|
+
}, z.core.$strip>;
|
|
2268
|
+
irreversible: z.ZodBoolean;
|
|
2269
|
+
}, z.core.$strip>>;
|
|
2270
|
+
}, z.core.$strip>;
|
|
2271
|
+
type GetHistoryTransfersResponse = z.infer<typeof getHistoryTransfersResponseParser>;
|
|
2272
|
+
/**
|
|
2273
|
+
* Open orders Balances
|
|
2274
|
+
*/
|
|
2275
|
+
declare const marketOpenOrdersBalanceParser: z.ZodObject<{
|
|
2276
|
+
market_id: z.ZodNumber;
|
|
2277
|
+
bid_token_quantity: z.ZodNumber;
|
|
2278
|
+
bid_token: z.ZodString;
|
|
2279
|
+
ask_token_quantity: z.ZodNumber;
|
|
2280
|
+
ask_token: z.ZodString;
|
|
2281
|
+
}, z.core.$strip>;
|
|
2282
|
+
type MarketOpenOrdersBalance = z.infer<typeof marketOpenOrdersBalanceParser>;
|
|
2283
|
+
declare const getOpenOrdersBalancesResponseParser: z.ZodObject<{
|
|
2284
|
+
sync: z.ZodNumber;
|
|
2285
|
+
data: z.ZodArray<z.ZodObject<{
|
|
2286
|
+
market_id: z.ZodNumber;
|
|
2287
|
+
bid_token_quantity: z.ZodNumber;
|
|
2288
|
+
bid_token: z.ZodString;
|
|
2289
|
+
ask_token_quantity: z.ZodNumber;
|
|
2290
|
+
ask_token: z.ZodString;
|
|
2291
|
+
}, z.core.$strip>>;
|
|
2292
|
+
}, z.core.$strip>;
|
|
2293
|
+
type GetOpenOrdersBalancesResponse = z.infer<typeof getOpenOrdersBalancesResponseParser>;
|
|
2294
|
+
/**
|
|
2295
|
+
* Basic Types
|
|
2296
|
+
*/
|
|
2297
|
+
declare enum orderType {
|
|
2298
|
+
ORDERBOOK = 0,
|
|
2299
|
+
LIMIT = 1,
|
|
2300
|
+
STOPLOSS = 2,
|
|
2301
|
+
TAKEPROFIT = 3
|
|
2302
|
+
}
|
|
2303
|
+
declare enum orderSide {
|
|
2304
|
+
INVALID = 0,
|
|
2305
|
+
BUY = 1,
|
|
2306
|
+
SELL = 2
|
|
2307
|
+
}
|
|
2308
|
+
declare enum fillType {
|
|
2309
|
+
GTC = 0,
|
|
2310
|
+
IOC = 1,
|
|
2311
|
+
POST_ONLY = 2
|
|
2312
|
+
}
|
|
2313
|
+
declare enum logStatus {
|
|
2314
|
+
CREATE = "create",
|
|
2315
|
+
UPDATE = "update",
|
|
2316
|
+
TRANSFER = "transfer",
|
|
2317
|
+
CANCEL = "cancel",
|
|
2318
|
+
DELETE = "delete"
|
|
2319
|
+
}
|
|
2320
|
+
declare enum ITopics {
|
|
2321
|
+
TRADES = "TRADES",
|
|
2322
|
+
ORDERS = "ORDERS"
|
|
2323
|
+
}
|
|
2324
|
+
declare const TOPICS: {
|
|
2325
|
+
TRADES: {
|
|
2326
|
+
topic: ITopics;
|
|
2327
|
+
};
|
|
2328
|
+
ORDERS: {
|
|
2329
|
+
topic: ITopics;
|
|
2330
|
+
};
|
|
2331
|
+
};
|
|
2332
|
+
declare const loginAccountParamsV3Parser: z.ZodObject<{
|
|
2333
|
+
signer: z.ZodObject<{
|
|
2334
|
+
actor: z.ZodString;
|
|
2335
|
+
permission: z.ZodString;
|
|
2336
|
+
}, z.core.$strip>;
|
|
2337
|
+
signatures: z.ZodArray<z.ZodString>;
|
|
2338
|
+
transaction: z.ZodObject<{
|
|
2339
|
+
expiration: z.ZodString;
|
|
2340
|
+
ref_block_num: z.ZodNumber;
|
|
2341
|
+
ref_block_prefix: z.ZodNumber;
|
|
2342
|
+
max_net_usage_words: z.ZodNumber;
|
|
2343
|
+
max_cpu_usage_ms: z.ZodNumber;
|
|
2344
|
+
delay_sec: z.ZodNumber;
|
|
2345
|
+
context_free_actions: z.ZodArray<z.ZodObject<{
|
|
2346
|
+
account: z.ZodString;
|
|
2347
|
+
name: z.ZodString;
|
|
2348
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
2349
|
+
actor: z.ZodString;
|
|
2350
|
+
permission: z.ZodString;
|
|
2351
|
+
}, z.core.$strip>>;
|
|
2352
|
+
data: z.ZodAny;
|
|
2353
|
+
hex_data: z.ZodOptional<z.ZodString>;
|
|
2354
|
+
}, z.core.$strip>>;
|
|
2355
|
+
transaction_extensions: z.ZodArray<z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString]>>>>;
|
|
2356
|
+
actions: z.ZodArray<z.ZodUnion<[z.ZodObject<{
|
|
2357
|
+
account: z.ZodString | z.ZodLiteral<string>;
|
|
2358
|
+
name: z.ZodLiteral<string>;
|
|
2359
|
+
data: z.ZodObject<{
|
|
2360
|
+
[x: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
|
|
2361
|
+
}, z.core.$strip>;
|
|
2362
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
2363
|
+
actor: z.ZodString;
|
|
2364
|
+
permission: z.ZodString;
|
|
2365
|
+
}, z.core.$strip>>;
|
|
2366
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
2367
|
+
account: z.ZodLiteral<"webauthn">;
|
|
2368
|
+
name: z.ZodLiteral<"exec">;
|
|
2369
|
+
data: z.ZodObject<{
|
|
2370
|
+
account: z.ZodString;
|
|
2371
|
+
key: z.ZodObject<{
|
|
2372
|
+
key: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
|
|
2373
|
+
modulus: z.ZodString;
|
|
2374
|
+
exponent: z.ZodString;
|
|
2375
|
+
}, z.core.$strip>]>>;
|
|
2376
|
+
user_presence: z.ZodNumber;
|
|
2377
|
+
rpid: z.ZodString;
|
|
2378
|
+
}, z.core.$strip>;
|
|
2379
|
+
nonce: z.ZodNumber;
|
|
2380
|
+
permissions: z.ZodArray<z.ZodObject<{
|
|
2381
|
+
actor: z.ZodString;
|
|
2382
|
+
permission: z.ZodString;
|
|
2383
|
+
}, z.core.$strip>>;
|
|
2384
|
+
signature: z.ZodObject<{
|
|
2385
|
+
auth_data: z.ZodString;
|
|
2386
|
+
client_json: z.ZodString;
|
|
2387
|
+
signature: z.ZodString;
|
|
2388
|
+
}, z.core.$strip>;
|
|
2389
|
+
trx: z.ZodObject<{
|
|
2390
|
+
expiration: z.ZodString;
|
|
2391
|
+
ref_block_num: z.ZodNumber;
|
|
2392
|
+
ref_block_prefix: z.ZodNumber;
|
|
2393
|
+
max_net_usage_words: z.ZodNumber;
|
|
2394
|
+
max_cpu_usage_ms: z.ZodNumber;
|
|
2395
|
+
delay_sec: z.ZodNumber;
|
|
2396
|
+
context_free_actions: z.ZodArray<z.ZodObject<{
|
|
2397
|
+
account: z.ZodString;
|
|
2398
|
+
name: z.ZodString;
|
|
2399
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
2400
|
+
actor: z.ZodString;
|
|
2401
|
+
permission: z.ZodString;
|
|
2402
|
+
}, z.core.$strip>>;
|
|
2403
|
+
data: z.ZodAny;
|
|
2404
|
+
hex_data: z.ZodOptional<z.ZodString>;
|
|
2405
|
+
}, z.core.$strip>>;
|
|
2406
|
+
transaction_extensions: z.ZodArray<z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString]>>>>;
|
|
2407
|
+
actions: z.ZodArray<z.ZodObject<{
|
|
2408
|
+
account: z.ZodString | z.ZodLiteral<string>;
|
|
2409
|
+
name: z.ZodLiteral<string>;
|
|
2410
|
+
data: z.ZodUnion<[z.ZodString, z.ZodObject<{
|
|
2411
|
+
[x: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
|
|
2412
|
+
}, z.core.$strip>]>;
|
|
2413
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
2414
|
+
actor: z.ZodString;
|
|
2415
|
+
permission: z.ZodString;
|
|
2416
|
+
}, z.core.$strip>>;
|
|
2417
|
+
}, z.core.$strip>>;
|
|
2418
|
+
}, z.core.$strip>;
|
|
2419
|
+
}, z.core.$strip>;
|
|
2420
|
+
authorization: z.ZodArray<z.ZodObject<{
|
|
2421
|
+
actor: z.ZodString;
|
|
2422
|
+
permission: z.ZodString;
|
|
2423
|
+
}, z.core.$strip>>;
|
|
2424
|
+
}, z.core.$strip>]>>;
|
|
2425
|
+
}, z.core.$strip>;
|
|
2426
|
+
email: z.ZodOptional<z.ZodString>;
|
|
2427
|
+
verificationCode: z.ZodOptional<z.ZodString>;
|
|
2428
|
+
}, z.core.$strip>;
|
|
2429
|
+
type LoginAccountParamsV3 = z.infer<typeof loginAccountParamsV3Parser>;
|
|
2430
|
+
declare const WRAP_CONTRACT = "proton.wrap";
|
|
2431
|
+
declare const WRAP_AUTH_ACTION = "generateauth";
|
|
2432
|
+
declare const FEE_FACTOR = 10000;
|
|
2433
|
+
declare const initializeConstants: (chain: string) => {
|
|
2434
|
+
SWAP_CONTRACT: string;
|
|
2435
|
+
VEST_CONTRACT: string;
|
|
2436
|
+
DEX_CONTRACT: string;
|
|
2437
|
+
FEE_FACTOR: number;
|
|
2438
|
+
SWAP_URL: string;
|
|
2439
|
+
WRAP_SERVER_URL: string;
|
|
2440
|
+
WRAP_CONTRACT: string;
|
|
2441
|
+
WRAP_ACTIONS: {
|
|
2442
|
+
SAVE_ADDRESS: string;
|
|
2443
|
+
DELETE_ADDRESS: string;
|
|
2444
|
+
WRAP_START: string;
|
|
2445
|
+
WRAP_FINISH: string;
|
|
2446
|
+
WRAP_PROCESS: string;
|
|
2447
|
+
WRAP_SET_CONF: string;
|
|
2448
|
+
};
|
|
2449
|
+
WRAP_TABLES: {
|
|
2450
|
+
ADDRESSES: string;
|
|
2451
|
+
WRAPS: string;
|
|
2452
|
+
};
|
|
2453
|
+
ADDRESSES_INDEXES: {
|
|
2454
|
+
BY_ACCOUNT: number;
|
|
2455
|
+
BY_ADDR_HASH: number;
|
|
2456
|
+
};
|
|
2457
|
+
WRAPS_INDEXES: {
|
|
2458
|
+
BY_ACCOUNT: number;
|
|
2459
|
+
BY_STATUS: number;
|
|
2460
|
+
BY_WRAP_HASH: number;
|
|
2461
|
+
};
|
|
2462
|
+
WRAP_PROCESS_TIMER: number;
|
|
2463
|
+
FARM_CONTRACT: string;
|
|
2464
|
+
WEBHOOK_PERMISSION: string;
|
|
2465
|
+
PUBLIC_PERMISSION: string;
|
|
2466
|
+
LIGHT_PERMISSION: string;
|
|
2467
|
+
WRAP_AUTH_ACTION: string;
|
|
2468
|
+
METAL_ENDPOINT: string;
|
|
2469
|
+
METAL_PROTON_ENDPOINT: string;
|
|
2470
|
+
METAL_DEX_HTTP_ENDPOINT: string;
|
|
2471
|
+
METAL_DEX_WS_ENDPOINT: string;
|
|
2472
|
+
PROTON_ENDPOINTS: string[];
|
|
2473
|
+
CHAIN_ID: string;
|
|
2474
|
+
COINS_URL: string;
|
|
2475
|
+
DEX_PROCESS_SIZE: number;
|
|
2476
|
+
DEX_SLTPPROCESS_SIZE: number;
|
|
2477
|
+
MAX_PRICE: string;
|
|
2478
|
+
MAX_ITEMS_PER_PAGE_DESKTOP: number;
|
|
2479
|
+
MIN_PRICE: number;
|
|
2480
|
+
DEFAULT_DEX_SYMBOL: string;
|
|
2481
|
+
CHAIN: string;
|
|
2482
|
+
SWAP_COINS: Coin[];
|
|
2483
|
+
BRIDGE_COINS: Coin[];
|
|
2484
|
+
ALL_ENABLED_COINS: Coin[];
|
|
2485
|
+
LEND_COINS: Coin[];
|
|
2486
|
+
BORROW_COINS: Coin[];
|
|
2487
|
+
LOAN_COINS: Coin[];
|
|
2488
|
+
ALL_COINS: Coin[];
|
|
2489
|
+
XMD_CONTRACT: string;
|
|
2490
|
+
XMD_TOKEN_CONTRACT: string;
|
|
2491
|
+
XMD_SYMBOL_CODE: string;
|
|
2492
|
+
XMD_DECIMALS: number;
|
|
2493
|
+
findBridgeCoinWalletByXtokenAndChain(xtokenSymbol: string, chain: string): CoinWallet | undefined;
|
|
2494
|
+
findBridgeCoinWallet(coin: string, wallet: string): CoinWallet | undefined;
|
|
2495
|
+
findBridgeCoinWalletByWallet(wallet: string): CoinWallet | undefined;
|
|
2496
|
+
findBridgeCoinNetwork(coin: string, network: string): CoinWallet | undefined;
|
|
2497
|
+
};
|
|
2498
|
+
interface PartialCoin {
|
|
2499
|
+
xtokenSymbol: string;
|
|
2500
|
+
xtokenPrecision: number;
|
|
2501
|
+
xtokenContract: string;
|
|
2502
|
+
}
|
|
2503
|
+
declare const isSameToken: (token1: PartialCoin, token2: PartialCoin) => boolean;
|
|
2504
|
+
declare const median: (numbers: number[]) => number;
|
|
2505
|
+
/**
|
|
2506
|
+
* XPR<>XUSDT (XPR -> XUSDT)
|
|
2507
|
+
*
|
|
2508
|
+
* pool1 * pool2
|
|
2509
|
+
* term = pool2 - --------------
|
|
2510
|
+
* pool1 + swap
|
|
2511
|
+
*
|
|
2512
|
+
* result = term - (term * fee)
|
|
2513
|
+
*/
|
|
2514
|
+
declare const compute_transfer: (pool1: BN.Instance, pool2: BN.Instance, swap: BN.Instance, exchange_fee: number, precision: number) => BN;
|
|
2515
|
+
declare const compute_transfer_curve: (reserve_in: number, reserve_out: number, amount_in: number, exchange_fee: number, precision: number, amplifier: number) => BN;
|
|
2516
|
+
declare const compute_liquidity: (amount_lt: BN.Instance, pool: BN.Instance, lt_supply: BN.Instance, precision: number) => number;
|
|
2517
|
+
declare const isInputInvalid: (data: string, value: string | number, pool: {
|
|
2518
|
+
xtokenPrecision: number;
|
|
2519
|
+
}) => boolean;
|
|
2520
|
+
declare const applyDiscountToFee: (fee: number, staked: number) => number;
|
|
2521
|
+
/**
|
|
2522
|
+
* Withdrawal destination validation for the bridge (MFE-855).
|
|
2523
|
+
*
|
|
2524
|
+
* The address and memo end up inside the XPR transfer memo as
|
|
2525
|
+
* `coin:network:address[?memo=...]:fee`, which the bridge server splits on ':'.
|
|
2526
|
+
* So beyond per-chain format checks, these validators also reject characters
|
|
2527
|
+
* that would corrupt that structure.
|
|
2528
|
+
*
|
|
2529
|
+
* Result levels:
|
|
2530
|
+
* - 'full' : the chain's address format was fully checked, including its
|
|
2531
|
+
* checksum where the format has one. Formats without a checksum
|
|
2532
|
+
* (Solana keys, EOS names, Hedera ids, single-case EVM) cannot
|
|
2533
|
+
* catch every typo even at this level.
|
|
2534
|
+
* - 'basic' : only the shared safety rules (and partial format checks) ran,
|
|
2535
|
+
* because no complete validator exists for this chain/format.
|
|
2536
|
+
*/
|
|
2537
|
+
declare const MAX_ADDRESS_LENGTH = 128;
|
|
2538
|
+
type AddressValidationLevel = 'full' | 'basic';
|
|
2539
|
+
type AddressValidationResult = {
|
|
2540
|
+
valid: true;
|
|
2541
|
+
level: AddressValidationLevel;
|
|
2542
|
+
} | {
|
|
2543
|
+
valid: false;
|
|
2544
|
+
reason: string;
|
|
2545
|
+
};
|
|
2546
|
+
type MemoValidationResult = {
|
|
2547
|
+
valid: true;
|
|
2548
|
+
} | {
|
|
2549
|
+
valid: false;
|
|
2550
|
+
reason: string;
|
|
2551
|
+
};
|
|
2552
|
+
/**
|
|
2553
|
+
* Validate a withdrawal destination address for the given bridge chain
|
|
2554
|
+
* (a `Chains` enum value, i.e. `wallet.chain`). Expects already-trimmed input.
|
|
2555
|
+
* Pure and synchronous, so it is safe to call on every keystroke.
|
|
2556
|
+
*/
|
|
2557
|
+
declare const validateWithdrawAddress: (chain: string, address: string) => AddressValidationResult;
|
|
2558
|
+
/**
|
|
2559
|
+
* Validate an optional withdrawal memo / destination tag. The memo is appended
|
|
2560
|
+
* to the address as `?memo=...` inside the ':'-delimited bridge memo, so
|
|
2561
|
+
* delimiter and URL-structure characters are rejected on every chain.
|
|
2562
|
+
*/
|
|
2563
|
+
declare const validateWithdrawMemo: (chain: string, memo: string | undefined) => MemoValidationResult;
|
|
2564
|
+
/**
|
|
2565
|
+
* Turn a failed bridge withdrawal request into a message that is safe to show
|
|
2566
|
+
* to the user (MFE-855).
|
|
2567
|
+
*
|
|
2568
|
+
* Only 4xx responses are treated as user-facing: they describe a problem with
|
|
2569
|
+
* the request (for example an invalid address passed through from Proton Swap).
|
|
2570
|
+
* 5xx responses, network failures and anything unrecognised get a generic
|
|
2571
|
+
* message, so server internals such as stack traces are never displayed and
|
|
2572
|
+
* the raw "AxiosError: Request failed with status code 500" is never shown.
|
|
2573
|
+
*
|
|
2574
|
+
* Duck-typed so it has no axios dependency.
|
|
2575
|
+
*/
|
|
2576
|
+
declare const GENERIC_WITHDRAW_ERROR = "Withdrawal failed. Please check the amount and address and try again.";
|
|
2577
|
+
declare const MAX_WITHDRAW_ERROR_LENGTH = 200;
|
|
2578
|
+
declare const withdrawErrorMessage: (error: unknown) => string;
|
|
2579
|
+
export { Address, AddressValidationLevel, AddressValidationResult, Authorization, Authorizations, BloksRate, BloksRates, Chains, ChronicleTransaction, Coin, CoinWallet, CurrencyStat, CurrencyStats, Daily, DbHistoryTransaction, DbMarket, DepositBody, Depth, ExchangeRate, ExchangeRates, ExtendedAsset, ExtendedAssetParser, ExtendedToken, ExtendedTokenWithRate, FEE_FACTOR, GENERIC_WITHDRAW_ERROR, GenerateAddressBody, GenerateAddressResponse, GenerateAuth, GenerateAuthBaseAction, GetDailyResponse, GetDepth, GetDepthParsed, GetDepthResponse, GetHistoryActions, GetHistoryActionsParsed, GetHistoryActionsResponse, GetHistoryTransactionResponse, GetHistoryTransfers, GetHistoryTransfersParsed, GetHistoryTransfersResponse, GetLeaderboard, GetLeaderboardParsed, GetLeaderboardResponse, GetMarketsResponse, GetOHLCV, GetOHLCVParsed, GetOHLCVResponse, GetOpenOrders, GetOpenOrdersBalancesResponse, GetOpenOrdersParsed, GetOpenOrdersResponse, GetOrderHistory, GetOrderHistoryParsed, GetOrderHistoryResponse, GetOrderLifecycle, GetOrderLifecycleParsed, GetOrderLifecycleResponse, GetReferralTotals, GetReferralTotalsParsed, GetReferralTotalsResponse, GetReferrals, GetReferralsParsed, GetReferralsResponse, GetSyncResponse, GetTradeHistory, GetTradeHistoryParsed, GetTradeHistoryResponse, GetTrades, GetTradesParsed, GetTradesResponse, Graph, HistoryAccountRamDelta, HistoryAct, HistoryAction, HistoryActionTrace, HistoryPartial, HistoryReceipt, HistoryTrace, HistoryTransaction, HistoryTransfer, ILink, INode, ITopics, Leaderboard, LoginAccountParamsV3, MAX_ADDRESS_LENGTH, MAX_WITHDRAW_ERROR_LENGTH, Market, MarketOpenOrdersBalance, MemoValidationResult, MetalTransaction, Networks, OHLCV, OpenOrder, OrderHistory, OrderLog, OtcOrderResponse, OtcQuoteBody, OtcQuoteResponse, Pool, PoolTable, PostSerializeOrder, PostSerializeOrderResponse, PostSubmitOrder, PostSubmitOrderResponse, Providers, Rate, RawPool, Referral, ReferralTotal, SortDirection, Status, Sync, TOPICS, Trade, TradeLog, Type, WRAP_AUTH_ACTION, WRAP_CONTRACT, Wallet, WithdrawBody, WithdrawBodyBaseAction, WithdrawHistoryMetalResponse, WithdrawHistoryMetalSwap, WithdrawMetalResponse, WithdrawalFeeQuote, Wrap, WrapSetConf, WrapStart, accountParser, accountRamDeltaParser, actParser, actionTraceParser, addressParser, applyDiscountToFee, authorizationParser, authorizationsParser, baseActionParser, baseActionSerializedParser, bloksRatesParser, chronicleTransactionParser, compute_liquidity, compute_transfer, compute_transfer_curve, createAbstractAuthParser, dailyParser, dbHistoryTransactionParser, dbMarketParser, depositBodyParser, depthParser, exchangeRateParser, exchangeRatesParser, explorerLinkByChain, fillType, generateAddressBodyParser, generateAddressResponse, generateAuthActionsBaseParser, generateAuthParser, getDailyResponseParser, getDepthParser, getDepthResponseParser, getHistoryActionsParser, getHistoryActionsResponseParser, getHistoryTransactionResponseParser, getHistoryTransfersParser, getHistoryTransfersResponseParser, getLeaderboardParser, getLeaderboardResponseParser, getMarketsResponseParser, getOhlcvParser, getOhlcvResponseParser, getOpenOrdersBalancesResponseParser, getOpenOrdersParser, getOpenOrdersResponseParser, getOrderHistoryParser, getOrderHistoryResponseParser, getOrderLifecycleParser, getOrderLifecycleResponseParser, getReferralTotalsParser, getReferralTotalsResponseParser, getReferralsParser, getReferralsResponseParser, getSyncResponseParser, getTradeHistoryParser, getTradeHistoryResponseParser, getTradesParser, getTradesResponseParser, historyActionParser, historyPartialParser, historyTransactionParser, historyTransferParser, initializeCoins, initializeConstants, isInputInvalid, isSameToken, leaderboardParser, logStatus, loginAccountParamsV3Parser, marketOpenOrdersBalanceParser, marketParser, median, metalTransactionParser, ohlcvParser, openOrderParser, orderHistoryParser, orderLogParser, orderSide, orderType, otcOrderResponseParser, otcQuoteBodyParser, otcQuoteResponseParser, postSerializeOrderParser, postSerializeOrderResponseParser, postSubmitOrderParser, postSubmitOrderResponseParser, protonExplorerTxUrl, rateParser, receiptParser, refferalParser, refferalTotalParser, similarChains, singleActionTransactionParser, sortDirectionEnum, syncParser, traceParser, tradeLogParser, tradeParser, validateWithdrawAddress, validateWithdrawMemo, webauthActionParser, withdrawBodyBaseAction, withdrawBodyParser, withdrawErrorMessage, withdrawHistoryMetalResponseParser, withdrawHistoryMetalSwapParser, withdrawMetalResponseParser, withdrawalFeeQuoteParser, wrapParser, wrapSetConfParser, wrapStartParser };
|