@gitmyabi/upgradeablelockreleasetokenpool 0.0.0-stage → 1.0.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +107 -2
- package/contracts/TransparentUpgradeableProxy.d.ts +185 -0
- package/contracts/TransparentUpgradeableProxy.js +238 -0
- package/contracts/TransparentUpgradeableProxy.ts +268 -0
- package/contracts/UpgradeableLockReleaseTokenPool.d.ts +2557 -0
- package/contracts/UpgradeableLockReleaseTokenPool.js +2852 -0
- package/contracts/UpgradeableLockReleaseTokenPool.ts +3421 -0
- package/contracts/index.d.ts +4 -0
- package/contracts/index.js +10 -0
- package/contracts/index.ts +5 -0
- package/index.d.ts +1 -0
- package/index.js +19 -0
- package/package.json +40 -3
|
@@ -0,0 +1,2557 @@
|
|
|
1
|
+
import type { Address, PublicClient, WalletClient } from 'viem';
|
|
2
|
+
/**
|
|
3
|
+
* RateLimiter.Config struct type
|
|
4
|
+
*/
|
|
5
|
+
export type RateLimiter_Config = {
|
|
6
|
+
isEnabled: boolean;
|
|
7
|
+
capacity: bigint;
|
|
8
|
+
rate: bigint;
|
|
9
|
+
};
|
|
10
|
+
/**
|
|
11
|
+
* UpgradeableTokenPool.ChainUpdate struct type
|
|
12
|
+
*/
|
|
13
|
+
export type UpgradeableTokenPool_ChainUpdate = {
|
|
14
|
+
remoteChainSelector: bigint;
|
|
15
|
+
remotePoolAddresses: `0x${string}`[];
|
|
16
|
+
remoteTokenAddress: `0x${string}`;
|
|
17
|
+
outboundRateLimiterConfig: RateLimiter_Config;
|
|
18
|
+
inboundRateLimiterConfig: RateLimiter_Config;
|
|
19
|
+
};
|
|
20
|
+
/**
|
|
21
|
+
* RateLimiter.TokenBucket struct type
|
|
22
|
+
*/
|
|
23
|
+
export type RateLimiter_TokenBucket = {
|
|
24
|
+
tokens: bigint;
|
|
25
|
+
lastUpdated: bigint;
|
|
26
|
+
isEnabled: boolean;
|
|
27
|
+
capacity: bigint;
|
|
28
|
+
rate: bigint;
|
|
29
|
+
};
|
|
30
|
+
/**
|
|
31
|
+
* Pool.LockOrBurnInV1 struct type
|
|
32
|
+
*/
|
|
33
|
+
export type Pool_LockOrBurnInV1 = {
|
|
34
|
+
receiver: `0x${string}`;
|
|
35
|
+
remoteChainSelector: bigint;
|
|
36
|
+
originalSender: `0x${string}`;
|
|
37
|
+
amount: bigint;
|
|
38
|
+
localToken: `0x${string}`;
|
|
39
|
+
};
|
|
40
|
+
/**
|
|
41
|
+
* Pool.LockOrBurnOutV1 struct type
|
|
42
|
+
*/
|
|
43
|
+
export type Pool_LockOrBurnOutV1 = {
|
|
44
|
+
destTokenAddress: `0x${string}`;
|
|
45
|
+
destPoolData: `0x${string}`;
|
|
46
|
+
};
|
|
47
|
+
/**
|
|
48
|
+
* Pool.ReleaseOrMintInV1 struct type
|
|
49
|
+
*/
|
|
50
|
+
export type Pool_ReleaseOrMintInV1 = {
|
|
51
|
+
originalSender: `0x${string}`;
|
|
52
|
+
remoteChainSelector: bigint;
|
|
53
|
+
receiver: `0x${string}`;
|
|
54
|
+
amount: bigint;
|
|
55
|
+
localToken: `0x${string}`;
|
|
56
|
+
sourcePoolAddress: `0x${string}`;
|
|
57
|
+
sourcePoolData: `0x${string}`;
|
|
58
|
+
offchainTokenData: `0x${string}`;
|
|
59
|
+
};
|
|
60
|
+
/**
|
|
61
|
+
* Pool.ReleaseOrMintOutV1 struct type
|
|
62
|
+
*/
|
|
63
|
+
export type Pool_ReleaseOrMintOutV1 = {
|
|
64
|
+
destinationAmount: bigint;
|
|
65
|
+
};
|
|
66
|
+
/**
|
|
67
|
+
* UpgradeableLockReleaseTokenPool ABI
|
|
68
|
+
*
|
|
69
|
+
* This ABI is typed using viem's type system for full type safety.
|
|
70
|
+
*/
|
|
71
|
+
export declare const UpgradeableLockReleaseTokenPoolAbi: readonly [{
|
|
72
|
+
readonly inputs: readonly [{
|
|
73
|
+
readonly internalType: "address";
|
|
74
|
+
readonly name: "token";
|
|
75
|
+
readonly type: "address";
|
|
76
|
+
}, {
|
|
77
|
+
readonly internalType: "uint8";
|
|
78
|
+
readonly name: "localTokenDecimals";
|
|
79
|
+
readonly type: "uint8";
|
|
80
|
+
}, {
|
|
81
|
+
readonly internalType: "address";
|
|
82
|
+
readonly name: "rmnProxy";
|
|
83
|
+
readonly type: "address";
|
|
84
|
+
}, {
|
|
85
|
+
readonly internalType: "bool";
|
|
86
|
+
readonly name: "allowListEnabled";
|
|
87
|
+
readonly type: "bool";
|
|
88
|
+
}, {
|
|
89
|
+
readonly internalType: "bool";
|
|
90
|
+
readonly name: "acceptLiquidity";
|
|
91
|
+
readonly type: "bool";
|
|
92
|
+
}];
|
|
93
|
+
readonly stateMutability: "nonpayable";
|
|
94
|
+
readonly type: "constructor";
|
|
95
|
+
}, {
|
|
96
|
+
readonly inputs: readonly [{
|
|
97
|
+
readonly internalType: "uint256";
|
|
98
|
+
readonly name: "capacity";
|
|
99
|
+
readonly type: "uint256";
|
|
100
|
+
}, {
|
|
101
|
+
readonly internalType: "uint256";
|
|
102
|
+
readonly name: "requested";
|
|
103
|
+
readonly type: "uint256";
|
|
104
|
+
}];
|
|
105
|
+
readonly name: "AggregateValueMaxCapacityExceeded";
|
|
106
|
+
readonly type: "error";
|
|
107
|
+
}, {
|
|
108
|
+
readonly inputs: readonly [{
|
|
109
|
+
readonly internalType: "uint256";
|
|
110
|
+
readonly name: "minWaitInSeconds";
|
|
111
|
+
readonly type: "uint256";
|
|
112
|
+
}, {
|
|
113
|
+
readonly internalType: "uint256";
|
|
114
|
+
readonly name: "available";
|
|
115
|
+
readonly type: "uint256";
|
|
116
|
+
}];
|
|
117
|
+
readonly name: "AggregateValueRateLimitReached";
|
|
118
|
+
readonly type: "error";
|
|
119
|
+
}, {
|
|
120
|
+
readonly inputs: readonly [];
|
|
121
|
+
readonly name: "AllowListNotEnabled";
|
|
122
|
+
readonly type: "error";
|
|
123
|
+
}, {
|
|
124
|
+
readonly inputs: readonly [{
|
|
125
|
+
readonly internalType: "uint256";
|
|
126
|
+
readonly name: "bridgeLimit";
|
|
127
|
+
readonly type: "uint256";
|
|
128
|
+
}];
|
|
129
|
+
readonly name: "BridgeLimitExceeded";
|
|
130
|
+
readonly type: "error";
|
|
131
|
+
}, {
|
|
132
|
+
readonly inputs: readonly [];
|
|
133
|
+
readonly name: "BucketOverfilled";
|
|
134
|
+
readonly type: "error";
|
|
135
|
+
}, {
|
|
136
|
+
readonly inputs: readonly [{
|
|
137
|
+
readonly internalType: "address";
|
|
138
|
+
readonly name: "caller";
|
|
139
|
+
readonly type: "address";
|
|
140
|
+
}];
|
|
141
|
+
readonly name: "CallerIsNotARampOnRouter";
|
|
142
|
+
readonly type: "error";
|
|
143
|
+
}, {
|
|
144
|
+
readonly inputs: readonly [];
|
|
145
|
+
readonly name: "CannotTransferToSelf";
|
|
146
|
+
readonly type: "error";
|
|
147
|
+
}, {
|
|
148
|
+
readonly inputs: readonly [{
|
|
149
|
+
readonly internalType: "uint64";
|
|
150
|
+
readonly name: "chainSelector";
|
|
151
|
+
readonly type: "uint64";
|
|
152
|
+
}];
|
|
153
|
+
readonly name: "ChainAlreadyExists";
|
|
154
|
+
readonly type: "error";
|
|
155
|
+
}, {
|
|
156
|
+
readonly inputs: readonly [{
|
|
157
|
+
readonly internalType: "uint64";
|
|
158
|
+
readonly name: "remoteChainSelector";
|
|
159
|
+
readonly type: "uint64";
|
|
160
|
+
}];
|
|
161
|
+
readonly name: "ChainNotAllowed";
|
|
162
|
+
readonly type: "error";
|
|
163
|
+
}, {
|
|
164
|
+
readonly inputs: readonly [];
|
|
165
|
+
readonly name: "CursedByRMN";
|
|
166
|
+
readonly type: "error";
|
|
167
|
+
}, {
|
|
168
|
+
readonly inputs: readonly [{
|
|
169
|
+
readonly components: readonly [{
|
|
170
|
+
readonly internalType: "bool";
|
|
171
|
+
readonly name: "isEnabled";
|
|
172
|
+
readonly type: "bool";
|
|
173
|
+
}, {
|
|
174
|
+
readonly internalType: "uint128";
|
|
175
|
+
readonly name: "capacity";
|
|
176
|
+
readonly type: "uint128";
|
|
177
|
+
}, {
|
|
178
|
+
readonly internalType: "uint128";
|
|
179
|
+
readonly name: "rate";
|
|
180
|
+
readonly type: "uint128";
|
|
181
|
+
}];
|
|
182
|
+
readonly internalType: "struct RateLimiter.Config";
|
|
183
|
+
readonly name: "config";
|
|
184
|
+
readonly type: "tuple";
|
|
185
|
+
}];
|
|
186
|
+
readonly name: "DisabledNonZeroRateLimit";
|
|
187
|
+
readonly type: "error";
|
|
188
|
+
}, {
|
|
189
|
+
readonly inputs: readonly [];
|
|
190
|
+
readonly name: "InsufficientLiquidity";
|
|
191
|
+
readonly type: "error";
|
|
192
|
+
}, {
|
|
193
|
+
readonly inputs: readonly [{
|
|
194
|
+
readonly internalType: "uint8";
|
|
195
|
+
readonly name: "expected";
|
|
196
|
+
readonly type: "uint8";
|
|
197
|
+
}, {
|
|
198
|
+
readonly internalType: "uint8";
|
|
199
|
+
readonly name: "actual";
|
|
200
|
+
readonly type: "uint8";
|
|
201
|
+
}];
|
|
202
|
+
readonly name: "InvalidDecimalArgs";
|
|
203
|
+
readonly type: "error";
|
|
204
|
+
}, {
|
|
205
|
+
readonly inputs: readonly [{
|
|
206
|
+
readonly components: readonly [{
|
|
207
|
+
readonly internalType: "bool";
|
|
208
|
+
readonly name: "isEnabled";
|
|
209
|
+
readonly type: "bool";
|
|
210
|
+
}, {
|
|
211
|
+
readonly internalType: "uint128";
|
|
212
|
+
readonly name: "capacity";
|
|
213
|
+
readonly type: "uint128";
|
|
214
|
+
}, {
|
|
215
|
+
readonly internalType: "uint128";
|
|
216
|
+
readonly name: "rate";
|
|
217
|
+
readonly type: "uint128";
|
|
218
|
+
}];
|
|
219
|
+
readonly internalType: "struct RateLimiter.Config";
|
|
220
|
+
readonly name: "rateLimiterConfig";
|
|
221
|
+
readonly type: "tuple";
|
|
222
|
+
}];
|
|
223
|
+
readonly name: "InvalidRateLimitRate";
|
|
224
|
+
readonly type: "error";
|
|
225
|
+
}, {
|
|
226
|
+
readonly inputs: readonly [{
|
|
227
|
+
readonly internalType: "bytes";
|
|
228
|
+
readonly name: "sourcePoolData";
|
|
229
|
+
readonly type: "bytes";
|
|
230
|
+
}];
|
|
231
|
+
readonly name: "InvalidRemoteChainDecimals";
|
|
232
|
+
readonly type: "error";
|
|
233
|
+
}, {
|
|
234
|
+
readonly inputs: readonly [{
|
|
235
|
+
readonly internalType: "uint64";
|
|
236
|
+
readonly name: "remoteChainSelector";
|
|
237
|
+
readonly type: "uint64";
|
|
238
|
+
}, {
|
|
239
|
+
readonly internalType: "bytes";
|
|
240
|
+
readonly name: "remotePoolAddress";
|
|
241
|
+
readonly type: "bytes";
|
|
242
|
+
}];
|
|
243
|
+
readonly name: "InvalidRemotePoolForChain";
|
|
244
|
+
readonly type: "error";
|
|
245
|
+
}, {
|
|
246
|
+
readonly inputs: readonly [{
|
|
247
|
+
readonly internalType: "bytes";
|
|
248
|
+
readonly name: "sourcePoolAddress";
|
|
249
|
+
readonly type: "bytes";
|
|
250
|
+
}];
|
|
251
|
+
readonly name: "InvalidSourcePoolAddress";
|
|
252
|
+
readonly type: "error";
|
|
253
|
+
}, {
|
|
254
|
+
readonly inputs: readonly [{
|
|
255
|
+
readonly internalType: "address";
|
|
256
|
+
readonly name: "token";
|
|
257
|
+
readonly type: "address";
|
|
258
|
+
}];
|
|
259
|
+
readonly name: "InvalidToken";
|
|
260
|
+
readonly type: "error";
|
|
261
|
+
}, {
|
|
262
|
+
readonly inputs: readonly [];
|
|
263
|
+
readonly name: "LiquidityNotAccepted";
|
|
264
|
+
readonly type: "error";
|
|
265
|
+
}, {
|
|
266
|
+
readonly inputs: readonly [];
|
|
267
|
+
readonly name: "MustBeProposedOwner";
|
|
268
|
+
readonly type: "error";
|
|
269
|
+
}, {
|
|
270
|
+
readonly inputs: readonly [{
|
|
271
|
+
readonly internalType: "uint64";
|
|
272
|
+
readonly name: "remoteChainSelector";
|
|
273
|
+
readonly type: "uint64";
|
|
274
|
+
}];
|
|
275
|
+
readonly name: "NonExistentChain";
|
|
276
|
+
readonly type: "error";
|
|
277
|
+
}, {
|
|
278
|
+
readonly inputs: readonly [];
|
|
279
|
+
readonly name: "NotEnoughBridgedAmount";
|
|
280
|
+
readonly type: "error";
|
|
281
|
+
}, {
|
|
282
|
+
readonly inputs: readonly [];
|
|
283
|
+
readonly name: "OnlyCallableByOwner";
|
|
284
|
+
readonly type: "error";
|
|
285
|
+
}, {
|
|
286
|
+
readonly inputs: readonly [{
|
|
287
|
+
readonly internalType: "uint8";
|
|
288
|
+
readonly name: "remoteDecimals";
|
|
289
|
+
readonly type: "uint8";
|
|
290
|
+
}, {
|
|
291
|
+
readonly internalType: "uint8";
|
|
292
|
+
readonly name: "localDecimals";
|
|
293
|
+
readonly type: "uint8";
|
|
294
|
+
}, {
|
|
295
|
+
readonly internalType: "uint256";
|
|
296
|
+
readonly name: "remoteAmount";
|
|
297
|
+
readonly type: "uint256";
|
|
298
|
+
}];
|
|
299
|
+
readonly name: "OverflowDetected";
|
|
300
|
+
readonly type: "error";
|
|
301
|
+
}, {
|
|
302
|
+
readonly inputs: readonly [];
|
|
303
|
+
readonly name: "OwnerCannotBeZero";
|
|
304
|
+
readonly type: "error";
|
|
305
|
+
}, {
|
|
306
|
+
readonly inputs: readonly [{
|
|
307
|
+
readonly internalType: "uint64";
|
|
308
|
+
readonly name: "remoteChainSelector";
|
|
309
|
+
readonly type: "uint64";
|
|
310
|
+
}, {
|
|
311
|
+
readonly internalType: "bytes";
|
|
312
|
+
readonly name: "remotePoolAddress";
|
|
313
|
+
readonly type: "bytes";
|
|
314
|
+
}];
|
|
315
|
+
readonly name: "PoolAlreadyAdded";
|
|
316
|
+
readonly type: "error";
|
|
317
|
+
}, {
|
|
318
|
+
readonly inputs: readonly [];
|
|
319
|
+
readonly name: "RateLimitMustBeDisabled";
|
|
320
|
+
readonly type: "error";
|
|
321
|
+
}, {
|
|
322
|
+
readonly inputs: readonly [{
|
|
323
|
+
readonly internalType: "address";
|
|
324
|
+
readonly name: "sender";
|
|
325
|
+
readonly type: "address";
|
|
326
|
+
}];
|
|
327
|
+
readonly name: "SenderNotAllowed";
|
|
328
|
+
readonly type: "error";
|
|
329
|
+
}, {
|
|
330
|
+
readonly inputs: readonly [{
|
|
331
|
+
readonly internalType: "uint256";
|
|
332
|
+
readonly name: "capacity";
|
|
333
|
+
readonly type: "uint256";
|
|
334
|
+
}, {
|
|
335
|
+
readonly internalType: "uint256";
|
|
336
|
+
readonly name: "requested";
|
|
337
|
+
readonly type: "uint256";
|
|
338
|
+
}, {
|
|
339
|
+
readonly internalType: "address";
|
|
340
|
+
readonly name: "tokenAddress";
|
|
341
|
+
readonly type: "address";
|
|
342
|
+
}];
|
|
343
|
+
readonly name: "TokenMaxCapacityExceeded";
|
|
344
|
+
readonly type: "error";
|
|
345
|
+
}, {
|
|
346
|
+
readonly inputs: readonly [{
|
|
347
|
+
readonly internalType: "uint256";
|
|
348
|
+
readonly name: "minWaitInSeconds";
|
|
349
|
+
readonly type: "uint256";
|
|
350
|
+
}, {
|
|
351
|
+
readonly internalType: "uint256";
|
|
352
|
+
readonly name: "available";
|
|
353
|
+
readonly type: "uint256";
|
|
354
|
+
}, {
|
|
355
|
+
readonly internalType: "address";
|
|
356
|
+
readonly name: "tokenAddress";
|
|
357
|
+
readonly type: "address";
|
|
358
|
+
}];
|
|
359
|
+
readonly name: "TokenRateLimitReached";
|
|
360
|
+
readonly type: "error";
|
|
361
|
+
}, {
|
|
362
|
+
readonly inputs: readonly [{
|
|
363
|
+
readonly internalType: "address";
|
|
364
|
+
readonly name: "caller";
|
|
365
|
+
readonly type: "address";
|
|
366
|
+
}];
|
|
367
|
+
readonly name: "Unauthorized";
|
|
368
|
+
readonly type: "error";
|
|
369
|
+
}, {
|
|
370
|
+
readonly inputs: readonly [];
|
|
371
|
+
readonly name: "ZeroAddressNotAllowed";
|
|
372
|
+
readonly type: "error";
|
|
373
|
+
}, {
|
|
374
|
+
readonly anonymous: false;
|
|
375
|
+
readonly inputs: readonly [{
|
|
376
|
+
readonly indexed: false;
|
|
377
|
+
readonly internalType: "address";
|
|
378
|
+
readonly name: "sender";
|
|
379
|
+
readonly type: "address";
|
|
380
|
+
}];
|
|
381
|
+
readonly name: "AllowListAdd";
|
|
382
|
+
readonly type: "event";
|
|
383
|
+
}, {
|
|
384
|
+
readonly anonymous: false;
|
|
385
|
+
readonly inputs: readonly [{
|
|
386
|
+
readonly indexed: false;
|
|
387
|
+
readonly internalType: "address";
|
|
388
|
+
readonly name: "sender";
|
|
389
|
+
readonly type: "address";
|
|
390
|
+
}];
|
|
391
|
+
readonly name: "AllowListRemove";
|
|
392
|
+
readonly type: "event";
|
|
393
|
+
}, {
|
|
394
|
+
readonly anonymous: false;
|
|
395
|
+
readonly inputs: readonly [{
|
|
396
|
+
readonly indexed: true;
|
|
397
|
+
readonly internalType: "address";
|
|
398
|
+
readonly name: "oldAdmin";
|
|
399
|
+
readonly type: "address";
|
|
400
|
+
}, {
|
|
401
|
+
readonly indexed: true;
|
|
402
|
+
readonly internalType: "address";
|
|
403
|
+
readonly name: "newAdmin";
|
|
404
|
+
readonly type: "address";
|
|
405
|
+
}];
|
|
406
|
+
readonly name: "BridgeLimitAdminUpdated";
|
|
407
|
+
readonly type: "event";
|
|
408
|
+
}, {
|
|
409
|
+
readonly anonymous: false;
|
|
410
|
+
readonly inputs: readonly [{
|
|
411
|
+
readonly indexed: false;
|
|
412
|
+
readonly internalType: "uint256";
|
|
413
|
+
readonly name: "oldBridgeLimit";
|
|
414
|
+
readonly type: "uint256";
|
|
415
|
+
}, {
|
|
416
|
+
readonly indexed: false;
|
|
417
|
+
readonly internalType: "uint256";
|
|
418
|
+
readonly name: "newBridgeLimit";
|
|
419
|
+
readonly type: "uint256";
|
|
420
|
+
}];
|
|
421
|
+
readonly name: "BridgeLimitUpdated";
|
|
422
|
+
readonly type: "event";
|
|
423
|
+
}, {
|
|
424
|
+
readonly anonymous: false;
|
|
425
|
+
readonly inputs: readonly [{
|
|
426
|
+
readonly indexed: true;
|
|
427
|
+
readonly internalType: "address";
|
|
428
|
+
readonly name: "sender";
|
|
429
|
+
readonly type: "address";
|
|
430
|
+
}, {
|
|
431
|
+
readonly indexed: false;
|
|
432
|
+
readonly internalType: "uint256";
|
|
433
|
+
readonly name: "amount";
|
|
434
|
+
readonly type: "uint256";
|
|
435
|
+
}];
|
|
436
|
+
readonly name: "Burned";
|
|
437
|
+
readonly type: "event";
|
|
438
|
+
}, {
|
|
439
|
+
readonly anonymous: false;
|
|
440
|
+
readonly inputs: readonly [{
|
|
441
|
+
readonly indexed: false;
|
|
442
|
+
readonly internalType: "uint64";
|
|
443
|
+
readonly name: "remoteChainSelector";
|
|
444
|
+
readonly type: "uint64";
|
|
445
|
+
}, {
|
|
446
|
+
readonly indexed: false;
|
|
447
|
+
readonly internalType: "bytes";
|
|
448
|
+
readonly name: "remoteToken";
|
|
449
|
+
readonly type: "bytes";
|
|
450
|
+
}, {
|
|
451
|
+
readonly components: readonly [{
|
|
452
|
+
readonly internalType: "bool";
|
|
453
|
+
readonly name: "isEnabled";
|
|
454
|
+
readonly type: "bool";
|
|
455
|
+
}, {
|
|
456
|
+
readonly internalType: "uint128";
|
|
457
|
+
readonly name: "capacity";
|
|
458
|
+
readonly type: "uint128";
|
|
459
|
+
}, {
|
|
460
|
+
readonly internalType: "uint128";
|
|
461
|
+
readonly name: "rate";
|
|
462
|
+
readonly type: "uint128";
|
|
463
|
+
}];
|
|
464
|
+
readonly indexed: false;
|
|
465
|
+
readonly internalType: "struct RateLimiter.Config";
|
|
466
|
+
readonly name: "outboundRateLimiterConfig";
|
|
467
|
+
readonly type: "tuple";
|
|
468
|
+
}, {
|
|
469
|
+
readonly components: readonly [{
|
|
470
|
+
readonly internalType: "bool";
|
|
471
|
+
readonly name: "isEnabled";
|
|
472
|
+
readonly type: "bool";
|
|
473
|
+
}, {
|
|
474
|
+
readonly internalType: "uint128";
|
|
475
|
+
readonly name: "capacity";
|
|
476
|
+
readonly type: "uint128";
|
|
477
|
+
}, {
|
|
478
|
+
readonly internalType: "uint128";
|
|
479
|
+
readonly name: "rate";
|
|
480
|
+
readonly type: "uint128";
|
|
481
|
+
}];
|
|
482
|
+
readonly indexed: false;
|
|
483
|
+
readonly internalType: "struct RateLimiter.Config";
|
|
484
|
+
readonly name: "inboundRateLimiterConfig";
|
|
485
|
+
readonly type: "tuple";
|
|
486
|
+
}];
|
|
487
|
+
readonly name: "ChainAdded";
|
|
488
|
+
readonly type: "event";
|
|
489
|
+
}, {
|
|
490
|
+
readonly anonymous: false;
|
|
491
|
+
readonly inputs: readonly [{
|
|
492
|
+
readonly indexed: false;
|
|
493
|
+
readonly internalType: "uint64";
|
|
494
|
+
readonly name: "remoteChainSelector";
|
|
495
|
+
readonly type: "uint64";
|
|
496
|
+
}, {
|
|
497
|
+
readonly components: readonly [{
|
|
498
|
+
readonly internalType: "bool";
|
|
499
|
+
readonly name: "isEnabled";
|
|
500
|
+
readonly type: "bool";
|
|
501
|
+
}, {
|
|
502
|
+
readonly internalType: "uint128";
|
|
503
|
+
readonly name: "capacity";
|
|
504
|
+
readonly type: "uint128";
|
|
505
|
+
}, {
|
|
506
|
+
readonly internalType: "uint128";
|
|
507
|
+
readonly name: "rate";
|
|
508
|
+
readonly type: "uint128";
|
|
509
|
+
}];
|
|
510
|
+
readonly indexed: false;
|
|
511
|
+
readonly internalType: "struct RateLimiter.Config";
|
|
512
|
+
readonly name: "outboundRateLimiterConfig";
|
|
513
|
+
readonly type: "tuple";
|
|
514
|
+
}, {
|
|
515
|
+
readonly components: readonly [{
|
|
516
|
+
readonly internalType: "bool";
|
|
517
|
+
readonly name: "isEnabled";
|
|
518
|
+
readonly type: "bool";
|
|
519
|
+
}, {
|
|
520
|
+
readonly internalType: "uint128";
|
|
521
|
+
readonly name: "capacity";
|
|
522
|
+
readonly type: "uint128";
|
|
523
|
+
}, {
|
|
524
|
+
readonly internalType: "uint128";
|
|
525
|
+
readonly name: "rate";
|
|
526
|
+
readonly type: "uint128";
|
|
527
|
+
}];
|
|
528
|
+
readonly indexed: false;
|
|
529
|
+
readonly internalType: "struct RateLimiter.Config";
|
|
530
|
+
readonly name: "inboundRateLimiterConfig";
|
|
531
|
+
readonly type: "tuple";
|
|
532
|
+
}];
|
|
533
|
+
readonly name: "ChainConfigured";
|
|
534
|
+
readonly type: "event";
|
|
535
|
+
}, {
|
|
536
|
+
readonly anonymous: false;
|
|
537
|
+
readonly inputs: readonly [{
|
|
538
|
+
readonly indexed: false;
|
|
539
|
+
readonly internalType: "uint64";
|
|
540
|
+
readonly name: "remoteChainSelector";
|
|
541
|
+
readonly type: "uint64";
|
|
542
|
+
}];
|
|
543
|
+
readonly name: "ChainRemoved";
|
|
544
|
+
readonly type: "event";
|
|
545
|
+
}, {
|
|
546
|
+
readonly anonymous: false;
|
|
547
|
+
readonly inputs: readonly [{
|
|
548
|
+
readonly components: readonly [{
|
|
549
|
+
readonly internalType: "bool";
|
|
550
|
+
readonly name: "isEnabled";
|
|
551
|
+
readonly type: "bool";
|
|
552
|
+
}, {
|
|
553
|
+
readonly internalType: "uint128";
|
|
554
|
+
readonly name: "capacity";
|
|
555
|
+
readonly type: "uint128";
|
|
556
|
+
}, {
|
|
557
|
+
readonly internalType: "uint128";
|
|
558
|
+
readonly name: "rate";
|
|
559
|
+
readonly type: "uint128";
|
|
560
|
+
}];
|
|
561
|
+
readonly indexed: false;
|
|
562
|
+
readonly internalType: "struct RateLimiter.Config";
|
|
563
|
+
readonly name: "config";
|
|
564
|
+
readonly type: "tuple";
|
|
565
|
+
}];
|
|
566
|
+
readonly name: "ConfigChanged";
|
|
567
|
+
readonly type: "event";
|
|
568
|
+
}, {
|
|
569
|
+
readonly anonymous: false;
|
|
570
|
+
readonly inputs: readonly [{
|
|
571
|
+
readonly indexed: false;
|
|
572
|
+
readonly internalType: "uint8";
|
|
573
|
+
readonly name: "version";
|
|
574
|
+
readonly type: "uint8";
|
|
575
|
+
}];
|
|
576
|
+
readonly name: "Initialized";
|
|
577
|
+
readonly type: "event";
|
|
578
|
+
}, {
|
|
579
|
+
readonly anonymous: false;
|
|
580
|
+
readonly inputs: readonly [{
|
|
581
|
+
readonly indexed: true;
|
|
582
|
+
readonly internalType: "address";
|
|
583
|
+
readonly name: "provider";
|
|
584
|
+
readonly type: "address";
|
|
585
|
+
}, {
|
|
586
|
+
readonly indexed: true;
|
|
587
|
+
readonly internalType: "uint256";
|
|
588
|
+
readonly name: "amount";
|
|
589
|
+
readonly type: "uint256";
|
|
590
|
+
}];
|
|
591
|
+
readonly name: "LiquidityAdded";
|
|
592
|
+
readonly type: "event";
|
|
593
|
+
}, {
|
|
594
|
+
readonly anonymous: false;
|
|
595
|
+
readonly inputs: readonly [{
|
|
596
|
+
readonly indexed: true;
|
|
597
|
+
readonly internalType: "address";
|
|
598
|
+
readonly name: "provider";
|
|
599
|
+
readonly type: "address";
|
|
600
|
+
}, {
|
|
601
|
+
readonly indexed: true;
|
|
602
|
+
readonly internalType: "uint256";
|
|
603
|
+
readonly name: "amount";
|
|
604
|
+
readonly type: "uint256";
|
|
605
|
+
}];
|
|
606
|
+
readonly name: "LiquidityRemoved";
|
|
607
|
+
readonly type: "event";
|
|
608
|
+
}, {
|
|
609
|
+
readonly anonymous: false;
|
|
610
|
+
readonly inputs: readonly [{
|
|
611
|
+
readonly indexed: true;
|
|
612
|
+
readonly internalType: "address";
|
|
613
|
+
readonly name: "from";
|
|
614
|
+
readonly type: "address";
|
|
615
|
+
}, {
|
|
616
|
+
readonly indexed: false;
|
|
617
|
+
readonly internalType: "uint256";
|
|
618
|
+
readonly name: "amount";
|
|
619
|
+
readonly type: "uint256";
|
|
620
|
+
}];
|
|
621
|
+
readonly name: "LiquidityTransferred";
|
|
622
|
+
readonly type: "event";
|
|
623
|
+
}, {
|
|
624
|
+
readonly anonymous: false;
|
|
625
|
+
readonly inputs: readonly [{
|
|
626
|
+
readonly indexed: true;
|
|
627
|
+
readonly internalType: "address";
|
|
628
|
+
readonly name: "sender";
|
|
629
|
+
readonly type: "address";
|
|
630
|
+
}, {
|
|
631
|
+
readonly indexed: false;
|
|
632
|
+
readonly internalType: "uint256";
|
|
633
|
+
readonly name: "amount";
|
|
634
|
+
readonly type: "uint256";
|
|
635
|
+
}];
|
|
636
|
+
readonly name: "Locked";
|
|
637
|
+
readonly type: "event";
|
|
638
|
+
}, {
|
|
639
|
+
readonly anonymous: false;
|
|
640
|
+
readonly inputs: readonly [{
|
|
641
|
+
readonly indexed: true;
|
|
642
|
+
readonly internalType: "address";
|
|
643
|
+
readonly name: "sender";
|
|
644
|
+
readonly type: "address";
|
|
645
|
+
}, {
|
|
646
|
+
readonly indexed: true;
|
|
647
|
+
readonly internalType: "address";
|
|
648
|
+
readonly name: "recipient";
|
|
649
|
+
readonly type: "address";
|
|
650
|
+
}, {
|
|
651
|
+
readonly indexed: false;
|
|
652
|
+
readonly internalType: "uint256";
|
|
653
|
+
readonly name: "amount";
|
|
654
|
+
readonly type: "uint256";
|
|
655
|
+
}];
|
|
656
|
+
readonly name: "Minted";
|
|
657
|
+
readonly type: "event";
|
|
658
|
+
}, {
|
|
659
|
+
readonly anonymous: false;
|
|
660
|
+
readonly inputs: readonly [{
|
|
661
|
+
readonly indexed: true;
|
|
662
|
+
readonly internalType: "address";
|
|
663
|
+
readonly name: "from";
|
|
664
|
+
readonly type: "address";
|
|
665
|
+
}, {
|
|
666
|
+
readonly indexed: true;
|
|
667
|
+
readonly internalType: "address";
|
|
668
|
+
readonly name: "to";
|
|
669
|
+
readonly type: "address";
|
|
670
|
+
}];
|
|
671
|
+
readonly name: "OwnershipTransferRequested";
|
|
672
|
+
readonly type: "event";
|
|
673
|
+
}, {
|
|
674
|
+
readonly anonymous: false;
|
|
675
|
+
readonly inputs: readonly [{
|
|
676
|
+
readonly indexed: true;
|
|
677
|
+
readonly internalType: "address";
|
|
678
|
+
readonly name: "from";
|
|
679
|
+
readonly type: "address";
|
|
680
|
+
}, {
|
|
681
|
+
readonly indexed: true;
|
|
682
|
+
readonly internalType: "address";
|
|
683
|
+
readonly name: "to";
|
|
684
|
+
readonly type: "address";
|
|
685
|
+
}];
|
|
686
|
+
readonly name: "OwnershipTransferred";
|
|
687
|
+
readonly type: "event";
|
|
688
|
+
}, {
|
|
689
|
+
readonly anonymous: false;
|
|
690
|
+
readonly inputs: readonly [{
|
|
691
|
+
readonly indexed: false;
|
|
692
|
+
readonly internalType: "address";
|
|
693
|
+
readonly name: "rateLimitAdmin";
|
|
694
|
+
readonly type: "address";
|
|
695
|
+
}];
|
|
696
|
+
readonly name: "RateLimitAdminSet";
|
|
697
|
+
readonly type: "event";
|
|
698
|
+
}, {
|
|
699
|
+
readonly anonymous: false;
|
|
700
|
+
readonly inputs: readonly [{
|
|
701
|
+
readonly indexed: true;
|
|
702
|
+
readonly internalType: "address";
|
|
703
|
+
readonly name: "sender";
|
|
704
|
+
readonly type: "address";
|
|
705
|
+
}, {
|
|
706
|
+
readonly indexed: true;
|
|
707
|
+
readonly internalType: "address";
|
|
708
|
+
readonly name: "recipient";
|
|
709
|
+
readonly type: "address";
|
|
710
|
+
}, {
|
|
711
|
+
readonly indexed: false;
|
|
712
|
+
readonly internalType: "uint256";
|
|
713
|
+
readonly name: "amount";
|
|
714
|
+
readonly type: "uint256";
|
|
715
|
+
}];
|
|
716
|
+
readonly name: "Released";
|
|
717
|
+
readonly type: "event";
|
|
718
|
+
}, {
|
|
719
|
+
readonly anonymous: false;
|
|
720
|
+
readonly inputs: readonly [{
|
|
721
|
+
readonly indexed: true;
|
|
722
|
+
readonly internalType: "uint64";
|
|
723
|
+
readonly name: "remoteChainSelector";
|
|
724
|
+
readonly type: "uint64";
|
|
725
|
+
}, {
|
|
726
|
+
readonly indexed: false;
|
|
727
|
+
readonly internalType: "bytes";
|
|
728
|
+
readonly name: "remotePoolAddress";
|
|
729
|
+
readonly type: "bytes";
|
|
730
|
+
}];
|
|
731
|
+
readonly name: "RemotePoolAdded";
|
|
732
|
+
readonly type: "event";
|
|
733
|
+
}, {
|
|
734
|
+
readonly anonymous: false;
|
|
735
|
+
readonly inputs: readonly [{
|
|
736
|
+
readonly indexed: true;
|
|
737
|
+
readonly internalType: "uint64";
|
|
738
|
+
readonly name: "remoteChainSelector";
|
|
739
|
+
readonly type: "uint64";
|
|
740
|
+
}, {
|
|
741
|
+
readonly indexed: false;
|
|
742
|
+
readonly internalType: "bytes";
|
|
743
|
+
readonly name: "remotePoolAddress";
|
|
744
|
+
readonly type: "bytes";
|
|
745
|
+
}];
|
|
746
|
+
readonly name: "RemotePoolRemoved";
|
|
747
|
+
readonly type: "event";
|
|
748
|
+
}, {
|
|
749
|
+
readonly anonymous: false;
|
|
750
|
+
readonly inputs: readonly [{
|
|
751
|
+
readonly indexed: false;
|
|
752
|
+
readonly internalType: "address";
|
|
753
|
+
readonly name: "oldRouter";
|
|
754
|
+
readonly type: "address";
|
|
755
|
+
}, {
|
|
756
|
+
readonly indexed: false;
|
|
757
|
+
readonly internalType: "address";
|
|
758
|
+
readonly name: "newRouter";
|
|
759
|
+
readonly type: "address";
|
|
760
|
+
}];
|
|
761
|
+
readonly name: "RouterUpdated";
|
|
762
|
+
readonly type: "event";
|
|
763
|
+
}, {
|
|
764
|
+
readonly anonymous: false;
|
|
765
|
+
readonly inputs: readonly [{
|
|
766
|
+
readonly indexed: false;
|
|
767
|
+
readonly internalType: "uint256";
|
|
768
|
+
readonly name: "tokens";
|
|
769
|
+
readonly type: "uint256";
|
|
770
|
+
}];
|
|
771
|
+
readonly name: "TokensConsumed";
|
|
772
|
+
readonly type: "event";
|
|
773
|
+
}, {
|
|
774
|
+
readonly inputs: readonly [];
|
|
775
|
+
readonly name: "acceptOwnership";
|
|
776
|
+
readonly outputs: readonly [];
|
|
777
|
+
readonly stateMutability: "nonpayable";
|
|
778
|
+
readonly type: "function";
|
|
779
|
+
}, {
|
|
780
|
+
readonly inputs: readonly [{
|
|
781
|
+
readonly internalType: "uint64";
|
|
782
|
+
readonly name: "remoteChainSelector";
|
|
783
|
+
readonly type: "uint64";
|
|
784
|
+
}, {
|
|
785
|
+
readonly internalType: "bytes";
|
|
786
|
+
readonly name: "remotePoolAddress";
|
|
787
|
+
readonly type: "bytes";
|
|
788
|
+
}];
|
|
789
|
+
readonly name: "addRemotePool";
|
|
790
|
+
readonly outputs: readonly [];
|
|
791
|
+
readonly stateMutability: "nonpayable";
|
|
792
|
+
readonly type: "function";
|
|
793
|
+
}, {
|
|
794
|
+
readonly inputs: readonly [{
|
|
795
|
+
readonly internalType: "address[]";
|
|
796
|
+
readonly name: "removes";
|
|
797
|
+
readonly type: "address[]";
|
|
798
|
+
}, {
|
|
799
|
+
readonly internalType: "address[]";
|
|
800
|
+
readonly name: "adds";
|
|
801
|
+
readonly type: "address[]";
|
|
802
|
+
}];
|
|
803
|
+
readonly name: "applyAllowListUpdates";
|
|
804
|
+
readonly outputs: readonly [];
|
|
805
|
+
readonly stateMutability: "nonpayable";
|
|
806
|
+
readonly type: "function";
|
|
807
|
+
}, {
|
|
808
|
+
readonly inputs: readonly [{
|
|
809
|
+
readonly internalType: "uint64[]";
|
|
810
|
+
readonly name: "remoteChainSelectorsToRemove";
|
|
811
|
+
readonly type: "uint64[]";
|
|
812
|
+
}, {
|
|
813
|
+
readonly components: readonly [{
|
|
814
|
+
readonly internalType: "uint64";
|
|
815
|
+
readonly name: "remoteChainSelector";
|
|
816
|
+
readonly type: "uint64";
|
|
817
|
+
}, {
|
|
818
|
+
readonly internalType: "bytes[]";
|
|
819
|
+
readonly name: "remotePoolAddresses";
|
|
820
|
+
readonly type: "bytes[]";
|
|
821
|
+
}, {
|
|
822
|
+
readonly internalType: "bytes";
|
|
823
|
+
readonly name: "remoteTokenAddress";
|
|
824
|
+
readonly type: "bytes";
|
|
825
|
+
}, {
|
|
826
|
+
readonly components: readonly [{
|
|
827
|
+
readonly internalType: "bool";
|
|
828
|
+
readonly name: "isEnabled";
|
|
829
|
+
readonly type: "bool";
|
|
830
|
+
}, {
|
|
831
|
+
readonly internalType: "uint128";
|
|
832
|
+
readonly name: "capacity";
|
|
833
|
+
readonly type: "uint128";
|
|
834
|
+
}, {
|
|
835
|
+
readonly internalType: "uint128";
|
|
836
|
+
readonly name: "rate";
|
|
837
|
+
readonly type: "uint128";
|
|
838
|
+
}];
|
|
839
|
+
readonly internalType: "struct RateLimiter.Config";
|
|
840
|
+
readonly name: "outboundRateLimiterConfig";
|
|
841
|
+
readonly type: "tuple";
|
|
842
|
+
}, {
|
|
843
|
+
readonly components: readonly [{
|
|
844
|
+
readonly internalType: "bool";
|
|
845
|
+
readonly name: "isEnabled";
|
|
846
|
+
readonly type: "bool";
|
|
847
|
+
}, {
|
|
848
|
+
readonly internalType: "uint128";
|
|
849
|
+
readonly name: "capacity";
|
|
850
|
+
readonly type: "uint128";
|
|
851
|
+
}, {
|
|
852
|
+
readonly internalType: "uint128";
|
|
853
|
+
readonly name: "rate";
|
|
854
|
+
readonly type: "uint128";
|
|
855
|
+
}];
|
|
856
|
+
readonly internalType: "struct RateLimiter.Config";
|
|
857
|
+
readonly name: "inboundRateLimiterConfig";
|
|
858
|
+
readonly type: "tuple";
|
|
859
|
+
}];
|
|
860
|
+
readonly internalType: "struct UpgradeableTokenPool.ChainUpdate[]";
|
|
861
|
+
readonly name: "chainsToAdd";
|
|
862
|
+
readonly type: "tuple[]";
|
|
863
|
+
}];
|
|
864
|
+
readonly name: "applyChainUpdates";
|
|
865
|
+
readonly outputs: readonly [];
|
|
866
|
+
readonly stateMutability: "nonpayable";
|
|
867
|
+
readonly type: "function";
|
|
868
|
+
}, {
|
|
869
|
+
readonly inputs: readonly [];
|
|
870
|
+
readonly name: "canAcceptLiquidity";
|
|
871
|
+
readonly outputs: readonly [{
|
|
872
|
+
readonly internalType: "bool";
|
|
873
|
+
readonly name: "";
|
|
874
|
+
readonly type: "bool";
|
|
875
|
+
}];
|
|
876
|
+
readonly stateMutability: "view";
|
|
877
|
+
readonly type: "function";
|
|
878
|
+
}, {
|
|
879
|
+
readonly inputs: readonly [];
|
|
880
|
+
readonly name: "getAllowList";
|
|
881
|
+
readonly outputs: readonly [{
|
|
882
|
+
readonly internalType: "address[]";
|
|
883
|
+
readonly name: "";
|
|
884
|
+
readonly type: "address[]";
|
|
885
|
+
}];
|
|
886
|
+
readonly stateMutability: "view";
|
|
887
|
+
readonly type: "function";
|
|
888
|
+
}, {
|
|
889
|
+
readonly inputs: readonly [];
|
|
890
|
+
readonly name: "getAllowListEnabled";
|
|
891
|
+
readonly outputs: readonly [{
|
|
892
|
+
readonly internalType: "bool";
|
|
893
|
+
readonly name: "";
|
|
894
|
+
readonly type: "bool";
|
|
895
|
+
}];
|
|
896
|
+
readonly stateMutability: "view";
|
|
897
|
+
readonly type: "function";
|
|
898
|
+
}, {
|
|
899
|
+
readonly inputs: readonly [];
|
|
900
|
+
readonly name: "getBridgeLimit";
|
|
901
|
+
readonly outputs: readonly [{
|
|
902
|
+
readonly internalType: "uint256";
|
|
903
|
+
readonly name: "";
|
|
904
|
+
readonly type: "uint256";
|
|
905
|
+
}];
|
|
906
|
+
readonly stateMutability: "view";
|
|
907
|
+
readonly type: "function";
|
|
908
|
+
}, {
|
|
909
|
+
readonly inputs: readonly [];
|
|
910
|
+
readonly name: "getBridgeLimitAdmin";
|
|
911
|
+
readonly outputs: readonly [{
|
|
912
|
+
readonly internalType: "address";
|
|
913
|
+
readonly name: "";
|
|
914
|
+
readonly type: "address";
|
|
915
|
+
}];
|
|
916
|
+
readonly stateMutability: "view";
|
|
917
|
+
readonly type: "function";
|
|
918
|
+
}, {
|
|
919
|
+
readonly inputs: readonly [];
|
|
920
|
+
readonly name: "getCurrentBridgedAmount";
|
|
921
|
+
readonly outputs: readonly [{
|
|
922
|
+
readonly internalType: "uint256";
|
|
923
|
+
readonly name: "";
|
|
924
|
+
readonly type: "uint256";
|
|
925
|
+
}];
|
|
926
|
+
readonly stateMutability: "view";
|
|
927
|
+
readonly type: "function";
|
|
928
|
+
}, {
|
|
929
|
+
readonly inputs: readonly [{
|
|
930
|
+
readonly internalType: "uint64";
|
|
931
|
+
readonly name: "remoteChainSelector";
|
|
932
|
+
readonly type: "uint64";
|
|
933
|
+
}];
|
|
934
|
+
readonly name: "getCurrentInboundRateLimiterState";
|
|
935
|
+
readonly outputs: readonly [{
|
|
936
|
+
readonly components: readonly [{
|
|
937
|
+
readonly internalType: "uint128";
|
|
938
|
+
readonly name: "tokens";
|
|
939
|
+
readonly type: "uint128";
|
|
940
|
+
}, {
|
|
941
|
+
readonly internalType: "uint32";
|
|
942
|
+
readonly name: "lastUpdated";
|
|
943
|
+
readonly type: "uint32";
|
|
944
|
+
}, {
|
|
945
|
+
readonly internalType: "bool";
|
|
946
|
+
readonly name: "isEnabled";
|
|
947
|
+
readonly type: "bool";
|
|
948
|
+
}, {
|
|
949
|
+
readonly internalType: "uint128";
|
|
950
|
+
readonly name: "capacity";
|
|
951
|
+
readonly type: "uint128";
|
|
952
|
+
}, {
|
|
953
|
+
readonly internalType: "uint128";
|
|
954
|
+
readonly name: "rate";
|
|
955
|
+
readonly type: "uint128";
|
|
956
|
+
}];
|
|
957
|
+
readonly internalType: "struct RateLimiter.TokenBucket";
|
|
958
|
+
readonly name: "";
|
|
959
|
+
readonly type: "tuple";
|
|
960
|
+
}];
|
|
961
|
+
readonly stateMutability: "view";
|
|
962
|
+
readonly type: "function";
|
|
963
|
+
}, {
|
|
964
|
+
readonly inputs: readonly [{
|
|
965
|
+
readonly internalType: "uint64";
|
|
966
|
+
readonly name: "remoteChainSelector";
|
|
967
|
+
readonly type: "uint64";
|
|
968
|
+
}];
|
|
969
|
+
readonly name: "getCurrentOutboundRateLimiterState";
|
|
970
|
+
readonly outputs: readonly [{
|
|
971
|
+
readonly components: readonly [{
|
|
972
|
+
readonly internalType: "uint128";
|
|
973
|
+
readonly name: "tokens";
|
|
974
|
+
readonly type: "uint128";
|
|
975
|
+
}, {
|
|
976
|
+
readonly internalType: "uint32";
|
|
977
|
+
readonly name: "lastUpdated";
|
|
978
|
+
readonly type: "uint32";
|
|
979
|
+
}, {
|
|
980
|
+
readonly internalType: "bool";
|
|
981
|
+
readonly name: "isEnabled";
|
|
982
|
+
readonly type: "bool";
|
|
983
|
+
}, {
|
|
984
|
+
readonly internalType: "uint128";
|
|
985
|
+
readonly name: "capacity";
|
|
986
|
+
readonly type: "uint128";
|
|
987
|
+
}, {
|
|
988
|
+
readonly internalType: "uint128";
|
|
989
|
+
readonly name: "rate";
|
|
990
|
+
readonly type: "uint128";
|
|
991
|
+
}];
|
|
992
|
+
readonly internalType: "struct RateLimiter.TokenBucket";
|
|
993
|
+
readonly name: "";
|
|
994
|
+
readonly type: "tuple";
|
|
995
|
+
}];
|
|
996
|
+
readonly stateMutability: "view";
|
|
997
|
+
readonly type: "function";
|
|
998
|
+
}, {
|
|
999
|
+
readonly inputs: readonly [];
|
|
1000
|
+
readonly name: "getRateLimitAdmin";
|
|
1001
|
+
readonly outputs: readonly [{
|
|
1002
|
+
readonly internalType: "address";
|
|
1003
|
+
readonly name: "";
|
|
1004
|
+
readonly type: "address";
|
|
1005
|
+
}];
|
|
1006
|
+
readonly stateMutability: "view";
|
|
1007
|
+
readonly type: "function";
|
|
1008
|
+
}, {
|
|
1009
|
+
readonly inputs: readonly [];
|
|
1010
|
+
readonly name: "getRebalancer";
|
|
1011
|
+
readonly outputs: readonly [{
|
|
1012
|
+
readonly internalType: "address";
|
|
1013
|
+
readonly name: "";
|
|
1014
|
+
readonly type: "address";
|
|
1015
|
+
}];
|
|
1016
|
+
readonly stateMutability: "view";
|
|
1017
|
+
readonly type: "function";
|
|
1018
|
+
}, {
|
|
1019
|
+
readonly inputs: readonly [{
|
|
1020
|
+
readonly internalType: "uint64";
|
|
1021
|
+
readonly name: "remoteChainSelector";
|
|
1022
|
+
readonly type: "uint64";
|
|
1023
|
+
}];
|
|
1024
|
+
readonly name: "getRemotePools";
|
|
1025
|
+
readonly outputs: readonly [{
|
|
1026
|
+
readonly internalType: "bytes[]";
|
|
1027
|
+
readonly name: "";
|
|
1028
|
+
readonly type: "bytes[]";
|
|
1029
|
+
}];
|
|
1030
|
+
readonly stateMutability: "view";
|
|
1031
|
+
readonly type: "function";
|
|
1032
|
+
}, {
|
|
1033
|
+
readonly inputs: readonly [{
|
|
1034
|
+
readonly internalType: "uint64";
|
|
1035
|
+
readonly name: "remoteChainSelector";
|
|
1036
|
+
readonly type: "uint64";
|
|
1037
|
+
}];
|
|
1038
|
+
readonly name: "getRemoteToken";
|
|
1039
|
+
readonly outputs: readonly [{
|
|
1040
|
+
readonly internalType: "bytes";
|
|
1041
|
+
readonly name: "";
|
|
1042
|
+
readonly type: "bytes";
|
|
1043
|
+
}];
|
|
1044
|
+
readonly stateMutability: "view";
|
|
1045
|
+
readonly type: "function";
|
|
1046
|
+
}, {
|
|
1047
|
+
readonly inputs: readonly [];
|
|
1048
|
+
readonly name: "getRmnProxy";
|
|
1049
|
+
readonly outputs: readonly [{
|
|
1050
|
+
readonly internalType: "address";
|
|
1051
|
+
readonly name: "rmnProxy";
|
|
1052
|
+
readonly type: "address";
|
|
1053
|
+
}];
|
|
1054
|
+
readonly stateMutability: "view";
|
|
1055
|
+
readonly type: "function";
|
|
1056
|
+
}, {
|
|
1057
|
+
readonly inputs: readonly [];
|
|
1058
|
+
readonly name: "getRouter";
|
|
1059
|
+
readonly outputs: readonly [{
|
|
1060
|
+
readonly internalType: "address";
|
|
1061
|
+
readonly name: "router";
|
|
1062
|
+
readonly type: "address";
|
|
1063
|
+
}];
|
|
1064
|
+
readonly stateMutability: "view";
|
|
1065
|
+
readonly type: "function";
|
|
1066
|
+
}, {
|
|
1067
|
+
readonly inputs: readonly [];
|
|
1068
|
+
readonly name: "getSupportedChains";
|
|
1069
|
+
readonly outputs: readonly [{
|
|
1070
|
+
readonly internalType: "uint64[]";
|
|
1071
|
+
readonly name: "";
|
|
1072
|
+
readonly type: "uint64[]";
|
|
1073
|
+
}];
|
|
1074
|
+
readonly stateMutability: "view";
|
|
1075
|
+
readonly type: "function";
|
|
1076
|
+
}, {
|
|
1077
|
+
readonly inputs: readonly [];
|
|
1078
|
+
readonly name: "getToken";
|
|
1079
|
+
readonly outputs: readonly [{
|
|
1080
|
+
readonly internalType: "contract IERC20";
|
|
1081
|
+
readonly name: "token";
|
|
1082
|
+
readonly type: "address";
|
|
1083
|
+
}];
|
|
1084
|
+
readonly stateMutability: "view";
|
|
1085
|
+
readonly type: "function";
|
|
1086
|
+
}, {
|
|
1087
|
+
readonly inputs: readonly [];
|
|
1088
|
+
readonly name: "getTokenDecimals";
|
|
1089
|
+
readonly outputs: readonly [{
|
|
1090
|
+
readonly internalType: "uint8";
|
|
1091
|
+
readonly name: "decimals";
|
|
1092
|
+
readonly type: "uint8";
|
|
1093
|
+
}];
|
|
1094
|
+
readonly stateMutability: "view";
|
|
1095
|
+
readonly type: "function";
|
|
1096
|
+
}, {
|
|
1097
|
+
readonly inputs: readonly [{
|
|
1098
|
+
readonly internalType: "address";
|
|
1099
|
+
readonly name: "owner_";
|
|
1100
|
+
readonly type: "address";
|
|
1101
|
+
}, {
|
|
1102
|
+
readonly internalType: "address[]";
|
|
1103
|
+
readonly name: "allowlist";
|
|
1104
|
+
readonly type: "address[]";
|
|
1105
|
+
}, {
|
|
1106
|
+
readonly internalType: "address";
|
|
1107
|
+
readonly name: "router";
|
|
1108
|
+
readonly type: "address";
|
|
1109
|
+
}, {
|
|
1110
|
+
readonly internalType: "uint256";
|
|
1111
|
+
readonly name: "bridgeLimit";
|
|
1112
|
+
readonly type: "uint256";
|
|
1113
|
+
}];
|
|
1114
|
+
readonly name: "initialize";
|
|
1115
|
+
readonly outputs: readonly [];
|
|
1116
|
+
readonly stateMutability: "nonpayable";
|
|
1117
|
+
readonly type: "function";
|
|
1118
|
+
}, {
|
|
1119
|
+
readonly inputs: readonly [{
|
|
1120
|
+
readonly internalType: "uint64";
|
|
1121
|
+
readonly name: "remoteChainSelector";
|
|
1122
|
+
readonly type: "uint64";
|
|
1123
|
+
}, {
|
|
1124
|
+
readonly internalType: "bytes";
|
|
1125
|
+
readonly name: "remotePoolAddress";
|
|
1126
|
+
readonly type: "bytes";
|
|
1127
|
+
}];
|
|
1128
|
+
readonly name: "isRemotePool";
|
|
1129
|
+
readonly outputs: readonly [{
|
|
1130
|
+
readonly internalType: "bool";
|
|
1131
|
+
readonly name: "";
|
|
1132
|
+
readonly type: "bool";
|
|
1133
|
+
}];
|
|
1134
|
+
readonly stateMutability: "view";
|
|
1135
|
+
readonly type: "function";
|
|
1136
|
+
}, {
|
|
1137
|
+
readonly inputs: readonly [{
|
|
1138
|
+
readonly internalType: "uint64";
|
|
1139
|
+
readonly name: "remoteChainSelector";
|
|
1140
|
+
readonly type: "uint64";
|
|
1141
|
+
}];
|
|
1142
|
+
readonly name: "isSupportedChain";
|
|
1143
|
+
readonly outputs: readonly [{
|
|
1144
|
+
readonly internalType: "bool";
|
|
1145
|
+
readonly name: "";
|
|
1146
|
+
readonly type: "bool";
|
|
1147
|
+
}];
|
|
1148
|
+
readonly stateMutability: "view";
|
|
1149
|
+
readonly type: "function";
|
|
1150
|
+
}, {
|
|
1151
|
+
readonly inputs: readonly [{
|
|
1152
|
+
readonly internalType: "address";
|
|
1153
|
+
readonly name: "token";
|
|
1154
|
+
readonly type: "address";
|
|
1155
|
+
}];
|
|
1156
|
+
readonly name: "isSupportedToken";
|
|
1157
|
+
readonly outputs: readonly [{
|
|
1158
|
+
readonly internalType: "bool";
|
|
1159
|
+
readonly name: "";
|
|
1160
|
+
readonly type: "bool";
|
|
1161
|
+
}];
|
|
1162
|
+
readonly stateMutability: "view";
|
|
1163
|
+
readonly type: "function";
|
|
1164
|
+
}, {
|
|
1165
|
+
readonly inputs: readonly [{
|
|
1166
|
+
readonly components: readonly [{
|
|
1167
|
+
readonly internalType: "bytes";
|
|
1168
|
+
readonly name: "receiver";
|
|
1169
|
+
readonly type: "bytes";
|
|
1170
|
+
}, {
|
|
1171
|
+
readonly internalType: "uint64";
|
|
1172
|
+
readonly name: "remoteChainSelector";
|
|
1173
|
+
readonly type: "uint64";
|
|
1174
|
+
}, {
|
|
1175
|
+
readonly internalType: "address";
|
|
1176
|
+
readonly name: "originalSender";
|
|
1177
|
+
readonly type: "address";
|
|
1178
|
+
}, {
|
|
1179
|
+
readonly internalType: "uint256";
|
|
1180
|
+
readonly name: "amount";
|
|
1181
|
+
readonly type: "uint256";
|
|
1182
|
+
}, {
|
|
1183
|
+
readonly internalType: "address";
|
|
1184
|
+
readonly name: "localToken";
|
|
1185
|
+
readonly type: "address";
|
|
1186
|
+
}];
|
|
1187
|
+
readonly internalType: "struct Pool.LockOrBurnInV1";
|
|
1188
|
+
readonly name: "lockOrBurnIn";
|
|
1189
|
+
readonly type: "tuple";
|
|
1190
|
+
}];
|
|
1191
|
+
readonly name: "lockOrBurn";
|
|
1192
|
+
readonly outputs: readonly [{
|
|
1193
|
+
readonly components: readonly [{
|
|
1194
|
+
readonly internalType: "bytes";
|
|
1195
|
+
readonly name: "destTokenAddress";
|
|
1196
|
+
readonly type: "bytes";
|
|
1197
|
+
}, {
|
|
1198
|
+
readonly internalType: "bytes";
|
|
1199
|
+
readonly name: "destPoolData";
|
|
1200
|
+
readonly type: "bytes";
|
|
1201
|
+
}];
|
|
1202
|
+
readonly internalType: "struct Pool.LockOrBurnOutV1";
|
|
1203
|
+
readonly name: "";
|
|
1204
|
+
readonly type: "tuple";
|
|
1205
|
+
}];
|
|
1206
|
+
readonly stateMutability: "nonpayable";
|
|
1207
|
+
readonly type: "function";
|
|
1208
|
+
}, {
|
|
1209
|
+
readonly inputs: readonly [];
|
|
1210
|
+
readonly name: "owner";
|
|
1211
|
+
readonly outputs: readonly [{
|
|
1212
|
+
readonly internalType: "address";
|
|
1213
|
+
readonly name: "";
|
|
1214
|
+
readonly type: "address";
|
|
1215
|
+
}];
|
|
1216
|
+
readonly stateMutability: "view";
|
|
1217
|
+
readonly type: "function";
|
|
1218
|
+
}, {
|
|
1219
|
+
readonly inputs: readonly [{
|
|
1220
|
+
readonly internalType: "uint256";
|
|
1221
|
+
readonly name: "amount";
|
|
1222
|
+
readonly type: "uint256";
|
|
1223
|
+
}];
|
|
1224
|
+
readonly name: "provideLiquidity";
|
|
1225
|
+
readonly outputs: readonly [];
|
|
1226
|
+
readonly stateMutability: "nonpayable";
|
|
1227
|
+
readonly type: "function";
|
|
1228
|
+
}, {
|
|
1229
|
+
readonly inputs: readonly [{
|
|
1230
|
+
readonly components: readonly [{
|
|
1231
|
+
readonly internalType: "bytes";
|
|
1232
|
+
readonly name: "originalSender";
|
|
1233
|
+
readonly type: "bytes";
|
|
1234
|
+
}, {
|
|
1235
|
+
readonly internalType: "uint64";
|
|
1236
|
+
readonly name: "remoteChainSelector";
|
|
1237
|
+
readonly type: "uint64";
|
|
1238
|
+
}, {
|
|
1239
|
+
readonly internalType: "address";
|
|
1240
|
+
readonly name: "receiver";
|
|
1241
|
+
readonly type: "address";
|
|
1242
|
+
}, {
|
|
1243
|
+
readonly internalType: "uint256";
|
|
1244
|
+
readonly name: "amount";
|
|
1245
|
+
readonly type: "uint256";
|
|
1246
|
+
}, {
|
|
1247
|
+
readonly internalType: "address";
|
|
1248
|
+
readonly name: "localToken";
|
|
1249
|
+
readonly type: "address";
|
|
1250
|
+
}, {
|
|
1251
|
+
readonly internalType: "bytes";
|
|
1252
|
+
readonly name: "sourcePoolAddress";
|
|
1253
|
+
readonly type: "bytes";
|
|
1254
|
+
}, {
|
|
1255
|
+
readonly internalType: "bytes";
|
|
1256
|
+
readonly name: "sourcePoolData";
|
|
1257
|
+
readonly type: "bytes";
|
|
1258
|
+
}, {
|
|
1259
|
+
readonly internalType: "bytes";
|
|
1260
|
+
readonly name: "offchainTokenData";
|
|
1261
|
+
readonly type: "bytes";
|
|
1262
|
+
}];
|
|
1263
|
+
readonly internalType: "struct Pool.ReleaseOrMintInV1";
|
|
1264
|
+
readonly name: "releaseOrMintIn";
|
|
1265
|
+
readonly type: "tuple";
|
|
1266
|
+
}];
|
|
1267
|
+
readonly name: "releaseOrMint";
|
|
1268
|
+
readonly outputs: readonly [{
|
|
1269
|
+
readonly components: readonly [{
|
|
1270
|
+
readonly internalType: "uint256";
|
|
1271
|
+
readonly name: "destinationAmount";
|
|
1272
|
+
readonly type: "uint256";
|
|
1273
|
+
}];
|
|
1274
|
+
readonly internalType: "struct Pool.ReleaseOrMintOutV1";
|
|
1275
|
+
readonly name: "";
|
|
1276
|
+
readonly type: "tuple";
|
|
1277
|
+
}];
|
|
1278
|
+
readonly stateMutability: "nonpayable";
|
|
1279
|
+
readonly type: "function";
|
|
1280
|
+
}, {
|
|
1281
|
+
readonly inputs: readonly [{
|
|
1282
|
+
readonly internalType: "uint64";
|
|
1283
|
+
readonly name: "remoteChainSelector";
|
|
1284
|
+
readonly type: "uint64";
|
|
1285
|
+
}, {
|
|
1286
|
+
readonly internalType: "bytes";
|
|
1287
|
+
readonly name: "remotePoolAddress";
|
|
1288
|
+
readonly type: "bytes";
|
|
1289
|
+
}];
|
|
1290
|
+
readonly name: "removeRemotePool";
|
|
1291
|
+
readonly outputs: readonly [];
|
|
1292
|
+
readonly stateMutability: "nonpayable";
|
|
1293
|
+
readonly type: "function";
|
|
1294
|
+
}, {
|
|
1295
|
+
readonly inputs: readonly [{
|
|
1296
|
+
readonly internalType: "uint256";
|
|
1297
|
+
readonly name: "newBridgeLimit";
|
|
1298
|
+
readonly type: "uint256";
|
|
1299
|
+
}];
|
|
1300
|
+
readonly name: "setBridgeLimit";
|
|
1301
|
+
readonly outputs: readonly [];
|
|
1302
|
+
readonly stateMutability: "nonpayable";
|
|
1303
|
+
readonly type: "function";
|
|
1304
|
+
}, {
|
|
1305
|
+
readonly inputs: readonly [{
|
|
1306
|
+
readonly internalType: "address";
|
|
1307
|
+
readonly name: "bridgeLimitAdmin";
|
|
1308
|
+
readonly type: "address";
|
|
1309
|
+
}];
|
|
1310
|
+
readonly name: "setBridgeLimitAdmin";
|
|
1311
|
+
readonly outputs: readonly [];
|
|
1312
|
+
readonly stateMutability: "nonpayable";
|
|
1313
|
+
readonly type: "function";
|
|
1314
|
+
}, {
|
|
1315
|
+
readonly inputs: readonly [{
|
|
1316
|
+
readonly internalType: "uint64";
|
|
1317
|
+
readonly name: "remoteChainSelector";
|
|
1318
|
+
readonly type: "uint64";
|
|
1319
|
+
}, {
|
|
1320
|
+
readonly components: readonly [{
|
|
1321
|
+
readonly internalType: "bool";
|
|
1322
|
+
readonly name: "isEnabled";
|
|
1323
|
+
readonly type: "bool";
|
|
1324
|
+
}, {
|
|
1325
|
+
readonly internalType: "uint128";
|
|
1326
|
+
readonly name: "capacity";
|
|
1327
|
+
readonly type: "uint128";
|
|
1328
|
+
}, {
|
|
1329
|
+
readonly internalType: "uint128";
|
|
1330
|
+
readonly name: "rate";
|
|
1331
|
+
readonly type: "uint128";
|
|
1332
|
+
}];
|
|
1333
|
+
readonly internalType: "struct RateLimiter.Config";
|
|
1334
|
+
readonly name: "outboundConfig";
|
|
1335
|
+
readonly type: "tuple";
|
|
1336
|
+
}, {
|
|
1337
|
+
readonly components: readonly [{
|
|
1338
|
+
readonly internalType: "bool";
|
|
1339
|
+
readonly name: "isEnabled";
|
|
1340
|
+
readonly type: "bool";
|
|
1341
|
+
}, {
|
|
1342
|
+
readonly internalType: "uint128";
|
|
1343
|
+
readonly name: "capacity";
|
|
1344
|
+
readonly type: "uint128";
|
|
1345
|
+
}, {
|
|
1346
|
+
readonly internalType: "uint128";
|
|
1347
|
+
readonly name: "rate";
|
|
1348
|
+
readonly type: "uint128";
|
|
1349
|
+
}];
|
|
1350
|
+
readonly internalType: "struct RateLimiter.Config";
|
|
1351
|
+
readonly name: "inboundConfig";
|
|
1352
|
+
readonly type: "tuple";
|
|
1353
|
+
}];
|
|
1354
|
+
readonly name: "setChainRateLimiterConfig";
|
|
1355
|
+
readonly outputs: readonly [];
|
|
1356
|
+
readonly stateMutability: "nonpayable";
|
|
1357
|
+
readonly type: "function";
|
|
1358
|
+
}, {
|
|
1359
|
+
readonly inputs: readonly [{
|
|
1360
|
+
readonly internalType: "uint256";
|
|
1361
|
+
readonly name: "newCurrentBridged";
|
|
1362
|
+
readonly type: "uint256";
|
|
1363
|
+
}];
|
|
1364
|
+
readonly name: "setCurrentBridgedAmount";
|
|
1365
|
+
readonly outputs: readonly [];
|
|
1366
|
+
readonly stateMutability: "nonpayable";
|
|
1367
|
+
readonly type: "function";
|
|
1368
|
+
}, {
|
|
1369
|
+
readonly inputs: readonly [{
|
|
1370
|
+
readonly internalType: "address";
|
|
1371
|
+
readonly name: "rateLimitAdmin";
|
|
1372
|
+
readonly type: "address";
|
|
1373
|
+
}];
|
|
1374
|
+
readonly name: "setRateLimitAdmin";
|
|
1375
|
+
readonly outputs: readonly [];
|
|
1376
|
+
readonly stateMutability: "nonpayable";
|
|
1377
|
+
readonly type: "function";
|
|
1378
|
+
}, {
|
|
1379
|
+
readonly inputs: readonly [{
|
|
1380
|
+
readonly internalType: "address";
|
|
1381
|
+
readonly name: "rebalancer";
|
|
1382
|
+
readonly type: "address";
|
|
1383
|
+
}];
|
|
1384
|
+
readonly name: "setRebalancer";
|
|
1385
|
+
readonly outputs: readonly [];
|
|
1386
|
+
readonly stateMutability: "nonpayable";
|
|
1387
|
+
readonly type: "function";
|
|
1388
|
+
}, {
|
|
1389
|
+
readonly inputs: readonly [{
|
|
1390
|
+
readonly internalType: "address";
|
|
1391
|
+
readonly name: "newRouter";
|
|
1392
|
+
readonly type: "address";
|
|
1393
|
+
}];
|
|
1394
|
+
readonly name: "setRouter";
|
|
1395
|
+
readonly outputs: readonly [];
|
|
1396
|
+
readonly stateMutability: "nonpayable";
|
|
1397
|
+
readonly type: "function";
|
|
1398
|
+
}, {
|
|
1399
|
+
readonly inputs: readonly [{
|
|
1400
|
+
readonly internalType: "bytes4";
|
|
1401
|
+
readonly name: "interfaceId";
|
|
1402
|
+
readonly type: "bytes4";
|
|
1403
|
+
}];
|
|
1404
|
+
readonly name: "supportsInterface";
|
|
1405
|
+
readonly outputs: readonly [{
|
|
1406
|
+
readonly internalType: "bool";
|
|
1407
|
+
readonly name: "";
|
|
1408
|
+
readonly type: "bool";
|
|
1409
|
+
}];
|
|
1410
|
+
readonly stateMutability: "pure";
|
|
1411
|
+
readonly type: "function";
|
|
1412
|
+
}, {
|
|
1413
|
+
readonly inputs: readonly [{
|
|
1414
|
+
readonly internalType: "address";
|
|
1415
|
+
readonly name: "from";
|
|
1416
|
+
readonly type: "address";
|
|
1417
|
+
}, {
|
|
1418
|
+
readonly internalType: "uint256";
|
|
1419
|
+
readonly name: "amount";
|
|
1420
|
+
readonly type: "uint256";
|
|
1421
|
+
}];
|
|
1422
|
+
readonly name: "transferLiquidity";
|
|
1423
|
+
readonly outputs: readonly [];
|
|
1424
|
+
readonly stateMutability: "nonpayable";
|
|
1425
|
+
readonly type: "function";
|
|
1426
|
+
}, {
|
|
1427
|
+
readonly inputs: readonly [{
|
|
1428
|
+
readonly internalType: "address";
|
|
1429
|
+
readonly name: "to";
|
|
1430
|
+
readonly type: "address";
|
|
1431
|
+
}];
|
|
1432
|
+
readonly name: "transferOwnership";
|
|
1433
|
+
readonly outputs: readonly [];
|
|
1434
|
+
readonly stateMutability: "nonpayable";
|
|
1435
|
+
readonly type: "function";
|
|
1436
|
+
}, {
|
|
1437
|
+
readonly inputs: readonly [];
|
|
1438
|
+
readonly name: "typeAndVersion";
|
|
1439
|
+
readonly outputs: readonly [{
|
|
1440
|
+
readonly internalType: "string";
|
|
1441
|
+
readonly name: "";
|
|
1442
|
+
readonly type: "string";
|
|
1443
|
+
}];
|
|
1444
|
+
readonly stateMutability: "view";
|
|
1445
|
+
readonly type: "function";
|
|
1446
|
+
}, {
|
|
1447
|
+
readonly inputs: readonly [{
|
|
1448
|
+
readonly internalType: "uint256";
|
|
1449
|
+
readonly name: "amount";
|
|
1450
|
+
readonly type: "uint256";
|
|
1451
|
+
}];
|
|
1452
|
+
readonly name: "withdrawLiquidity";
|
|
1453
|
+
readonly outputs: readonly [];
|
|
1454
|
+
readonly stateMutability: "nonpayable";
|
|
1455
|
+
readonly type: "function";
|
|
1456
|
+
}];
|
|
1457
|
+
/**
|
|
1458
|
+
* Type-safe ABI for UpgradeableLockReleaseTokenPool
|
|
1459
|
+
*/
|
|
1460
|
+
export type UpgradeableLockReleaseTokenPoolAbi = typeof UpgradeableLockReleaseTokenPoolAbi;
|
|
1461
|
+
/**
|
|
1462
|
+
* Contract instance type for UpgradeableLockReleaseTokenPool
|
|
1463
|
+
*/
|
|
1464
|
+
export type UpgradeableLockReleaseTokenPoolContract = any;
|
|
1465
|
+
/**
|
|
1466
|
+
* UpgradeableLockReleaseTokenPool Contract Class
|
|
1467
|
+
*
|
|
1468
|
+
* Provides a class-based API similar to TypeChain for interacting with the contract.
|
|
1469
|
+
*
|
|
1470
|
+
* @example
|
|
1471
|
+
* ```typescript
|
|
1472
|
+
* import { createPublicClient, createWalletClient, http } from 'viem';
|
|
1473
|
+
* import { mainnet } from 'viem/chains';
|
|
1474
|
+
* import { UpgradeableLockReleaseTokenPool } from 'UpgradeableLockReleaseTokenPool';
|
|
1475
|
+
*
|
|
1476
|
+
* const publicClient = createPublicClient({ chain: mainnet, transport: http() });
|
|
1477
|
+
* const walletClient = createWalletClient({ chain: mainnet, transport: http() });
|
|
1478
|
+
*
|
|
1479
|
+
* const contract = new UpgradeableLockReleaseTokenPool('0x...', { publicClient, walletClient });
|
|
1480
|
+
*
|
|
1481
|
+
* // Read functions
|
|
1482
|
+
* const result = await contract.balanceOf('0x...');
|
|
1483
|
+
*
|
|
1484
|
+
* // Write functions
|
|
1485
|
+
* const hash = await contract.transfer('0x...', 1000n);
|
|
1486
|
+
*
|
|
1487
|
+
* // Simulate transactions (dry-run)
|
|
1488
|
+
* const simulation = await contract.simulate.transfer('0x...', 1000n);
|
|
1489
|
+
* console.log('Gas estimate:', simulation.request.gas);
|
|
1490
|
+
*
|
|
1491
|
+
* // Watch events
|
|
1492
|
+
* const unwatch = contract.watch.Transfer((event) => {
|
|
1493
|
+
* console.log('Transfer event:', event);
|
|
1494
|
+
* });
|
|
1495
|
+
* ```
|
|
1496
|
+
*/
|
|
1497
|
+
export declare class UpgradeableLockReleaseTokenPool {
|
|
1498
|
+
private contract;
|
|
1499
|
+
private contractAddress;
|
|
1500
|
+
private publicClient;
|
|
1501
|
+
constructor(address: Address, clients: {
|
|
1502
|
+
publicClient: PublicClient;
|
|
1503
|
+
walletClient?: WalletClient;
|
|
1504
|
+
});
|
|
1505
|
+
/**
|
|
1506
|
+
* Get the contract address
|
|
1507
|
+
*/
|
|
1508
|
+
get address(): Address;
|
|
1509
|
+
/**
|
|
1510
|
+
* Get the underlying viem contract instance.
|
|
1511
|
+
*/
|
|
1512
|
+
getContract(): UpgradeableLockReleaseTokenPoolContract;
|
|
1513
|
+
/**
|
|
1514
|
+
* canAcceptLiquidity
|
|
1515
|
+
* view
|
|
1516
|
+
*/
|
|
1517
|
+
canAcceptLiquidity(): Promise<boolean>;
|
|
1518
|
+
/**
|
|
1519
|
+
* getAllowList
|
|
1520
|
+
* view
|
|
1521
|
+
*/
|
|
1522
|
+
getAllowList(): Promise<`0x${string}`[]>;
|
|
1523
|
+
/**
|
|
1524
|
+
* getAllowListEnabled
|
|
1525
|
+
* view
|
|
1526
|
+
*/
|
|
1527
|
+
getAllowListEnabled(): Promise<boolean>;
|
|
1528
|
+
/**
|
|
1529
|
+
* getBridgeLimit
|
|
1530
|
+
* view
|
|
1531
|
+
*/
|
|
1532
|
+
getBridgeLimit(): Promise<bigint>;
|
|
1533
|
+
/**
|
|
1534
|
+
* getBridgeLimitAdmin
|
|
1535
|
+
* view
|
|
1536
|
+
*/
|
|
1537
|
+
getBridgeLimitAdmin(): Promise<`0x${string}`>;
|
|
1538
|
+
/**
|
|
1539
|
+
* getCurrentBridgedAmount
|
|
1540
|
+
* view
|
|
1541
|
+
*/
|
|
1542
|
+
getCurrentBridgedAmount(): Promise<bigint>;
|
|
1543
|
+
/**
|
|
1544
|
+
* getCurrentInboundRateLimiterState
|
|
1545
|
+
* view
|
|
1546
|
+
*/
|
|
1547
|
+
getCurrentInboundRateLimiterState(remoteChainSelector: bigint): Promise<RateLimiter_TokenBucket>;
|
|
1548
|
+
/**
|
|
1549
|
+
* getCurrentOutboundRateLimiterState
|
|
1550
|
+
* view
|
|
1551
|
+
*/
|
|
1552
|
+
getCurrentOutboundRateLimiterState(remoteChainSelector: bigint): Promise<RateLimiter_TokenBucket>;
|
|
1553
|
+
/**
|
|
1554
|
+
* getRateLimitAdmin
|
|
1555
|
+
* view
|
|
1556
|
+
*/
|
|
1557
|
+
getRateLimitAdmin(): Promise<`0x${string}`>;
|
|
1558
|
+
/**
|
|
1559
|
+
* getRebalancer
|
|
1560
|
+
* view
|
|
1561
|
+
*/
|
|
1562
|
+
getRebalancer(): Promise<`0x${string}`>;
|
|
1563
|
+
/**
|
|
1564
|
+
* getRemotePools
|
|
1565
|
+
* view
|
|
1566
|
+
*/
|
|
1567
|
+
getRemotePools(remoteChainSelector: bigint): Promise<`0x${string}`[]>;
|
|
1568
|
+
/**
|
|
1569
|
+
* getRemoteToken
|
|
1570
|
+
* view
|
|
1571
|
+
*/
|
|
1572
|
+
getRemoteToken(remoteChainSelector: bigint): Promise<`0x${string}`>;
|
|
1573
|
+
/**
|
|
1574
|
+
* getRmnProxy
|
|
1575
|
+
* view
|
|
1576
|
+
*/
|
|
1577
|
+
getRmnProxy(): Promise<`0x${string}`>;
|
|
1578
|
+
/**
|
|
1579
|
+
* getRouter
|
|
1580
|
+
* view
|
|
1581
|
+
*/
|
|
1582
|
+
getRouter(): Promise<`0x${string}`>;
|
|
1583
|
+
/**
|
|
1584
|
+
* getSupportedChains
|
|
1585
|
+
* view
|
|
1586
|
+
*/
|
|
1587
|
+
getSupportedChains(): Promise<bigint[]>;
|
|
1588
|
+
/**
|
|
1589
|
+
* getToken
|
|
1590
|
+
* view
|
|
1591
|
+
*/
|
|
1592
|
+
getToken(): Promise<`0x${string}`>;
|
|
1593
|
+
/**
|
|
1594
|
+
* getTokenDecimals
|
|
1595
|
+
* view
|
|
1596
|
+
*/
|
|
1597
|
+
getTokenDecimals(): Promise<bigint>;
|
|
1598
|
+
/**
|
|
1599
|
+
* isRemotePool
|
|
1600
|
+
* view
|
|
1601
|
+
*/
|
|
1602
|
+
isRemotePool(remoteChainSelector: bigint, remotePoolAddress: `0x${string}`): Promise<boolean>;
|
|
1603
|
+
/**
|
|
1604
|
+
* isSupportedChain
|
|
1605
|
+
* view
|
|
1606
|
+
*/
|
|
1607
|
+
isSupportedChain(remoteChainSelector: bigint): Promise<boolean>;
|
|
1608
|
+
/**
|
|
1609
|
+
* isSupportedToken
|
|
1610
|
+
* view
|
|
1611
|
+
*/
|
|
1612
|
+
isSupportedToken(token: `0x${string}`): Promise<boolean>;
|
|
1613
|
+
/**
|
|
1614
|
+
* owner
|
|
1615
|
+
* view
|
|
1616
|
+
*/
|
|
1617
|
+
owner(): Promise<`0x${string}`>;
|
|
1618
|
+
/**
|
|
1619
|
+
* supportsInterface
|
|
1620
|
+
* pure
|
|
1621
|
+
*/
|
|
1622
|
+
supportsInterface(interfaceId: `0x${string}`): Promise<boolean>;
|
|
1623
|
+
/**
|
|
1624
|
+
* typeAndVersion
|
|
1625
|
+
* view
|
|
1626
|
+
*/
|
|
1627
|
+
typeAndVersion(): Promise<string>;
|
|
1628
|
+
/**
|
|
1629
|
+
* acceptOwnership
|
|
1630
|
+
* nonpayable
|
|
1631
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1632
|
+
*/
|
|
1633
|
+
acceptOwnership(options?: {
|
|
1634
|
+
accessList?: import('viem').AccessList;
|
|
1635
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1636
|
+
chain?: import('viem').Chain | null;
|
|
1637
|
+
dataSuffix?: `0x${string}`;
|
|
1638
|
+
gas?: bigint;
|
|
1639
|
+
gasPrice?: bigint;
|
|
1640
|
+
maxFeePerGas?: bigint;
|
|
1641
|
+
maxPriorityFeePerGas?: bigint;
|
|
1642
|
+
nonce?: number;
|
|
1643
|
+
value?: bigint;
|
|
1644
|
+
}): Promise<`0x${string}`>;
|
|
1645
|
+
/**
|
|
1646
|
+
* addRemotePool
|
|
1647
|
+
* nonpayable
|
|
1648
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1649
|
+
*/
|
|
1650
|
+
addRemotePool(remoteChainSelector: bigint, remotePoolAddress: `0x${string}`, options?: {
|
|
1651
|
+
accessList?: import('viem').AccessList;
|
|
1652
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1653
|
+
chain?: import('viem').Chain | null;
|
|
1654
|
+
dataSuffix?: `0x${string}`;
|
|
1655
|
+
gas?: bigint;
|
|
1656
|
+
gasPrice?: bigint;
|
|
1657
|
+
maxFeePerGas?: bigint;
|
|
1658
|
+
maxPriorityFeePerGas?: bigint;
|
|
1659
|
+
nonce?: number;
|
|
1660
|
+
value?: bigint;
|
|
1661
|
+
}): Promise<`0x${string}`>;
|
|
1662
|
+
/**
|
|
1663
|
+
* applyAllowListUpdates
|
|
1664
|
+
* nonpayable
|
|
1665
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1666
|
+
*/
|
|
1667
|
+
applyAllowListUpdates(removes: `0x${string}`[], adds: `0x${string}`[], options?: {
|
|
1668
|
+
accessList?: import('viem').AccessList;
|
|
1669
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1670
|
+
chain?: import('viem').Chain | null;
|
|
1671
|
+
dataSuffix?: `0x${string}`;
|
|
1672
|
+
gas?: bigint;
|
|
1673
|
+
gasPrice?: bigint;
|
|
1674
|
+
maxFeePerGas?: bigint;
|
|
1675
|
+
maxPriorityFeePerGas?: bigint;
|
|
1676
|
+
nonce?: number;
|
|
1677
|
+
value?: bigint;
|
|
1678
|
+
}): Promise<`0x${string}`>;
|
|
1679
|
+
/**
|
|
1680
|
+
* applyChainUpdates
|
|
1681
|
+
* nonpayable
|
|
1682
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1683
|
+
*/
|
|
1684
|
+
applyChainUpdates(remoteChainSelectorsToRemove: bigint[], chainsToAdd: UpgradeableTokenPool_ChainUpdate[], options?: {
|
|
1685
|
+
accessList?: import('viem').AccessList;
|
|
1686
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1687
|
+
chain?: import('viem').Chain | null;
|
|
1688
|
+
dataSuffix?: `0x${string}`;
|
|
1689
|
+
gas?: bigint;
|
|
1690
|
+
gasPrice?: bigint;
|
|
1691
|
+
maxFeePerGas?: bigint;
|
|
1692
|
+
maxPriorityFeePerGas?: bigint;
|
|
1693
|
+
nonce?: number;
|
|
1694
|
+
value?: bigint;
|
|
1695
|
+
}): Promise<`0x${string}`>;
|
|
1696
|
+
/**
|
|
1697
|
+
* initialize
|
|
1698
|
+
* nonpayable
|
|
1699
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1700
|
+
*/
|
|
1701
|
+
initialize(owner_: `0x${string}`, allowlist: `0x${string}`[], router: `0x${string}`, bridgeLimit: bigint, options?: {
|
|
1702
|
+
accessList?: import('viem').AccessList;
|
|
1703
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1704
|
+
chain?: import('viem').Chain | null;
|
|
1705
|
+
dataSuffix?: `0x${string}`;
|
|
1706
|
+
gas?: bigint;
|
|
1707
|
+
gasPrice?: bigint;
|
|
1708
|
+
maxFeePerGas?: bigint;
|
|
1709
|
+
maxPriorityFeePerGas?: bigint;
|
|
1710
|
+
nonce?: number;
|
|
1711
|
+
value?: bigint;
|
|
1712
|
+
}): Promise<`0x${string}`>;
|
|
1713
|
+
/**
|
|
1714
|
+
* lockOrBurn
|
|
1715
|
+
* nonpayable
|
|
1716
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1717
|
+
*/
|
|
1718
|
+
lockOrBurn(lockOrBurnIn: Pool_LockOrBurnInV1, options?: {
|
|
1719
|
+
accessList?: import('viem').AccessList;
|
|
1720
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1721
|
+
chain?: import('viem').Chain | null;
|
|
1722
|
+
dataSuffix?: `0x${string}`;
|
|
1723
|
+
gas?: bigint;
|
|
1724
|
+
gasPrice?: bigint;
|
|
1725
|
+
maxFeePerGas?: bigint;
|
|
1726
|
+
maxPriorityFeePerGas?: bigint;
|
|
1727
|
+
nonce?: number;
|
|
1728
|
+
value?: bigint;
|
|
1729
|
+
}): Promise<`0x${string}`>;
|
|
1730
|
+
/**
|
|
1731
|
+
* provideLiquidity
|
|
1732
|
+
* nonpayable
|
|
1733
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1734
|
+
*/
|
|
1735
|
+
provideLiquidity(amount: bigint, options?: {
|
|
1736
|
+
accessList?: import('viem').AccessList;
|
|
1737
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1738
|
+
chain?: import('viem').Chain | null;
|
|
1739
|
+
dataSuffix?: `0x${string}`;
|
|
1740
|
+
gas?: bigint;
|
|
1741
|
+
gasPrice?: bigint;
|
|
1742
|
+
maxFeePerGas?: bigint;
|
|
1743
|
+
maxPriorityFeePerGas?: bigint;
|
|
1744
|
+
nonce?: number;
|
|
1745
|
+
value?: bigint;
|
|
1746
|
+
}): Promise<`0x${string}`>;
|
|
1747
|
+
/**
|
|
1748
|
+
* releaseOrMint
|
|
1749
|
+
* nonpayable
|
|
1750
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1751
|
+
*/
|
|
1752
|
+
releaseOrMint(releaseOrMintIn: Pool_ReleaseOrMintInV1, options?: {
|
|
1753
|
+
accessList?: import('viem').AccessList;
|
|
1754
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1755
|
+
chain?: import('viem').Chain | null;
|
|
1756
|
+
dataSuffix?: `0x${string}`;
|
|
1757
|
+
gas?: bigint;
|
|
1758
|
+
gasPrice?: bigint;
|
|
1759
|
+
maxFeePerGas?: bigint;
|
|
1760
|
+
maxPriorityFeePerGas?: bigint;
|
|
1761
|
+
nonce?: number;
|
|
1762
|
+
value?: bigint;
|
|
1763
|
+
}): Promise<`0x${string}`>;
|
|
1764
|
+
/**
|
|
1765
|
+
* removeRemotePool
|
|
1766
|
+
* nonpayable
|
|
1767
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1768
|
+
*/
|
|
1769
|
+
removeRemotePool(remoteChainSelector: bigint, remotePoolAddress: `0x${string}`, options?: {
|
|
1770
|
+
accessList?: import('viem').AccessList;
|
|
1771
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1772
|
+
chain?: import('viem').Chain | null;
|
|
1773
|
+
dataSuffix?: `0x${string}`;
|
|
1774
|
+
gas?: bigint;
|
|
1775
|
+
gasPrice?: bigint;
|
|
1776
|
+
maxFeePerGas?: bigint;
|
|
1777
|
+
maxPriorityFeePerGas?: bigint;
|
|
1778
|
+
nonce?: number;
|
|
1779
|
+
value?: bigint;
|
|
1780
|
+
}): Promise<`0x${string}`>;
|
|
1781
|
+
/**
|
|
1782
|
+
* setBridgeLimit
|
|
1783
|
+
* nonpayable
|
|
1784
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1785
|
+
*/
|
|
1786
|
+
setBridgeLimit(newBridgeLimit: bigint, options?: {
|
|
1787
|
+
accessList?: import('viem').AccessList;
|
|
1788
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1789
|
+
chain?: import('viem').Chain | null;
|
|
1790
|
+
dataSuffix?: `0x${string}`;
|
|
1791
|
+
gas?: bigint;
|
|
1792
|
+
gasPrice?: bigint;
|
|
1793
|
+
maxFeePerGas?: bigint;
|
|
1794
|
+
maxPriorityFeePerGas?: bigint;
|
|
1795
|
+
nonce?: number;
|
|
1796
|
+
value?: bigint;
|
|
1797
|
+
}): Promise<`0x${string}`>;
|
|
1798
|
+
/**
|
|
1799
|
+
* setBridgeLimitAdmin
|
|
1800
|
+
* nonpayable
|
|
1801
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1802
|
+
*/
|
|
1803
|
+
setBridgeLimitAdmin(bridgeLimitAdmin: `0x${string}`, options?: {
|
|
1804
|
+
accessList?: import('viem').AccessList;
|
|
1805
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1806
|
+
chain?: import('viem').Chain | null;
|
|
1807
|
+
dataSuffix?: `0x${string}`;
|
|
1808
|
+
gas?: bigint;
|
|
1809
|
+
gasPrice?: bigint;
|
|
1810
|
+
maxFeePerGas?: bigint;
|
|
1811
|
+
maxPriorityFeePerGas?: bigint;
|
|
1812
|
+
nonce?: number;
|
|
1813
|
+
value?: bigint;
|
|
1814
|
+
}): Promise<`0x${string}`>;
|
|
1815
|
+
/**
|
|
1816
|
+
* setChainRateLimiterConfig
|
|
1817
|
+
* nonpayable
|
|
1818
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1819
|
+
*/
|
|
1820
|
+
setChainRateLimiterConfig(remoteChainSelector: bigint, outboundConfig: RateLimiter_Config, inboundConfig: RateLimiter_Config, options?: {
|
|
1821
|
+
accessList?: import('viem').AccessList;
|
|
1822
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1823
|
+
chain?: import('viem').Chain | null;
|
|
1824
|
+
dataSuffix?: `0x${string}`;
|
|
1825
|
+
gas?: bigint;
|
|
1826
|
+
gasPrice?: bigint;
|
|
1827
|
+
maxFeePerGas?: bigint;
|
|
1828
|
+
maxPriorityFeePerGas?: bigint;
|
|
1829
|
+
nonce?: number;
|
|
1830
|
+
value?: bigint;
|
|
1831
|
+
}): Promise<`0x${string}`>;
|
|
1832
|
+
/**
|
|
1833
|
+
* setCurrentBridgedAmount
|
|
1834
|
+
* nonpayable
|
|
1835
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1836
|
+
*/
|
|
1837
|
+
setCurrentBridgedAmount(newCurrentBridged: bigint, options?: {
|
|
1838
|
+
accessList?: import('viem').AccessList;
|
|
1839
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1840
|
+
chain?: import('viem').Chain | null;
|
|
1841
|
+
dataSuffix?: `0x${string}`;
|
|
1842
|
+
gas?: bigint;
|
|
1843
|
+
gasPrice?: bigint;
|
|
1844
|
+
maxFeePerGas?: bigint;
|
|
1845
|
+
maxPriorityFeePerGas?: bigint;
|
|
1846
|
+
nonce?: number;
|
|
1847
|
+
value?: bigint;
|
|
1848
|
+
}): Promise<`0x${string}`>;
|
|
1849
|
+
/**
|
|
1850
|
+
* setRateLimitAdmin
|
|
1851
|
+
* nonpayable
|
|
1852
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1853
|
+
*/
|
|
1854
|
+
setRateLimitAdmin(rateLimitAdmin: `0x${string}`, options?: {
|
|
1855
|
+
accessList?: import('viem').AccessList;
|
|
1856
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1857
|
+
chain?: import('viem').Chain | null;
|
|
1858
|
+
dataSuffix?: `0x${string}`;
|
|
1859
|
+
gas?: bigint;
|
|
1860
|
+
gasPrice?: bigint;
|
|
1861
|
+
maxFeePerGas?: bigint;
|
|
1862
|
+
maxPriorityFeePerGas?: bigint;
|
|
1863
|
+
nonce?: number;
|
|
1864
|
+
value?: bigint;
|
|
1865
|
+
}): Promise<`0x${string}`>;
|
|
1866
|
+
/**
|
|
1867
|
+
* setRebalancer
|
|
1868
|
+
* nonpayable
|
|
1869
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1870
|
+
*/
|
|
1871
|
+
setRebalancer(rebalancer: `0x${string}`, options?: {
|
|
1872
|
+
accessList?: import('viem').AccessList;
|
|
1873
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1874
|
+
chain?: import('viem').Chain | null;
|
|
1875
|
+
dataSuffix?: `0x${string}`;
|
|
1876
|
+
gas?: bigint;
|
|
1877
|
+
gasPrice?: bigint;
|
|
1878
|
+
maxFeePerGas?: bigint;
|
|
1879
|
+
maxPriorityFeePerGas?: bigint;
|
|
1880
|
+
nonce?: number;
|
|
1881
|
+
value?: bigint;
|
|
1882
|
+
}): Promise<`0x${string}`>;
|
|
1883
|
+
/**
|
|
1884
|
+
* setRouter
|
|
1885
|
+
* nonpayable
|
|
1886
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1887
|
+
*/
|
|
1888
|
+
setRouter(newRouter: `0x${string}`, options?: {
|
|
1889
|
+
accessList?: import('viem').AccessList;
|
|
1890
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1891
|
+
chain?: import('viem').Chain | null;
|
|
1892
|
+
dataSuffix?: `0x${string}`;
|
|
1893
|
+
gas?: bigint;
|
|
1894
|
+
gasPrice?: bigint;
|
|
1895
|
+
maxFeePerGas?: bigint;
|
|
1896
|
+
maxPriorityFeePerGas?: bigint;
|
|
1897
|
+
nonce?: number;
|
|
1898
|
+
value?: bigint;
|
|
1899
|
+
}): Promise<`0x${string}`>;
|
|
1900
|
+
/**
|
|
1901
|
+
* transferLiquidity
|
|
1902
|
+
* nonpayable
|
|
1903
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1904
|
+
*/
|
|
1905
|
+
transferLiquidity(from: `0x${string}`, amount: bigint, options?: {
|
|
1906
|
+
accessList?: import('viem').AccessList;
|
|
1907
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1908
|
+
chain?: import('viem').Chain | null;
|
|
1909
|
+
dataSuffix?: `0x${string}`;
|
|
1910
|
+
gas?: bigint;
|
|
1911
|
+
gasPrice?: bigint;
|
|
1912
|
+
maxFeePerGas?: bigint;
|
|
1913
|
+
maxPriorityFeePerGas?: bigint;
|
|
1914
|
+
nonce?: number;
|
|
1915
|
+
value?: bigint;
|
|
1916
|
+
}): Promise<`0x${string}`>;
|
|
1917
|
+
/**
|
|
1918
|
+
* transferOwnership
|
|
1919
|
+
* nonpayable
|
|
1920
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1921
|
+
*/
|
|
1922
|
+
transferOwnership(to: `0x${string}`, options?: {
|
|
1923
|
+
accessList?: import('viem').AccessList;
|
|
1924
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1925
|
+
chain?: import('viem').Chain | null;
|
|
1926
|
+
dataSuffix?: `0x${string}`;
|
|
1927
|
+
gas?: bigint;
|
|
1928
|
+
gasPrice?: bigint;
|
|
1929
|
+
maxFeePerGas?: bigint;
|
|
1930
|
+
maxPriorityFeePerGas?: bigint;
|
|
1931
|
+
nonce?: number;
|
|
1932
|
+
value?: bigint;
|
|
1933
|
+
}): Promise<`0x${string}`>;
|
|
1934
|
+
/**
|
|
1935
|
+
* withdrawLiquidity
|
|
1936
|
+
* nonpayable
|
|
1937
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1938
|
+
*/
|
|
1939
|
+
withdrawLiquidity(amount: bigint, options?: {
|
|
1940
|
+
accessList?: import('viem').AccessList;
|
|
1941
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1942
|
+
chain?: import('viem').Chain | null;
|
|
1943
|
+
dataSuffix?: `0x${string}`;
|
|
1944
|
+
gas?: bigint;
|
|
1945
|
+
gasPrice?: bigint;
|
|
1946
|
+
maxFeePerGas?: bigint;
|
|
1947
|
+
maxPriorityFeePerGas?: bigint;
|
|
1948
|
+
nonce?: number;
|
|
1949
|
+
value?: bigint;
|
|
1950
|
+
}): Promise<`0x${string}`>;
|
|
1951
|
+
/**
|
|
1952
|
+
* Simulate contract write operations (dry-run without sending transaction)
|
|
1953
|
+
*
|
|
1954
|
+
* @example
|
|
1955
|
+
* const result = await contract.simulate.transfer('0x...', 1000n);
|
|
1956
|
+
* console.log('Gas estimate:', result.request.gas);
|
|
1957
|
+
* console.log('Would succeed:', result.result);
|
|
1958
|
+
*/
|
|
1959
|
+
get simulate(): {
|
|
1960
|
+
/**
|
|
1961
|
+
* Simulate acceptOwnership
|
|
1962
|
+
* Returns gas estimate and result without sending transaction
|
|
1963
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1964
|
+
*/
|
|
1965
|
+
acceptOwnership(options?: {
|
|
1966
|
+
accessList?: import("viem").AccessList;
|
|
1967
|
+
authorizationList?: import("viem").AuthorizationList;
|
|
1968
|
+
chain?: import("viem").Chain | null;
|
|
1969
|
+
dataSuffix?: `0x${string}`;
|
|
1970
|
+
gas?: bigint;
|
|
1971
|
+
gasPrice?: bigint;
|
|
1972
|
+
maxFeePerGas?: bigint;
|
|
1973
|
+
maxPriorityFeePerGas?: bigint;
|
|
1974
|
+
nonce?: number;
|
|
1975
|
+
value?: bigint;
|
|
1976
|
+
}): Promise<void>;
|
|
1977
|
+
/**
|
|
1978
|
+
* Simulate addRemotePool
|
|
1979
|
+
* Returns gas estimate and result without sending transaction
|
|
1980
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1981
|
+
*/
|
|
1982
|
+
addRemotePool(remoteChainSelector: bigint, remotePoolAddress: `0x${string}`, options?: {
|
|
1983
|
+
accessList?: import("viem").AccessList;
|
|
1984
|
+
authorizationList?: import("viem").AuthorizationList;
|
|
1985
|
+
chain?: import("viem").Chain | null;
|
|
1986
|
+
dataSuffix?: `0x${string}`;
|
|
1987
|
+
gas?: bigint;
|
|
1988
|
+
gasPrice?: bigint;
|
|
1989
|
+
maxFeePerGas?: bigint;
|
|
1990
|
+
maxPriorityFeePerGas?: bigint;
|
|
1991
|
+
nonce?: number;
|
|
1992
|
+
value?: bigint;
|
|
1993
|
+
}): Promise<void>;
|
|
1994
|
+
/**
|
|
1995
|
+
* Simulate applyAllowListUpdates
|
|
1996
|
+
* Returns gas estimate and result without sending transaction
|
|
1997
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1998
|
+
*/
|
|
1999
|
+
applyAllowListUpdates(removes: `0x${string}`[], adds: `0x${string}`[], options?: {
|
|
2000
|
+
accessList?: import("viem").AccessList;
|
|
2001
|
+
authorizationList?: import("viem").AuthorizationList;
|
|
2002
|
+
chain?: import("viem").Chain | null;
|
|
2003
|
+
dataSuffix?: `0x${string}`;
|
|
2004
|
+
gas?: bigint;
|
|
2005
|
+
gasPrice?: bigint;
|
|
2006
|
+
maxFeePerGas?: bigint;
|
|
2007
|
+
maxPriorityFeePerGas?: bigint;
|
|
2008
|
+
nonce?: number;
|
|
2009
|
+
value?: bigint;
|
|
2010
|
+
}): Promise<void>;
|
|
2011
|
+
/**
|
|
2012
|
+
* Simulate applyChainUpdates
|
|
2013
|
+
* Returns gas estimate and result without sending transaction
|
|
2014
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2015
|
+
*/
|
|
2016
|
+
applyChainUpdates(remoteChainSelectorsToRemove: bigint[], chainsToAdd: UpgradeableTokenPool_ChainUpdate[], options?: {
|
|
2017
|
+
accessList?: import("viem").AccessList;
|
|
2018
|
+
authorizationList?: import("viem").AuthorizationList;
|
|
2019
|
+
chain?: import("viem").Chain | null;
|
|
2020
|
+
dataSuffix?: `0x${string}`;
|
|
2021
|
+
gas?: bigint;
|
|
2022
|
+
gasPrice?: bigint;
|
|
2023
|
+
maxFeePerGas?: bigint;
|
|
2024
|
+
maxPriorityFeePerGas?: bigint;
|
|
2025
|
+
nonce?: number;
|
|
2026
|
+
value?: bigint;
|
|
2027
|
+
}): Promise<void>;
|
|
2028
|
+
/**
|
|
2029
|
+
* Simulate initialize
|
|
2030
|
+
* Returns gas estimate and result without sending transaction
|
|
2031
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2032
|
+
*/
|
|
2033
|
+
initialize(owner_: `0x${string}`, allowlist: `0x${string}`[], router: `0x${string}`, bridgeLimit: bigint, options?: {
|
|
2034
|
+
accessList?: import("viem").AccessList;
|
|
2035
|
+
authorizationList?: import("viem").AuthorizationList;
|
|
2036
|
+
chain?: import("viem").Chain | null;
|
|
2037
|
+
dataSuffix?: `0x${string}`;
|
|
2038
|
+
gas?: bigint;
|
|
2039
|
+
gasPrice?: bigint;
|
|
2040
|
+
maxFeePerGas?: bigint;
|
|
2041
|
+
maxPriorityFeePerGas?: bigint;
|
|
2042
|
+
nonce?: number;
|
|
2043
|
+
value?: bigint;
|
|
2044
|
+
}): Promise<void>;
|
|
2045
|
+
/**
|
|
2046
|
+
* Simulate lockOrBurn
|
|
2047
|
+
* Returns gas estimate and result without sending transaction
|
|
2048
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2049
|
+
*/
|
|
2050
|
+
lockOrBurn(lockOrBurnIn: Pool_LockOrBurnInV1, options?: {
|
|
2051
|
+
accessList?: import("viem").AccessList;
|
|
2052
|
+
authorizationList?: import("viem").AuthorizationList;
|
|
2053
|
+
chain?: import("viem").Chain | null;
|
|
2054
|
+
dataSuffix?: `0x${string}`;
|
|
2055
|
+
gas?: bigint;
|
|
2056
|
+
gasPrice?: bigint;
|
|
2057
|
+
maxFeePerGas?: bigint;
|
|
2058
|
+
maxPriorityFeePerGas?: bigint;
|
|
2059
|
+
nonce?: number;
|
|
2060
|
+
value?: bigint;
|
|
2061
|
+
}): Promise<Pool_LockOrBurnOutV1>;
|
|
2062
|
+
/**
|
|
2063
|
+
* Simulate provideLiquidity
|
|
2064
|
+
* Returns gas estimate and result without sending transaction
|
|
2065
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2066
|
+
*/
|
|
2067
|
+
provideLiquidity(amount: bigint, options?: {
|
|
2068
|
+
accessList?: import("viem").AccessList;
|
|
2069
|
+
authorizationList?: import("viem").AuthorizationList;
|
|
2070
|
+
chain?: import("viem").Chain | null;
|
|
2071
|
+
dataSuffix?: `0x${string}`;
|
|
2072
|
+
gas?: bigint;
|
|
2073
|
+
gasPrice?: bigint;
|
|
2074
|
+
maxFeePerGas?: bigint;
|
|
2075
|
+
maxPriorityFeePerGas?: bigint;
|
|
2076
|
+
nonce?: number;
|
|
2077
|
+
value?: bigint;
|
|
2078
|
+
}): Promise<void>;
|
|
2079
|
+
/**
|
|
2080
|
+
* Simulate releaseOrMint
|
|
2081
|
+
* Returns gas estimate and result without sending transaction
|
|
2082
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2083
|
+
*/
|
|
2084
|
+
releaseOrMint(releaseOrMintIn: Pool_ReleaseOrMintInV1, options?: {
|
|
2085
|
+
accessList?: import("viem").AccessList;
|
|
2086
|
+
authorizationList?: import("viem").AuthorizationList;
|
|
2087
|
+
chain?: import("viem").Chain | null;
|
|
2088
|
+
dataSuffix?: `0x${string}`;
|
|
2089
|
+
gas?: bigint;
|
|
2090
|
+
gasPrice?: bigint;
|
|
2091
|
+
maxFeePerGas?: bigint;
|
|
2092
|
+
maxPriorityFeePerGas?: bigint;
|
|
2093
|
+
nonce?: number;
|
|
2094
|
+
value?: bigint;
|
|
2095
|
+
}): Promise<Pool_ReleaseOrMintOutV1>;
|
|
2096
|
+
/**
|
|
2097
|
+
* Simulate removeRemotePool
|
|
2098
|
+
* Returns gas estimate and result without sending transaction
|
|
2099
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2100
|
+
*/
|
|
2101
|
+
removeRemotePool(remoteChainSelector: bigint, remotePoolAddress: `0x${string}`, options?: {
|
|
2102
|
+
accessList?: import("viem").AccessList;
|
|
2103
|
+
authorizationList?: import("viem").AuthorizationList;
|
|
2104
|
+
chain?: import("viem").Chain | null;
|
|
2105
|
+
dataSuffix?: `0x${string}`;
|
|
2106
|
+
gas?: bigint;
|
|
2107
|
+
gasPrice?: bigint;
|
|
2108
|
+
maxFeePerGas?: bigint;
|
|
2109
|
+
maxPriorityFeePerGas?: bigint;
|
|
2110
|
+
nonce?: number;
|
|
2111
|
+
value?: bigint;
|
|
2112
|
+
}): Promise<void>;
|
|
2113
|
+
/**
|
|
2114
|
+
* Simulate setBridgeLimit
|
|
2115
|
+
* Returns gas estimate and result without sending transaction
|
|
2116
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2117
|
+
*/
|
|
2118
|
+
setBridgeLimit(newBridgeLimit: bigint, options?: {
|
|
2119
|
+
accessList?: import("viem").AccessList;
|
|
2120
|
+
authorizationList?: import("viem").AuthorizationList;
|
|
2121
|
+
chain?: import("viem").Chain | null;
|
|
2122
|
+
dataSuffix?: `0x${string}`;
|
|
2123
|
+
gas?: bigint;
|
|
2124
|
+
gasPrice?: bigint;
|
|
2125
|
+
maxFeePerGas?: bigint;
|
|
2126
|
+
maxPriorityFeePerGas?: bigint;
|
|
2127
|
+
nonce?: number;
|
|
2128
|
+
value?: bigint;
|
|
2129
|
+
}): Promise<void>;
|
|
2130
|
+
/**
|
|
2131
|
+
* Simulate setBridgeLimitAdmin
|
|
2132
|
+
* Returns gas estimate and result without sending transaction
|
|
2133
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2134
|
+
*/
|
|
2135
|
+
setBridgeLimitAdmin(bridgeLimitAdmin: `0x${string}`, options?: {
|
|
2136
|
+
accessList?: import("viem").AccessList;
|
|
2137
|
+
authorizationList?: import("viem").AuthorizationList;
|
|
2138
|
+
chain?: import("viem").Chain | null;
|
|
2139
|
+
dataSuffix?: `0x${string}`;
|
|
2140
|
+
gas?: bigint;
|
|
2141
|
+
gasPrice?: bigint;
|
|
2142
|
+
maxFeePerGas?: bigint;
|
|
2143
|
+
maxPriorityFeePerGas?: bigint;
|
|
2144
|
+
nonce?: number;
|
|
2145
|
+
value?: bigint;
|
|
2146
|
+
}): Promise<void>;
|
|
2147
|
+
/**
|
|
2148
|
+
* Simulate setChainRateLimiterConfig
|
|
2149
|
+
* Returns gas estimate and result without sending transaction
|
|
2150
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2151
|
+
*/
|
|
2152
|
+
setChainRateLimiterConfig(remoteChainSelector: bigint, outboundConfig: RateLimiter_Config, inboundConfig: RateLimiter_Config, options?: {
|
|
2153
|
+
accessList?: import("viem").AccessList;
|
|
2154
|
+
authorizationList?: import("viem").AuthorizationList;
|
|
2155
|
+
chain?: import("viem").Chain | null;
|
|
2156
|
+
dataSuffix?: `0x${string}`;
|
|
2157
|
+
gas?: bigint;
|
|
2158
|
+
gasPrice?: bigint;
|
|
2159
|
+
maxFeePerGas?: bigint;
|
|
2160
|
+
maxPriorityFeePerGas?: bigint;
|
|
2161
|
+
nonce?: number;
|
|
2162
|
+
value?: bigint;
|
|
2163
|
+
}): Promise<void>;
|
|
2164
|
+
/**
|
|
2165
|
+
* Simulate setCurrentBridgedAmount
|
|
2166
|
+
* Returns gas estimate and result without sending transaction
|
|
2167
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2168
|
+
*/
|
|
2169
|
+
setCurrentBridgedAmount(newCurrentBridged: bigint, options?: {
|
|
2170
|
+
accessList?: import("viem").AccessList;
|
|
2171
|
+
authorizationList?: import("viem").AuthorizationList;
|
|
2172
|
+
chain?: import("viem").Chain | null;
|
|
2173
|
+
dataSuffix?: `0x${string}`;
|
|
2174
|
+
gas?: bigint;
|
|
2175
|
+
gasPrice?: bigint;
|
|
2176
|
+
maxFeePerGas?: bigint;
|
|
2177
|
+
maxPriorityFeePerGas?: bigint;
|
|
2178
|
+
nonce?: number;
|
|
2179
|
+
value?: bigint;
|
|
2180
|
+
}): Promise<void>;
|
|
2181
|
+
/**
|
|
2182
|
+
* Simulate setRateLimitAdmin
|
|
2183
|
+
* Returns gas estimate and result without sending transaction
|
|
2184
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2185
|
+
*/
|
|
2186
|
+
setRateLimitAdmin(rateLimitAdmin: `0x${string}`, options?: {
|
|
2187
|
+
accessList?: import("viem").AccessList;
|
|
2188
|
+
authorizationList?: import("viem").AuthorizationList;
|
|
2189
|
+
chain?: import("viem").Chain | null;
|
|
2190
|
+
dataSuffix?: `0x${string}`;
|
|
2191
|
+
gas?: bigint;
|
|
2192
|
+
gasPrice?: bigint;
|
|
2193
|
+
maxFeePerGas?: bigint;
|
|
2194
|
+
maxPriorityFeePerGas?: bigint;
|
|
2195
|
+
nonce?: number;
|
|
2196
|
+
value?: bigint;
|
|
2197
|
+
}): Promise<void>;
|
|
2198
|
+
/**
|
|
2199
|
+
* Simulate setRebalancer
|
|
2200
|
+
* Returns gas estimate and result without sending transaction
|
|
2201
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2202
|
+
*/
|
|
2203
|
+
setRebalancer(rebalancer: `0x${string}`, options?: {
|
|
2204
|
+
accessList?: import("viem").AccessList;
|
|
2205
|
+
authorizationList?: import("viem").AuthorizationList;
|
|
2206
|
+
chain?: import("viem").Chain | null;
|
|
2207
|
+
dataSuffix?: `0x${string}`;
|
|
2208
|
+
gas?: bigint;
|
|
2209
|
+
gasPrice?: bigint;
|
|
2210
|
+
maxFeePerGas?: bigint;
|
|
2211
|
+
maxPriorityFeePerGas?: bigint;
|
|
2212
|
+
nonce?: number;
|
|
2213
|
+
value?: bigint;
|
|
2214
|
+
}): Promise<void>;
|
|
2215
|
+
/**
|
|
2216
|
+
* Simulate setRouter
|
|
2217
|
+
* Returns gas estimate and result without sending transaction
|
|
2218
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2219
|
+
*/
|
|
2220
|
+
setRouter(newRouter: `0x${string}`, options?: {
|
|
2221
|
+
accessList?: import("viem").AccessList;
|
|
2222
|
+
authorizationList?: import("viem").AuthorizationList;
|
|
2223
|
+
chain?: import("viem").Chain | null;
|
|
2224
|
+
dataSuffix?: `0x${string}`;
|
|
2225
|
+
gas?: bigint;
|
|
2226
|
+
gasPrice?: bigint;
|
|
2227
|
+
maxFeePerGas?: bigint;
|
|
2228
|
+
maxPriorityFeePerGas?: bigint;
|
|
2229
|
+
nonce?: number;
|
|
2230
|
+
value?: bigint;
|
|
2231
|
+
}): Promise<void>;
|
|
2232
|
+
/**
|
|
2233
|
+
* Simulate transferLiquidity
|
|
2234
|
+
* Returns gas estimate and result without sending transaction
|
|
2235
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2236
|
+
*/
|
|
2237
|
+
transferLiquidity(from: `0x${string}`, amount: bigint, options?: {
|
|
2238
|
+
accessList?: import("viem").AccessList;
|
|
2239
|
+
authorizationList?: import("viem").AuthorizationList;
|
|
2240
|
+
chain?: import("viem").Chain | null;
|
|
2241
|
+
dataSuffix?: `0x${string}`;
|
|
2242
|
+
gas?: bigint;
|
|
2243
|
+
gasPrice?: bigint;
|
|
2244
|
+
maxFeePerGas?: bigint;
|
|
2245
|
+
maxPriorityFeePerGas?: bigint;
|
|
2246
|
+
nonce?: number;
|
|
2247
|
+
value?: bigint;
|
|
2248
|
+
}): Promise<void>;
|
|
2249
|
+
/**
|
|
2250
|
+
* Simulate transferOwnership
|
|
2251
|
+
* Returns gas estimate and result without sending transaction
|
|
2252
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2253
|
+
*/
|
|
2254
|
+
transferOwnership(to: `0x${string}`, options?: {
|
|
2255
|
+
accessList?: import("viem").AccessList;
|
|
2256
|
+
authorizationList?: import("viem").AuthorizationList;
|
|
2257
|
+
chain?: import("viem").Chain | null;
|
|
2258
|
+
dataSuffix?: `0x${string}`;
|
|
2259
|
+
gas?: bigint;
|
|
2260
|
+
gasPrice?: bigint;
|
|
2261
|
+
maxFeePerGas?: bigint;
|
|
2262
|
+
maxPriorityFeePerGas?: bigint;
|
|
2263
|
+
nonce?: number;
|
|
2264
|
+
value?: bigint;
|
|
2265
|
+
}): Promise<void>;
|
|
2266
|
+
/**
|
|
2267
|
+
* Simulate withdrawLiquidity
|
|
2268
|
+
* Returns gas estimate and result without sending transaction
|
|
2269
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2270
|
+
*/
|
|
2271
|
+
withdrawLiquidity(amount: bigint, options?: {
|
|
2272
|
+
accessList?: import("viem").AccessList;
|
|
2273
|
+
authorizationList?: import("viem").AuthorizationList;
|
|
2274
|
+
chain?: import("viem").Chain | null;
|
|
2275
|
+
dataSuffix?: `0x${string}`;
|
|
2276
|
+
gas?: bigint;
|
|
2277
|
+
gasPrice?: bigint;
|
|
2278
|
+
maxFeePerGas?: bigint;
|
|
2279
|
+
maxPriorityFeePerGas?: bigint;
|
|
2280
|
+
nonce?: number;
|
|
2281
|
+
value?: bigint;
|
|
2282
|
+
}): Promise<void>;
|
|
2283
|
+
};
|
|
2284
|
+
/**
|
|
2285
|
+
* Watch contract events
|
|
2286
|
+
*
|
|
2287
|
+
* @example
|
|
2288
|
+
* // Watch all Transfer events
|
|
2289
|
+
* const unwatch = contract.watch.Transfer((event) => {
|
|
2290
|
+
* console.log('Transfer:', event);
|
|
2291
|
+
* });
|
|
2292
|
+
*
|
|
2293
|
+
* // Stop watching
|
|
2294
|
+
* unwatch();
|
|
2295
|
+
*/
|
|
2296
|
+
get watch(): {
|
|
2297
|
+
/**
|
|
2298
|
+
* Watch AllowListAdd events
|
|
2299
|
+
* @param callback Function to call when event is emitted
|
|
2300
|
+
* @param filter Optional filter for indexed parameters
|
|
2301
|
+
* @returns Unwatch function to stop listening
|
|
2302
|
+
*/
|
|
2303
|
+
AllowListAdd: (callback: (event: {
|
|
2304
|
+
sender: `0x${string}`;
|
|
2305
|
+
}) => void) => () => void;
|
|
2306
|
+
/**
|
|
2307
|
+
* Watch AllowListRemove events
|
|
2308
|
+
* @param callback Function to call when event is emitted
|
|
2309
|
+
* @param filter Optional filter for indexed parameters
|
|
2310
|
+
* @returns Unwatch function to stop listening
|
|
2311
|
+
*/
|
|
2312
|
+
AllowListRemove: (callback: (event: {
|
|
2313
|
+
sender: `0x${string}`;
|
|
2314
|
+
}) => void) => () => void;
|
|
2315
|
+
/**
|
|
2316
|
+
* Watch BridgeLimitAdminUpdated events
|
|
2317
|
+
* @param callback Function to call when event is emitted
|
|
2318
|
+
* @param filter Optional filter for indexed parameters
|
|
2319
|
+
* @returns Unwatch function to stop listening
|
|
2320
|
+
*/
|
|
2321
|
+
BridgeLimitAdminUpdated: (callback: (event: {
|
|
2322
|
+
oldAdmin: `0x${string}`;
|
|
2323
|
+
newAdmin: `0x${string}`;
|
|
2324
|
+
}) => void, filter?: {
|
|
2325
|
+
oldAdmin?: `0x${string}` | `0x${string}`[] | null;
|
|
2326
|
+
newAdmin?: `0x${string}` | `0x${string}`[] | null;
|
|
2327
|
+
}) => () => void;
|
|
2328
|
+
/**
|
|
2329
|
+
* Watch BridgeLimitUpdated events
|
|
2330
|
+
* @param callback Function to call when event is emitted
|
|
2331
|
+
* @param filter Optional filter for indexed parameters
|
|
2332
|
+
* @returns Unwatch function to stop listening
|
|
2333
|
+
*/
|
|
2334
|
+
BridgeLimitUpdated: (callback: (event: {
|
|
2335
|
+
oldBridgeLimit: bigint;
|
|
2336
|
+
newBridgeLimit: bigint;
|
|
2337
|
+
}) => void) => () => void;
|
|
2338
|
+
/**
|
|
2339
|
+
* Watch Burned events
|
|
2340
|
+
* @param callback Function to call when event is emitted
|
|
2341
|
+
* @param filter Optional filter for indexed parameters
|
|
2342
|
+
* @returns Unwatch function to stop listening
|
|
2343
|
+
*/
|
|
2344
|
+
Burned: (callback: (event: {
|
|
2345
|
+
sender: `0x${string}`;
|
|
2346
|
+
amount: bigint;
|
|
2347
|
+
}) => void, filter?: {
|
|
2348
|
+
sender?: `0x${string}` | `0x${string}`[] | null;
|
|
2349
|
+
}) => () => void;
|
|
2350
|
+
/**
|
|
2351
|
+
* Watch ChainAdded events
|
|
2352
|
+
* @param callback Function to call when event is emitted
|
|
2353
|
+
* @param filter Optional filter for indexed parameters
|
|
2354
|
+
* @returns Unwatch function to stop listening
|
|
2355
|
+
*/
|
|
2356
|
+
ChainAdded: (callback: (event: {
|
|
2357
|
+
remoteChainSelector: bigint;
|
|
2358
|
+
remoteToken: `0x${string}`;
|
|
2359
|
+
outboundRateLimiterConfig: RateLimiter_Config;
|
|
2360
|
+
inboundRateLimiterConfig: RateLimiter_Config;
|
|
2361
|
+
}) => void) => () => void;
|
|
2362
|
+
/**
|
|
2363
|
+
* Watch ChainConfigured events
|
|
2364
|
+
* @param callback Function to call when event is emitted
|
|
2365
|
+
* @param filter Optional filter for indexed parameters
|
|
2366
|
+
* @returns Unwatch function to stop listening
|
|
2367
|
+
*/
|
|
2368
|
+
ChainConfigured: (callback: (event: {
|
|
2369
|
+
remoteChainSelector: bigint;
|
|
2370
|
+
outboundRateLimiterConfig: RateLimiter_Config;
|
|
2371
|
+
inboundRateLimiterConfig: RateLimiter_Config;
|
|
2372
|
+
}) => void) => () => void;
|
|
2373
|
+
/**
|
|
2374
|
+
* Watch ChainRemoved events
|
|
2375
|
+
* @param callback Function to call when event is emitted
|
|
2376
|
+
* @param filter Optional filter for indexed parameters
|
|
2377
|
+
* @returns Unwatch function to stop listening
|
|
2378
|
+
*/
|
|
2379
|
+
ChainRemoved: (callback: (event: {
|
|
2380
|
+
remoteChainSelector: bigint;
|
|
2381
|
+
}) => void) => () => void;
|
|
2382
|
+
/**
|
|
2383
|
+
* Watch ConfigChanged events
|
|
2384
|
+
* @param callback Function to call when event is emitted
|
|
2385
|
+
* @param filter Optional filter for indexed parameters
|
|
2386
|
+
* @returns Unwatch function to stop listening
|
|
2387
|
+
*/
|
|
2388
|
+
ConfigChanged: (callback: (event: {
|
|
2389
|
+
config: RateLimiter_Config;
|
|
2390
|
+
}) => void) => () => void;
|
|
2391
|
+
/**
|
|
2392
|
+
* Watch Initialized events
|
|
2393
|
+
* @param callback Function to call when event is emitted
|
|
2394
|
+
* @param filter Optional filter for indexed parameters
|
|
2395
|
+
* @returns Unwatch function to stop listening
|
|
2396
|
+
*/
|
|
2397
|
+
Initialized: (callback: (event: {
|
|
2398
|
+
version: bigint;
|
|
2399
|
+
}) => void) => () => void;
|
|
2400
|
+
/**
|
|
2401
|
+
* Watch LiquidityAdded events
|
|
2402
|
+
* @param callback Function to call when event is emitted
|
|
2403
|
+
* @param filter Optional filter for indexed parameters
|
|
2404
|
+
* @returns Unwatch function to stop listening
|
|
2405
|
+
*/
|
|
2406
|
+
LiquidityAdded: (callback: (event: {
|
|
2407
|
+
provider: `0x${string}`;
|
|
2408
|
+
amount: bigint;
|
|
2409
|
+
}) => void, filter?: {
|
|
2410
|
+
provider?: `0x${string}` | `0x${string}`[] | null;
|
|
2411
|
+
amount?: bigint | bigint[] | null;
|
|
2412
|
+
}) => () => void;
|
|
2413
|
+
/**
|
|
2414
|
+
* Watch LiquidityRemoved events
|
|
2415
|
+
* @param callback Function to call when event is emitted
|
|
2416
|
+
* @param filter Optional filter for indexed parameters
|
|
2417
|
+
* @returns Unwatch function to stop listening
|
|
2418
|
+
*/
|
|
2419
|
+
LiquidityRemoved: (callback: (event: {
|
|
2420
|
+
provider: `0x${string}`;
|
|
2421
|
+
amount: bigint;
|
|
2422
|
+
}) => void, filter?: {
|
|
2423
|
+
provider?: `0x${string}` | `0x${string}`[] | null;
|
|
2424
|
+
amount?: bigint | bigint[] | null;
|
|
2425
|
+
}) => () => void;
|
|
2426
|
+
/**
|
|
2427
|
+
* Watch LiquidityTransferred events
|
|
2428
|
+
* @param callback Function to call when event is emitted
|
|
2429
|
+
* @param filter Optional filter for indexed parameters
|
|
2430
|
+
* @returns Unwatch function to stop listening
|
|
2431
|
+
*/
|
|
2432
|
+
LiquidityTransferred: (callback: (event: {
|
|
2433
|
+
from: `0x${string}`;
|
|
2434
|
+
amount: bigint;
|
|
2435
|
+
}) => void, filter?: {
|
|
2436
|
+
from?: `0x${string}` | `0x${string}`[] | null;
|
|
2437
|
+
}) => () => void;
|
|
2438
|
+
/**
|
|
2439
|
+
* Watch Locked events
|
|
2440
|
+
* @param callback Function to call when event is emitted
|
|
2441
|
+
* @param filter Optional filter for indexed parameters
|
|
2442
|
+
* @returns Unwatch function to stop listening
|
|
2443
|
+
*/
|
|
2444
|
+
Locked: (callback: (event: {
|
|
2445
|
+
sender: `0x${string}`;
|
|
2446
|
+
amount: bigint;
|
|
2447
|
+
}) => void, filter?: {
|
|
2448
|
+
sender?: `0x${string}` | `0x${string}`[] | null;
|
|
2449
|
+
}) => () => void;
|
|
2450
|
+
/**
|
|
2451
|
+
* Watch Minted events
|
|
2452
|
+
* @param callback Function to call when event is emitted
|
|
2453
|
+
* @param filter Optional filter for indexed parameters
|
|
2454
|
+
* @returns Unwatch function to stop listening
|
|
2455
|
+
*/
|
|
2456
|
+
Minted: (callback: (event: {
|
|
2457
|
+
sender: `0x${string}`;
|
|
2458
|
+
recipient: `0x${string}`;
|
|
2459
|
+
amount: bigint;
|
|
2460
|
+
}) => void, filter?: {
|
|
2461
|
+
sender?: `0x${string}` | `0x${string}`[] | null;
|
|
2462
|
+
recipient?: `0x${string}` | `0x${string}`[] | null;
|
|
2463
|
+
}) => () => void;
|
|
2464
|
+
/**
|
|
2465
|
+
* Watch OwnershipTransferRequested events
|
|
2466
|
+
* @param callback Function to call when event is emitted
|
|
2467
|
+
* @param filter Optional filter for indexed parameters
|
|
2468
|
+
* @returns Unwatch function to stop listening
|
|
2469
|
+
*/
|
|
2470
|
+
OwnershipTransferRequested: (callback: (event: {
|
|
2471
|
+
from: `0x${string}`;
|
|
2472
|
+
to: `0x${string}`;
|
|
2473
|
+
}) => void, filter?: {
|
|
2474
|
+
from?: `0x${string}` | `0x${string}`[] | null;
|
|
2475
|
+
to?: `0x${string}` | `0x${string}`[] | null;
|
|
2476
|
+
}) => () => void;
|
|
2477
|
+
/**
|
|
2478
|
+
* Watch OwnershipTransferred events
|
|
2479
|
+
* @param callback Function to call when event is emitted
|
|
2480
|
+
* @param filter Optional filter for indexed parameters
|
|
2481
|
+
* @returns Unwatch function to stop listening
|
|
2482
|
+
*/
|
|
2483
|
+
OwnershipTransferred: (callback: (event: {
|
|
2484
|
+
from: `0x${string}`;
|
|
2485
|
+
to: `0x${string}`;
|
|
2486
|
+
}) => void, filter?: {
|
|
2487
|
+
from?: `0x${string}` | `0x${string}`[] | null;
|
|
2488
|
+
to?: `0x${string}` | `0x${string}`[] | null;
|
|
2489
|
+
}) => () => void;
|
|
2490
|
+
/**
|
|
2491
|
+
* Watch RateLimitAdminSet events
|
|
2492
|
+
* @param callback Function to call when event is emitted
|
|
2493
|
+
* @param filter Optional filter for indexed parameters
|
|
2494
|
+
* @returns Unwatch function to stop listening
|
|
2495
|
+
*/
|
|
2496
|
+
RateLimitAdminSet: (callback: (event: {
|
|
2497
|
+
rateLimitAdmin: `0x${string}`;
|
|
2498
|
+
}) => void) => () => void;
|
|
2499
|
+
/**
|
|
2500
|
+
* Watch Released events
|
|
2501
|
+
* @param callback Function to call when event is emitted
|
|
2502
|
+
* @param filter Optional filter for indexed parameters
|
|
2503
|
+
* @returns Unwatch function to stop listening
|
|
2504
|
+
*/
|
|
2505
|
+
Released: (callback: (event: {
|
|
2506
|
+
sender: `0x${string}`;
|
|
2507
|
+
recipient: `0x${string}`;
|
|
2508
|
+
amount: bigint;
|
|
2509
|
+
}) => void, filter?: {
|
|
2510
|
+
sender?: `0x${string}` | `0x${string}`[] | null;
|
|
2511
|
+
recipient?: `0x${string}` | `0x${string}`[] | null;
|
|
2512
|
+
}) => () => void;
|
|
2513
|
+
/**
|
|
2514
|
+
* Watch RemotePoolAdded events
|
|
2515
|
+
* @param callback Function to call when event is emitted
|
|
2516
|
+
* @param filter Optional filter for indexed parameters
|
|
2517
|
+
* @returns Unwatch function to stop listening
|
|
2518
|
+
*/
|
|
2519
|
+
RemotePoolAdded: (callback: (event: {
|
|
2520
|
+
remoteChainSelector: bigint;
|
|
2521
|
+
remotePoolAddress: `0x${string}`;
|
|
2522
|
+
}) => void, filter?: {
|
|
2523
|
+
remoteChainSelector?: bigint | bigint[] | null;
|
|
2524
|
+
}) => () => void;
|
|
2525
|
+
/**
|
|
2526
|
+
* Watch RemotePoolRemoved events
|
|
2527
|
+
* @param callback Function to call when event is emitted
|
|
2528
|
+
* @param filter Optional filter for indexed parameters
|
|
2529
|
+
* @returns Unwatch function to stop listening
|
|
2530
|
+
*/
|
|
2531
|
+
RemotePoolRemoved: (callback: (event: {
|
|
2532
|
+
remoteChainSelector: bigint;
|
|
2533
|
+
remotePoolAddress: `0x${string}`;
|
|
2534
|
+
}) => void, filter?: {
|
|
2535
|
+
remoteChainSelector?: bigint | bigint[] | null;
|
|
2536
|
+
}) => () => void;
|
|
2537
|
+
/**
|
|
2538
|
+
* Watch RouterUpdated events
|
|
2539
|
+
* @param callback Function to call when event is emitted
|
|
2540
|
+
* @param filter Optional filter for indexed parameters
|
|
2541
|
+
* @returns Unwatch function to stop listening
|
|
2542
|
+
*/
|
|
2543
|
+
RouterUpdated: (callback: (event: {
|
|
2544
|
+
oldRouter: `0x${string}`;
|
|
2545
|
+
newRouter: `0x${string}`;
|
|
2546
|
+
}) => void) => () => void;
|
|
2547
|
+
/**
|
|
2548
|
+
* Watch TokensConsumed events
|
|
2549
|
+
* @param callback Function to call when event is emitted
|
|
2550
|
+
* @param filter Optional filter for indexed parameters
|
|
2551
|
+
* @returns Unwatch function to stop listening
|
|
2552
|
+
*/
|
|
2553
|
+
TokensConsumed: (callback: (event: {
|
|
2554
|
+
tokens: bigint;
|
|
2555
|
+
}) => void) => () => void;
|
|
2556
|
+
};
|
|
2557
|
+
}
|