@velora-dex/widget 0.8.5-dev.0 → 0.8.5-dev.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (29) hide show
  1. package/dist/core/limit/state/currentLimitInputAtom.d.ts +2 -2
  2. package/dist/core/limit/state/utils.d.ts +1 -1
  3. package/dist/core/otc/state/currentOtcInputAtom.d.ts +2 -2
  4. package/dist/core/state/configAtom.js +2 -2
  5. package/dist/core/state/configAtom.js.map +1 -1
  6. package/dist/core/state/currentSwapInputAtom.d.ts +2 -2
  7. package/dist/core/twap/state/currentTwapInputAtom.d.ts +2 -2
  8. package/dist/hooks/permit/hooks/permit2/usePermit2Allowance.d.ts +1 -1
  9. package/dist/hooks/permit/hooks/permit2/usePermit2Allowance.d.ts.map +1 -1
  10. package/dist/hooks/permit/hooks/permit2/useTokenFromPermit2Allowance.d.ts +1 -1
  11. package/dist/hooks/permit/hooks/permit2/useTokenFromPermit2Allowance.d.ts.map +1 -1
  12. package/dist/hooks/swap/prices/delta/orders/types.d.ts +1 -1
  13. package/dist/hooks/swap/prices/delta/orders/types.d.ts.map +1 -1
  14. package/dist/hooks/swap/prices/delta/orders/utils.d.ts +1 -8
  15. package/dist/hooks/swap/prices/delta/orders/utils.d.ts.map +1 -1
  16. package/dist/hooks/swap/prices/delta/orders/utils.js.map +1 -1
  17. package/dist/hooks/tokens/allowance/useTokenAllowance.d.ts +1 -1
  18. package/dist/hooks/tokens/allowance/useTokenAllowance.d.ts.map +1 -1
  19. package/dist/hooks/tokens/balances/useTokenBalance.d.ts +1 -1
  20. package/dist/hooks/tokens/balances/useTokenBalance.d.ts.map +1 -1
  21. package/dist/hooks/txs/queries/useTxResponse.d.ts +339 -261
  22. package/dist/hooks/txs/queries/useTxResponse.d.ts.map +1 -1
  23. package/dist/lib/web3/wagmi/config.d.ts +99 -21
  24. package/dist/lib/web3/wagmi/config.d.ts.map +1 -1
  25. package/dist/lib/web3/wagmi/constants.d.ts +99 -21
  26. package/dist/lib/web3/wagmi/constants.d.ts.map +1 -1
  27. package/dist/lib/web3/wagmi/switchChain.d.ts +99 -21
  28. package/dist/lib/web3/wagmi/switchChain.d.ts.map +1 -1
  29. package/package.json +2 -2
package/dist/hooks/txs/queries/useTxResponse.d.ts CHANGED
@@ -16,14 +16,11 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
16
16
  readonly apiUrl: "https://api.etherscan.io/api";
17
17
  };
18
18
  };
19
- blockTime?: number | undefined | undefined;
19
+ blockTime: 12000;
20
20
  contracts: {
21
- readonly ensRegistry: {
22
- readonly address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e";
23
- };
24
21
  readonly ensUniversalResolver: {
25
- readonly address: "0xce01f8eee7E479C928F8919abD53E553a36CeF67";
26
- readonly blockCreated: 19258213;
22
+ readonly address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
23
+ readonly blockCreated: 23085558;
27
24
  };
28
25
  readonly multicall3: {
29
26
  readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
@@ -47,18 +44,27 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
47
44
  sourceId?: number | undefined | undefined;
48
45
  testnet?: boolean | undefined | undefined;
49
46
  custom?: Record<string, unknown> | undefined;
47
+ extendSchema?: Record<string, unknown> | undefined;
50
48
  fees?: import('viem').ChainFees<undefined> | undefined;
51
49
  formatters?: undefined;
50
+ prepareTransactionRequest?: ((args: import('viem').PrepareTransactionRequestParameters, options: {
51
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
52
+ }) => Promise<import('viem').PrepareTransactionRequestParameters>) | [fn: ((args: import('viem').PrepareTransactionRequestParameters, options: {
53
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
54
+ }) => Promise<import('viem').PrepareTransactionRequestParameters>) | undefined, options: {
55
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
56
+ }] | undefined;
52
57
  serializers?: import('viem').ChainSerializers<undefined, import('viem').TransactionSerializable> | undefined;
58
+ verifyHash?: ((client: import('viem').Client, parameters: import('viem').VerifyHashActionParameters) => Promise<import('viem').VerifyHashActionReturnType>) | undefined;
53
59
  }, {
54
60
  blockExplorers: {
55
61
  readonly default: {
56
62
  readonly name: "PolygonScan";
57
63
  readonly url: "https://polygonscan.com";
58
- readonly apiUrl: "https://api.polygonscan.com/api";
64
+ readonly apiUrl: "https://api.etherscan.io/v2/api";
59
65
  };
60
66
  };
61
- blockTime?: number | undefined | undefined;
67
+ blockTime: 2000;
62
68
  contracts: {
63
69
  readonly multicall3: {
64
70
  readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
@@ -82,9 +88,18 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
82
88
  sourceId?: number | undefined | undefined;
83
89
  testnet?: boolean | undefined | undefined;
84
90
  custom?: Record<string, unknown> | undefined;
91
+ extendSchema?: Record<string, unknown> | undefined;
85
92
  fees?: import('viem').ChainFees<undefined> | undefined;
86
93
  formatters?: undefined;
94
+ prepareTransactionRequest?: ((args: import('viem').PrepareTransactionRequestParameters, options: {
95
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
96
+ }) => Promise<import('viem').PrepareTransactionRequestParameters>) | [fn: ((args: import('viem').PrepareTransactionRequestParameters, options: {
97
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
98
+ }) => Promise<import('viem').PrepareTransactionRequestParameters>) | undefined, options: {
99
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
100
+ }] | undefined;
87
101
  serializers?: import('viem').ChainSerializers<undefined, import('viem').TransactionSerializable> | undefined;
102
+ verifyHash?: ((client: import('viem').Client, parameters: import('viem').VerifyHashActionParameters) => Promise<import('viem').VerifyHashActionReturnType>) | undefined;
88
103
  }, {
89
104
  blockExplorers: {
90
105
  readonly default: {
@@ -93,7 +108,7 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
93
108
  readonly apiUrl: "https://api.bscscan.com/api";
94
109
  };
95
110
  };
96
- blockTime?: number | undefined | undefined;
111
+ blockTime: 750;
97
112
  contracts: {
98
113
  readonly multicall3: {
99
114
  readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
@@ -117,9 +132,18 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
117
132
  sourceId?: number | undefined | undefined;
118
133
  testnet?: boolean | undefined | undefined;
119
134
  custom?: Record<string, unknown> | undefined;
135
+ extendSchema?: Record<string, unknown> | undefined;
120
136
  fees?: import('viem').ChainFees<undefined> | undefined;
121
137
  formatters?: undefined;
138
+ prepareTransactionRequest?: ((args: import('viem').PrepareTransactionRequestParameters, options: {
139
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
140
+ }) => Promise<import('viem').PrepareTransactionRequestParameters>) | [fn: ((args: import('viem').PrepareTransactionRequestParameters, options: {
141
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
142
+ }) => Promise<import('viem').PrepareTransactionRequestParameters>) | undefined, options: {
143
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
144
+ }] | undefined;
122
145
  serializers?: import('viem').ChainSerializers<undefined, import('viem').TransactionSerializable> | undefined;
146
+ verifyHash?: ((client: import('viem').Client, parameters: import('viem').VerifyHashActionParameters) => Promise<import('viem').VerifyHashActionReturnType>) | undefined;
123
147
  }, {
124
148
  blockExplorers: {
125
149
  readonly default: {
@@ -128,7 +152,7 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
128
152
  readonly apiUrl: "https://api.snowtrace.io";
129
153
  };
130
154
  };
131
- blockTime?: number | undefined | undefined;
155
+ blockTime: 1700;
132
156
  contracts: {
133
157
  readonly multicall3: {
134
158
  readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
@@ -152,9 +176,18 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
152
176
  sourceId?: number | undefined | undefined;
153
177
  testnet?: boolean | undefined | undefined;
154
178
  custom?: Record<string, unknown> | undefined;
179
+ extendSchema?: Record<string, unknown> | undefined;
155
180
  fees?: import('viem').ChainFees<undefined> | undefined;
156
181
  formatters?: undefined;
182
+ prepareTransactionRequest?: ((args: import('viem').PrepareTransactionRequestParameters, options: {
183
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
184
+ }) => Promise<import('viem').PrepareTransactionRequestParameters>) | [fn: ((args: import('viem').PrepareTransactionRequestParameters, options: {
185
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
186
+ }) => Promise<import('viem').PrepareTransactionRequestParameters>) | undefined, options: {
187
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
188
+ }] | undefined;
157
189
  serializers?: import('viem').ChainSerializers<undefined, import('viem').TransactionSerializable> | undefined;
190
+ verifyHash?: ((client: import('viem').Client, parameters: import('viem').VerifyHashActionParameters) => Promise<import('viem').VerifyHashActionReturnType>) | undefined;
158
191
  }, {
159
192
  blockExplorers: {
160
193
  readonly default: {
@@ -187,9 +220,18 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
187
220
  sourceId?: number | undefined | undefined;
188
221
  testnet?: boolean | undefined | undefined;
189
222
  custom?: Record<string, unknown> | undefined;
223
+ extendSchema?: Record<string, unknown> | undefined;
190
224
  fees?: import('viem').ChainFees<undefined> | undefined;
191
225
  formatters?: undefined;
226
+ prepareTransactionRequest?: ((args: import('viem').PrepareTransactionRequestParameters, options: {
227
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
228
+ }) => Promise<import('viem').PrepareTransactionRequestParameters>) | [fn: ((args: import('viem').PrepareTransactionRequestParameters, options: {
229
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
230
+ }) => Promise<import('viem').PrepareTransactionRequestParameters>) | undefined, options: {
231
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
232
+ }] | undefined;
192
233
  serializers?: import('viem').ChainSerializers<undefined, import('viem').TransactionSerializable> | undefined;
234
+ verifyHash?: ((client: import('viem').Client, parameters: import('viem').VerifyHashActionParameters) => Promise<import('viem').VerifyHashActionReturnType>) | undefined;
193
235
  }, {
194
236
  blockExplorers: {
195
237
  readonly default: {
@@ -260,11 +302,12 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
260
302
  sourceId: 1;
261
303
  testnet?: boolean | undefined | undefined;
262
304
  custom?: Record<string, unknown> | undefined;
305
+ extendSchema?: Record<string, unknown> | undefined;
263
306
  fees?: import('viem').ChainFees<undefined> | undefined;
264
307
  formatters: {
265
308
  readonly block: {
266
309
  exclude: [] | undefined;
267
- format: (args: import('viem/chains').OpStackRpcBlock) => {
310
+ format: (args: import('viem/chains').OpStackRpcBlock, action?: string | undefined) => {
268
311
  baseFeePerGas: bigint | null;
269
312
  blobGasUsed: bigint;
270
313
  difficulty: bigint;
@@ -297,7 +340,7 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
297
340
  };
298
341
  readonly transaction: {
299
342
  exclude: [] | undefined;
300
- format: (args: import('viem/chains').OpStackRpcTransaction) => ({
343
+ format: (args: import('viem/chains').OpStackRpcTransaction, action?: string | undefined) => ({
301
344
  blockHash: `0x${string}` | null;
302
345
  blockNumber: bigint | null;
303
346
  from: import('viem').Address;
@@ -466,7 +509,7 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
466
509
  };
467
510
  readonly transactionReceipt: {
468
511
  exclude: [] | undefined;
469
- format: (args: import('viem/chains').OpStackRpcTransactionReceipt) => {
512
+ format: (args: import('viem/chains').OpStackRpcTransactionReceipt, action?: string | undefined) => {
470
513
  blobGasPrice?: bigint | undefined;
471
514
  blobGasUsed?: bigint | undefined;
472
515
  blockHash: import('viem').Hash;
@@ -492,9 +535,17 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
492
535
  type: "transactionReceipt";
493
536
  };
494
537
  };
538
+ prepareTransactionRequest?: ((args: import('viem').PrepareTransactionRequestParameters, options: {
539
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
540
+ }) => Promise<import('viem').PrepareTransactionRequestParameters>) | [fn: ((args: import('viem').PrepareTransactionRequestParameters, options: {
541
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
542
+ }) => Promise<import('viem').PrepareTransactionRequestParameters>) | undefined, options: {
543
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
544
+ }] | undefined;
495
545
  serializers: {
496
546
  readonly transaction: typeof import('viem/chains').serializeTransactionOpStack;
497
547
  };
548
+ verifyHash?: ((client: import('viem').Client, parameters: import('viem').VerifyHashActionParameters) => Promise<import('viem').VerifyHashActionReturnType>) | undefined;
498
549
  }, {
499
550
  blockExplorers: {
500
551
  readonly default: {
@@ -567,11 +618,12 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
567
618
  sourceId: 1;
568
619
  testnet?: boolean | undefined | undefined;
569
620
  custom?: Record<string, unknown> | undefined;
621
+ extendSchema?: Record<string, unknown> | undefined;
570
622
  fees?: import('viem').ChainFees<undefined> | undefined;
571
623
  formatters: {
572
624
  readonly block: {
573
625
  exclude: [] | undefined;
574
- format: (args: import('viem/chains').OpStackRpcBlock) => {
626
+ format: (args: import('viem/chains').OpStackRpcBlock, action?: string | undefined) => {
575
627
  baseFeePerGas: bigint | null;
576
628
  blobGasUsed: bigint;
577
629
  difficulty: bigint;
@@ -604,7 +656,7 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
604
656
  };
605
657
  readonly transaction: {
606
658
  exclude: [] | undefined;
607
- format: (args: import('viem/chains').OpStackRpcTransaction) => ({
659
+ format: (args: import('viem/chains').OpStackRpcTransaction, action?: string | undefined) => ({
608
660
  blockHash: `0x${string}` | null;
609
661
  blockNumber: bigint | null;
610
662
  from: import('viem').Address;
@@ -773,7 +825,7 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
773
825
  };
774
826
  readonly transactionReceipt: {
775
827
  exclude: [] | undefined;
776
- format: (args: import('viem/chains').OpStackRpcTransactionReceipt) => {
828
+ format: (args: import('viem/chains').OpStackRpcTransactionReceipt, action?: string | undefined) => {
777
829
  blobGasPrice?: bigint | undefined;
778
830
  blobGasUsed?: bigint | undefined;
779
831
  blockHash: import('viem').Hash;
@@ -799,9 +851,17 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
799
851
  type: "transactionReceipt";
800
852
  };
801
853
  };
854
+ prepareTransactionRequest?: ((args: import('viem').PrepareTransactionRequestParameters, options: {
855
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
856
+ }) => Promise<import('viem').PrepareTransactionRequestParameters>) | [fn: ((args: import('viem').PrepareTransactionRequestParameters, options: {
857
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
858
+ }) => Promise<import('viem').PrepareTransactionRequestParameters>) | undefined, options: {
859
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
860
+ }] | undefined;
802
861
  serializers: {
803
862
  readonly transaction: typeof import('viem/chains').serializeTransactionOpStack;
804
863
  };
864
+ verifyHash?: ((client: import('viem').Client, parameters: import('viem').VerifyHashActionParameters) => Promise<import('viem').VerifyHashActionReturnType>) | undefined;
805
865
  }, {
806
866
  blockExplorers: {
807
867
  readonly default: {
@@ -810,7 +870,7 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
810
870
  readonly apiUrl: "https://api.gnosisscan.io/api";
811
871
  };
812
872
  };
813
- blockTime?: number | undefined | undefined;
873
+ blockTime: 5000;
814
874
  contracts: {
815
875
  readonly multicall3: {
816
876
  readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
@@ -835,9 +895,18 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
835
895
  sourceId?: number | undefined | undefined;
836
896
  testnet?: boolean | undefined | undefined;
837
897
  custom?: Record<string, unknown> | undefined;
898
+ extendSchema?: Record<string, unknown> | undefined;
838
899
  fees?: import('viem').ChainFees<undefined> | undefined;
839
900
  formatters?: undefined;
901
+ prepareTransactionRequest?: ((args: import('viem').PrepareTransactionRequestParameters, options: {
902
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
903
+ }) => Promise<import('viem').PrepareTransactionRequestParameters>) | [fn: ((args: import('viem').PrepareTransactionRequestParameters, options: {
904
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
905
+ }) => Promise<import('viem').PrepareTransactionRequestParameters>) | undefined, options: {
906
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
907
+ }] | undefined;
840
908
  serializers?: import('viem').ChainSerializers<undefined, import('viem').TransactionSerializable> | undefined;
909
+ verifyHash?: ((client: import('viem').Client, parameters: import('viem').VerifyHashActionParameters) => Promise<import('viem').VerifyHashActionReturnType>) | undefined;
841
910
  }, {
842
911
  blockExplorers: {
843
912
  readonly default: {
@@ -846,7 +915,7 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
846
915
  readonly apiUrl: "https://api.uniscan.xyz/api";
847
916
  };
848
917
  };
849
- blockTime: 2000;
918
+ blockTime: 1000;
850
919
  contracts: {
851
920
  readonly multicall3: {
852
921
  readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
@@ -903,11 +972,12 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
903
972
  sourceId: 1;
904
973
  testnet?: boolean | undefined | undefined;
905
974
  custom?: Record<string, unknown> | undefined;
975
+ extendSchema?: Record<string, unknown> | undefined;
906
976
  fees?: import('viem').ChainFees<undefined> | undefined;
907
977
  formatters: {
908
978
  readonly block: {
909
979
  exclude: [] | undefined;
910
- format: (args: import('viem/chains').OpStackRpcBlock) => {
980
+ format: (args: import('viem/chains').OpStackRpcBlock, action?: string | undefined) => {
911
981
  baseFeePerGas: bigint | null;
912
982
  blobGasUsed: bigint;
913
983
  difficulty: bigint;
@@ -940,7 +1010,7 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
940
1010
  };
941
1011
  readonly transaction: {
942
1012
  exclude: [] | undefined;
943
- format: (args: import('viem/chains').OpStackRpcTransaction) => ({
1013
+ format: (args: import('viem/chains').OpStackRpcTransaction, action?: string | undefined) => ({
944
1014
  blockHash: `0x${string}` | null;
945
1015
  blockNumber: bigint | null;
946
1016
  from: import('viem').Address;
@@ -1109,7 +1179,7 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
1109
1179
  };
1110
1180
  readonly transactionReceipt: {
1111
1181
  exclude: [] | undefined;
1112
- format: (args: import('viem/chains').OpStackRpcTransactionReceipt) => {
1182
+ format: (args: import('viem/chains').OpStackRpcTransactionReceipt, action?: string | undefined) => {
1113
1183
  blobGasPrice?: bigint | undefined;
1114
1184
  blobGasUsed?: bigint | undefined;
1115
1185
  blockHash: import('viem').Hash;
@@ -1135,21 +1205,25 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
1135
1205
  type: "transactionReceipt";
1136
1206
  };
1137
1207
  };
1208
+ prepareTransactionRequest?: ((args: import('viem').PrepareTransactionRequestParameters, options: {
1209
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
1210
+ }) => Promise<import('viem').PrepareTransactionRequestParameters>) | [fn: ((args: import('viem').PrepareTransactionRequestParameters, options: {
1211
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
1212
+ }) => Promise<import('viem').PrepareTransactionRequestParameters>) | undefined, options: {
1213
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
1214
+ }] | undefined;
1138
1215
  serializers: {
1139
1216
  readonly transaction: typeof import('viem/chains').serializeTransactionOpStack;
1140
1217
  };
1218
+ verifyHash?: ((client: import('viem').Client, parameters: import('viem').VerifyHashActionParameters) => Promise<import('viem').VerifyHashActionReturnType>) | undefined;
1141
1219
  }], Record<1 | 10 | 137 | 56 | 43114 | 42161 | 8453 | 100 | 130, import('viem').FallbackTransport<import('viem').Transport[]>>, import('wagmi').CreateConnectorFn[]>, 1 | 10 | 137 | 56 | 43114 | 42161 | 8453 | 100 | 130, {
1142
1220
  type: "legacy";
1143
1221
  chainId: 1;
1222
+ to: import('viem').Address | null;
1144
1223
  from: import('viem').Address;
1145
1224
  gas: bigint;
1146
1225
  nonce: number;
1147
- to: import('viem').Address | null;
1148
1226
  value: bigint;
1149
- r: import('viem').Hex;
1150
- s: import('viem').Hex;
1151
- v: bigint;
1152
- yParity?: undefined | undefined;
1153
1227
  blobVersionedHashes?: undefined | undefined;
1154
1228
  gasPrice: bigint;
1155
1229
  maxFeePerBlobGas?: undefined | undefined;
@@ -1157,24 +1231,24 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
1157
1231
  maxPriorityFeePerGas?: undefined | undefined;
1158
1232
  accessList?: undefined | undefined;
1159
1233
  authorizationList?: undefined | undefined;
1234
+ yParity?: undefined | undefined;
1160
1235
  hash: Hash;
1161
1236
  input: import('viem').Hex;
1237
+ r: import('viem').Hex;
1238
+ s: import('viem').Hex;
1162
1239
  typeHex: import('viem').Hex | null;
1240
+ v: bigint;
1163
1241
  blockHash: `0x${string}`;
1164
1242
  blockNumber: bigint;
1165
1243
  transactionIndex: number;
1166
1244
  } | {
1167
1245
  type: "eip2930";
1168
1246
  chainId: 1;
1247
+ to: import('viem').Address | null;
1169
1248
  from: import('viem').Address;
1170
1249
  gas: bigint;
1171
1250
  nonce: number;
1172
- to: import('viem').Address | null;
1173
1251
  value: bigint;
1174
- r: import('viem').Hex;
1175
- s: import('viem').Hex;
1176
- v: bigint;
1177
- yParity: number;
1178
1252
  blobVersionedHashes?: undefined | undefined;
1179
1253
  gasPrice: bigint;
1180
1254
  maxFeePerBlobGas?: undefined | undefined;
@@ -1182,24 +1256,24 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
1182
1256
  maxPriorityFeePerGas?: undefined | undefined;
1183
1257
  accessList: import('viem').AccessList;
1184
1258
  authorizationList?: undefined | undefined;
1259
+ yParity: number;
1185
1260
  hash: Hash;
1186
1261
  input: import('viem').Hex;
1262
+ r: import('viem').Hex;
1263
+ s: import('viem').Hex;
1187
1264
  typeHex: import('viem').Hex | null;
1265
+ v: bigint;
1188
1266
  blockHash: `0x${string}`;
1189
1267
  blockNumber: bigint;
1190
1268
  transactionIndex: number;
1191
1269
  } | {
1192
1270
  type: "eip1559";
1193
1271
  chainId: 1;
1272
+ to: import('viem').Address | null;
1194
1273
  from: import('viem').Address;
1195
1274
  gas: bigint;
1196
1275
  nonce: number;
1197
- to: import('viem').Address | null;
1198
1276
  value: bigint;
1199
- r: import('viem').Hex;
1200
- s: import('viem').Hex;
1201
- v: bigint;
1202
- yParity: number;
1203
1277
  blobVersionedHashes?: undefined | undefined;
1204
1278
  gasPrice?: undefined | undefined;
1205
1279
  maxFeePerBlobGas?: undefined | undefined;
@@ -1207,24 +1281,24 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
1207
1281
  maxPriorityFeePerGas: bigint;
1208
1282
  accessList: import('viem').AccessList;
1209
1283
  authorizationList?: undefined | undefined;
1284
+ yParity: number;
1210
1285
  hash: Hash;
1211
1286
  input: import('viem').Hex;
1287
+ r: import('viem').Hex;
1288
+ s: import('viem').Hex;
1212
1289
  typeHex: import('viem').Hex | null;
1290
+ v: bigint;
1213
1291
  blockHash: `0x${string}`;
1214
1292
  blockNumber: bigint;
1215
1293
  transactionIndex: number;
1216
1294
  } | {
1217
1295
  type: "eip4844";
1218
1296
  chainId: 1;
1297
+ to: import('viem').Address | null;
1219
1298
  from: import('viem').Address;
1220
1299
  gas: bigint;
1221
1300
  nonce: number;
1222
- to: import('viem').Address | null;
1223
1301
  value: bigint;
1224
- r: import('viem').Hex;
1225
- s: import('viem').Hex;
1226
- v: bigint;
1227
- yParity: number;
1228
1302
  blobVersionedHashes: readonly import('viem').Hex[];
1229
1303
  gasPrice?: undefined | undefined;
1230
1304
  maxFeePerBlobGas: bigint;
@@ -1232,24 +1306,24 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
1232
1306
  maxPriorityFeePerGas: bigint;
1233
1307
  accessList: import('viem').AccessList;
1234
1308
  authorizationList?: undefined | undefined;
1309
+ yParity: number;
1235
1310
  hash: Hash;
1236
1311
  input: import('viem').Hex;
1312
+ r: import('viem').Hex;
1313
+ s: import('viem').Hex;
1237
1314
  typeHex: import('viem').Hex | null;
1315
+ v: bigint;
1238
1316
  blockHash: `0x${string}`;
1239
1317
  blockNumber: bigint;
1240
1318
  transactionIndex: number;
1241
1319
  } | {
1242
1320
  type: "eip7702";
1243
1321
  chainId: 1;
1322
+ to: import('viem').Address | null;
1244
1323
  from: import('viem').Address;
1245
1324
  gas: bigint;
1246
1325
  nonce: number;
1247
- to: import('viem').Address | null;
1248
1326
  value: bigint;
1249
- r: import('viem').Hex;
1250
- s: import('viem').Hex;
1251
- v: bigint;
1252
- yParity: number;
1253
1327
  blobVersionedHashes?: undefined | undefined;
1254
1328
  gasPrice?: undefined | undefined;
1255
1329
  maxFeePerBlobGas?: undefined | undefined;
@@ -1257,24 +1331,24 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
1257
1331
  maxPriorityFeePerGas: bigint;
1258
1332
  accessList: import('viem').AccessList;
1259
1333
  authorizationList: import('viem').SignedAuthorizationList;
1334
+ yParity: number;
1260
1335
  hash: Hash;
1261
1336
  input: import('viem').Hex;
1337
+ r: import('viem').Hex;
1338
+ s: import('viem').Hex;
1262
1339
  typeHex: import('viem').Hex | null;
1340
+ v: bigint;
1263
1341
  blockHash: `0x${string}`;
1264
1342
  blockNumber: bigint;
1265
1343
  transactionIndex: number;
1266
1344
  } | {
1267
1345
  type: "legacy";
1268
1346
  chainId: 137;
1347
+ to: import('viem').Address | null;
1269
1348
  from: import('viem').Address;
1270
1349
  gas: bigint;
1271
1350
  nonce: number;
1272
- to: import('viem').Address | null;
1273
1351
  value: bigint;
1274
- r: import('viem').Hex;
1275
- s: import('viem').Hex;
1276
- v: bigint;
1277
- yParity?: undefined | undefined;
1278
1352
  blobVersionedHashes?: undefined | undefined;
1279
1353
  gasPrice: bigint;
1280
1354
  maxFeePerBlobGas?: undefined | undefined;
@@ -1282,24 +1356,24 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
1282
1356
  maxPriorityFeePerGas?: undefined | undefined;
1283
1357
  accessList?: undefined | undefined;
1284
1358
  authorizationList?: undefined | undefined;
1359
+ yParity?: undefined | undefined;
1285
1360
  hash: Hash;
1286
1361
  input: import('viem').Hex;
1362
+ r: import('viem').Hex;
1363
+ s: import('viem').Hex;
1287
1364
  typeHex: import('viem').Hex | null;
1365
+ v: bigint;
1288
1366
  blockHash: `0x${string}`;
1289
1367
  blockNumber: bigint;
1290
1368
  transactionIndex: number;
1291
1369
  } | {
1292
1370
  type: "eip2930";
1293
1371
  chainId: 137;
1372
+ to: import('viem').Address | null;
1294
1373
  from: import('viem').Address;
1295
1374
  gas: bigint;
1296
1375
  nonce: number;
1297
- to: import('viem').Address | null;
1298
1376
  value: bigint;
1299
- r: import('viem').Hex;
1300
- s: import('viem').Hex;
1301
- v: bigint;
1302
- yParity: number;
1303
1377
  blobVersionedHashes?: undefined | undefined;
1304
1378
  gasPrice: bigint;
1305
1379
  maxFeePerBlobGas?: undefined | undefined;
@@ -1307,24 +1381,24 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
1307
1381
  maxPriorityFeePerGas?: undefined | undefined;
1308
1382
  accessList: import('viem').AccessList;
1309
1383
  authorizationList?: undefined | undefined;
1384
+ yParity: number;
1310
1385
  hash: Hash;
1311
1386
  input: import('viem').Hex;
1387
+ r: import('viem').Hex;
1388
+ s: import('viem').Hex;
1312
1389
  typeHex: import('viem').Hex | null;
1390
+ v: bigint;
1313
1391
  blockHash: `0x${string}`;
1314
1392
  blockNumber: bigint;
1315
1393
  transactionIndex: number;
1316
1394
  } | {
1317
1395
  type: "eip1559";
1318
1396
  chainId: 137;
1397
+ to: import('viem').Address | null;
1319
1398
  from: import('viem').Address;
1320
1399
  gas: bigint;
1321
1400
  nonce: number;
1322
- to: import('viem').Address | null;
1323
1401
  value: bigint;
1324
- r: import('viem').Hex;
1325
- s: import('viem').Hex;
1326
- v: bigint;
1327
- yParity: number;
1328
1402
  blobVersionedHashes?: undefined | undefined;
1329
1403
  gasPrice?: undefined | undefined;
1330
1404
  maxFeePerBlobGas?: undefined | undefined;
@@ -1332,24 +1406,24 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
1332
1406
  maxPriorityFeePerGas: bigint;
1333
1407
  accessList: import('viem').AccessList;
1334
1408
  authorizationList?: undefined | undefined;
1409
+ yParity: number;
1335
1410
  hash: Hash;
1336
1411
  input: import('viem').Hex;
1412
+ r: import('viem').Hex;
1413
+ s: import('viem').Hex;
1337
1414
  typeHex: import('viem').Hex | null;
1415
+ v: bigint;
1338
1416
  blockHash: `0x${string}`;
1339
1417
  blockNumber: bigint;
1340
1418
  transactionIndex: number;
1341
1419
  } | {
1342
1420
  type: "eip4844";
1343
1421
  chainId: 137;
1422
+ to: import('viem').Address | null;
1344
1423
  from: import('viem').Address;
1345
1424
  gas: bigint;
1346
1425
  nonce: number;
1347
- to: import('viem').Address | null;
1348
1426
  value: bigint;
1349
- r: import('viem').Hex;
1350
- s: import('viem').Hex;
1351
- v: bigint;
1352
- yParity: number;
1353
1427
  blobVersionedHashes: readonly import('viem').Hex[];
1354
1428
  gasPrice?: undefined | undefined;
1355
1429
  maxFeePerBlobGas: bigint;
@@ -1357,24 +1431,24 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
1357
1431
  maxPriorityFeePerGas: bigint;
1358
1432
  accessList: import('viem').AccessList;
1359
1433
  authorizationList?: undefined | undefined;
1434
+ yParity: number;
1360
1435
  hash: Hash;
1361
1436
  input: import('viem').Hex;
1437
+ r: import('viem').Hex;
1438
+ s: import('viem').Hex;
1362
1439
  typeHex: import('viem').Hex | null;
1440
+ v: bigint;
1363
1441
  blockHash: `0x${string}`;
1364
1442
  blockNumber: bigint;
1365
1443
  transactionIndex: number;
1366
1444
  } | {
1367
1445
  type: "eip7702";
1368
1446
  chainId: 137;
1447
+ to: import('viem').Address | null;
1369
1448
  from: import('viem').Address;
1370
1449
  gas: bigint;
1371
1450
  nonce: number;
1372
- to: import('viem').Address | null;
1373
1451
  value: bigint;
1374
- r: import('viem').Hex;
1375
- s: import('viem').Hex;
1376
- v: bigint;
1377
- yParity: number;
1378
1452
  blobVersionedHashes?: undefined | undefined;
1379
1453
  gasPrice?: undefined | undefined;
1380
1454
  maxFeePerBlobGas?: undefined | undefined;
@@ -1382,24 +1456,24 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
1382
1456
  maxPriorityFeePerGas: bigint;
1383
1457
  accessList: import('viem').AccessList;
1384
1458
  authorizationList: import('viem').SignedAuthorizationList;
1459
+ yParity: number;
1385
1460
  hash: Hash;
1386
1461
  input: import('viem').Hex;
1462
+ r: import('viem').Hex;
1463
+ s: import('viem').Hex;
1387
1464
  typeHex: import('viem').Hex | null;
1465
+ v: bigint;
1388
1466
  blockHash: `0x${string}`;
1389
1467
  blockNumber: bigint;
1390
1468
  transactionIndex: number;
1391
1469
  } | {
1392
1470
  type: "legacy";
1393
1471
  chainId: 56;
1472
+ to: import('viem').Address | null;
1394
1473
  from: import('viem').Address;
1395
1474
  gas: bigint;
1396
1475
  nonce: number;
1397
- to: import('viem').Address | null;
1398
1476
  value: bigint;
1399
- r: import('viem').Hex;
1400
- s: import('viem').Hex;
1401
- v: bigint;
1402
- yParity?: undefined | undefined;
1403
1477
  blobVersionedHashes?: undefined | undefined;
1404
1478
  gasPrice: bigint;
1405
1479
  maxFeePerBlobGas?: undefined | undefined;
@@ -1407,24 +1481,24 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
1407
1481
  maxPriorityFeePerGas?: undefined | undefined;
1408
1482
  accessList?: undefined | undefined;
1409
1483
  authorizationList?: undefined | undefined;
1484
+ yParity?: undefined | undefined;
1410
1485
  hash: Hash;
1411
1486
  input: import('viem').Hex;
1487
+ r: import('viem').Hex;
1488
+ s: import('viem').Hex;
1412
1489
  typeHex: import('viem').Hex | null;
1490
+ v: bigint;
1413
1491
  blockHash: `0x${string}`;
1414
1492
  blockNumber: bigint;
1415
1493
  transactionIndex: number;
1416
1494
  } | {
1417
1495
  type: "eip2930";
1418
1496
  chainId: 56;
1497
+ to: import('viem').Address | null;
1419
1498
  from: import('viem').Address;
1420
1499
  gas: bigint;
1421
1500
  nonce: number;
1422
- to: import('viem').Address | null;
1423
1501
  value: bigint;
1424
- r: import('viem').Hex;
1425
- s: import('viem').Hex;
1426
- v: bigint;
1427
- yParity: number;
1428
1502
  blobVersionedHashes?: undefined | undefined;
1429
1503
  gasPrice: bigint;
1430
1504
  maxFeePerBlobGas?: undefined | undefined;
@@ -1432,24 +1506,24 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
1432
1506
  maxPriorityFeePerGas?: undefined | undefined;
1433
1507
  accessList: import('viem').AccessList;
1434
1508
  authorizationList?: undefined | undefined;
1509
+ yParity: number;
1435
1510
  hash: Hash;
1436
1511
  input: import('viem').Hex;
1512
+ r: import('viem').Hex;
1513
+ s: import('viem').Hex;
1437
1514
  typeHex: import('viem').Hex | null;
1515
+ v: bigint;
1438
1516
  blockHash: `0x${string}`;
1439
1517
  blockNumber: bigint;
1440
1518
  transactionIndex: number;
1441
1519
  } | {
1442
1520
  type: "eip1559";
1443
1521
  chainId: 56;
1522
+ to: import('viem').Address | null;
1444
1523
  from: import('viem').Address;
1445
1524
  gas: bigint;
1446
1525
  nonce: number;
1447
- to: import('viem').Address | null;
1448
1526
  value: bigint;
1449
- r: import('viem').Hex;
1450
- s: import('viem').Hex;
1451
- v: bigint;
1452
- yParity: number;
1453
1527
  blobVersionedHashes?: undefined | undefined;
1454
1528
  gasPrice?: undefined | undefined;
1455
1529
  maxFeePerBlobGas?: undefined | undefined;
@@ -1457,24 +1531,24 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
1457
1531
  maxPriorityFeePerGas: bigint;
1458
1532
  accessList: import('viem').AccessList;
1459
1533
  authorizationList?: undefined | undefined;
1534
+ yParity: number;
1460
1535
  hash: Hash;
1461
1536
  input: import('viem').Hex;
1537
+ r: import('viem').Hex;
1538
+ s: import('viem').Hex;
1462
1539
  typeHex: import('viem').Hex | null;
1540
+ v: bigint;
1463
1541
  blockHash: `0x${string}`;
1464
1542
  blockNumber: bigint;
1465
1543
  transactionIndex: number;
1466
1544
  } | {
1467
1545
  type: "eip4844";
1468
1546
  chainId: 56;
1547
+ to: import('viem').Address | null;
1469
1548
  from: import('viem').Address;
1470
1549
  gas: bigint;
1471
1550
  nonce: number;
1472
- to: import('viem').Address | null;
1473
1551
  value: bigint;
1474
- r: import('viem').Hex;
1475
- s: import('viem').Hex;
1476
- v: bigint;
1477
- yParity: number;
1478
1552
  blobVersionedHashes: readonly import('viem').Hex[];
1479
1553
  gasPrice?: undefined | undefined;
1480
1554
  maxFeePerBlobGas: bigint;
@@ -1482,24 +1556,24 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
1482
1556
  maxPriorityFeePerGas: bigint;
1483
1557
  accessList: import('viem').AccessList;
1484
1558
  authorizationList?: undefined | undefined;
1559
+ yParity: number;
1485
1560
  hash: Hash;
1486
1561
  input: import('viem').Hex;
1562
+ r: import('viem').Hex;
1563
+ s: import('viem').Hex;
1487
1564
  typeHex: import('viem').Hex | null;
1565
+ v: bigint;
1488
1566
  blockHash: `0x${string}`;
1489
1567
  blockNumber: bigint;
1490
1568
  transactionIndex: number;
1491
1569
  } | {
1492
1570
  type: "eip7702";
1493
1571
  chainId: 56;
1572
+ to: import('viem').Address | null;
1494
1573
  from: import('viem').Address;
1495
1574
  gas: bigint;
1496
1575
  nonce: number;
1497
- to: import('viem').Address | null;
1498
1576
  value: bigint;
1499
- r: import('viem').Hex;
1500
- s: import('viem').Hex;
1501
- v: bigint;
1502
- yParity: number;
1503
1577
  blobVersionedHashes?: undefined | undefined;
1504
1578
  gasPrice?: undefined | undefined;
1505
1579
  maxFeePerBlobGas?: undefined | undefined;
@@ -1507,24 +1581,24 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
1507
1581
  maxPriorityFeePerGas: bigint;
1508
1582
  accessList: import('viem').AccessList;
1509
1583
  authorizationList: import('viem').SignedAuthorizationList;
1584
+ yParity: number;
1510
1585
  hash: Hash;
1511
1586
  input: import('viem').Hex;
1587
+ r: import('viem').Hex;
1588
+ s: import('viem').Hex;
1512
1589
  typeHex: import('viem').Hex | null;
1590
+ v: bigint;
1513
1591
  blockHash: `0x${string}`;
1514
1592
  blockNumber: bigint;
1515
1593
  transactionIndex: number;
1516
1594
  } | {
1517
1595
  type: "legacy";
1518
1596
  chainId: 43114;
1597
+ to: import('viem').Address | null;
1519
1598
  from: import('viem').Address;
1520
1599
  gas: bigint;
1521
1600
  nonce: number;
1522
- to: import('viem').Address | null;
1523
1601
  value: bigint;
1524
- r: import('viem').Hex;
1525
- s: import('viem').Hex;
1526
- v: bigint;
1527
- yParity?: undefined | undefined;
1528
1602
  blobVersionedHashes?: undefined | undefined;
1529
1603
  gasPrice: bigint;
1530
1604
  maxFeePerBlobGas?: undefined | undefined;
@@ -1532,24 +1606,24 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
1532
1606
  maxPriorityFeePerGas?: undefined | undefined;
1533
1607
  accessList?: undefined | undefined;
1534
1608
  authorizationList?: undefined | undefined;
1609
+ yParity?: undefined | undefined;
1535
1610
  hash: Hash;
1536
1611
  input: import('viem').Hex;
1612
+ r: import('viem').Hex;
1613
+ s: import('viem').Hex;
1537
1614
  typeHex: import('viem').Hex | null;
1615
+ v: bigint;
1538
1616
  blockHash: `0x${string}`;
1539
1617
  blockNumber: bigint;
1540
1618
  transactionIndex: number;
1541
1619
  } | {
1542
1620
  type: "eip2930";
1543
1621
  chainId: 43114;
1622
+ to: import('viem').Address | null;
1544
1623
  from: import('viem').Address;
1545
1624
  gas: bigint;
1546
1625
  nonce: number;
1547
- to: import('viem').Address | null;
1548
1626
  value: bigint;
1549
- r: import('viem').Hex;
1550
- s: import('viem').Hex;
1551
- v: bigint;
1552
- yParity: number;
1553
1627
  blobVersionedHashes?: undefined | undefined;
1554
1628
  gasPrice: bigint;
1555
1629
  maxFeePerBlobGas?: undefined | undefined;
@@ -1557,24 +1631,24 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
1557
1631
  maxPriorityFeePerGas?: undefined | undefined;
1558
1632
  accessList: import('viem').AccessList;
1559
1633
  authorizationList?: undefined | undefined;
1634
+ yParity: number;
1560
1635
  hash: Hash;
1561
1636
  input: import('viem').Hex;
1637
+ r: import('viem').Hex;
1638
+ s: import('viem').Hex;
1562
1639
  typeHex: import('viem').Hex | null;
1640
+ v: bigint;
1563
1641
  blockHash: `0x${string}`;
1564
1642
  blockNumber: bigint;
1565
1643
  transactionIndex: number;
1566
1644
  } | {
1567
1645
  type: "eip1559";
1568
1646
  chainId: 43114;
1647
+ to: import('viem').Address | null;
1569
1648
  from: import('viem').Address;
1570
1649
  gas: bigint;
1571
1650
  nonce: number;
1572
- to: import('viem').Address | null;
1573
1651
  value: bigint;
1574
- r: import('viem').Hex;
1575
- s: import('viem').Hex;
1576
- v: bigint;
1577
- yParity: number;
1578
1652
  blobVersionedHashes?: undefined | undefined;
1579
1653
  gasPrice?: undefined | undefined;
1580
1654
  maxFeePerBlobGas?: undefined | undefined;
@@ -1582,24 +1656,24 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
1582
1656
  maxPriorityFeePerGas: bigint;
1583
1657
  accessList: import('viem').AccessList;
1584
1658
  authorizationList?: undefined | undefined;
1659
+ yParity: number;
1585
1660
  hash: Hash;
1586
1661
  input: import('viem').Hex;
1662
+ r: import('viem').Hex;
1663
+ s: import('viem').Hex;
1587
1664
  typeHex: import('viem').Hex | null;
1665
+ v: bigint;
1588
1666
  blockHash: `0x${string}`;
1589
1667
  blockNumber: bigint;
1590
1668
  transactionIndex: number;
1591
1669
  } | {
1592
1670
  type: "eip4844";
1593
1671
  chainId: 43114;
1672
+ to: import('viem').Address | null;
1594
1673
  from: import('viem').Address;
1595
1674
  gas: bigint;
1596
1675
  nonce: number;
1597
- to: import('viem').Address | null;
1598
1676
  value: bigint;
1599
- r: import('viem').Hex;
1600
- s: import('viem').Hex;
1601
- v: bigint;
1602
- yParity: number;
1603
1677
  blobVersionedHashes: readonly import('viem').Hex[];
1604
1678
  gasPrice?: undefined | undefined;
1605
1679
  maxFeePerBlobGas: bigint;
@@ -1607,24 +1681,24 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
1607
1681
  maxPriorityFeePerGas: bigint;
1608
1682
  accessList: import('viem').AccessList;
1609
1683
  authorizationList?: undefined | undefined;
1684
+ yParity: number;
1610
1685
  hash: Hash;
1611
1686
  input: import('viem').Hex;
1687
+ r: import('viem').Hex;
1688
+ s: import('viem').Hex;
1612
1689
  typeHex: import('viem').Hex | null;
1690
+ v: bigint;
1613
1691
  blockHash: `0x${string}`;
1614
1692
  blockNumber: bigint;
1615
1693
  transactionIndex: number;
1616
1694
  } | {
1617
1695
  type: "eip7702";
1618
1696
  chainId: 43114;
1697
+ to: import('viem').Address | null;
1619
1698
  from: import('viem').Address;
1620
1699
  gas: bigint;
1621
1700
  nonce: number;
1622
- to: import('viem').Address | null;
1623
1701
  value: bigint;
1624
- r: import('viem').Hex;
1625
- s: import('viem').Hex;
1626
- v: bigint;
1627
- yParity: number;
1628
1702
  blobVersionedHashes?: undefined | undefined;
1629
1703
  gasPrice?: undefined | undefined;
1630
1704
  maxFeePerBlobGas?: undefined | undefined;
@@ -1632,24 +1706,24 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
1632
1706
  maxPriorityFeePerGas: bigint;
1633
1707
  accessList: import('viem').AccessList;
1634
1708
  authorizationList: import('viem').SignedAuthorizationList;
1709
+ yParity: number;
1635
1710
  hash: Hash;
1636
1711
  input: import('viem').Hex;
1712
+ r: import('viem').Hex;
1713
+ s: import('viem').Hex;
1637
1714
  typeHex: import('viem').Hex | null;
1715
+ v: bigint;
1638
1716
  blockHash: `0x${string}`;
1639
1717
  blockNumber: bigint;
1640
1718
  transactionIndex: number;
1641
1719
  } | {
1642
1720
  type: "legacy";
1643
1721
  chainId: 42161;
1722
+ to: import('viem').Address | null;
1644
1723
  from: import('viem').Address;
1645
1724
  gas: bigint;
1646
1725
  nonce: number;
1647
- to: import('viem').Address | null;
1648
1726
  value: bigint;
1649
- r: import('viem').Hex;
1650
- s: import('viem').Hex;
1651
- v: bigint;
1652
- yParity?: undefined | undefined;
1653
1727
  blobVersionedHashes?: undefined | undefined;
1654
1728
  gasPrice: bigint;
1655
1729
  maxFeePerBlobGas?: undefined | undefined;
@@ -1657,24 +1731,24 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
1657
1731
  maxPriorityFeePerGas?: undefined | undefined;
1658
1732
  accessList?: undefined | undefined;
1659
1733
  authorizationList?: undefined | undefined;
1734
+ yParity?: undefined | undefined;
1660
1735
  hash: Hash;
1661
1736
  input: import('viem').Hex;
1737
+ r: import('viem').Hex;
1738
+ s: import('viem').Hex;
1662
1739
  typeHex: import('viem').Hex | null;
1740
+ v: bigint;
1663
1741
  blockHash: `0x${string}`;
1664
1742
  blockNumber: bigint;
1665
1743
  transactionIndex: number;
1666
1744
  } | {
1667
1745
  type: "eip2930";
1668
1746
  chainId: 42161;
1747
+ to: import('viem').Address | null;
1669
1748
  from: import('viem').Address;
1670
1749
  gas: bigint;
1671
1750
  nonce: number;
1672
- to: import('viem').Address | null;
1673
1751
  value: bigint;
1674
- r: import('viem').Hex;
1675
- s: import('viem').Hex;
1676
- v: bigint;
1677
- yParity: number;
1678
1752
  blobVersionedHashes?: undefined | undefined;
1679
1753
  gasPrice: bigint;
1680
1754
  maxFeePerBlobGas?: undefined | undefined;
@@ -1682,24 +1756,24 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
1682
1756
  maxPriorityFeePerGas?: undefined | undefined;
1683
1757
  accessList: import('viem').AccessList;
1684
1758
  authorizationList?: undefined | undefined;
1759
+ yParity: number;
1685
1760
  hash: Hash;
1686
1761
  input: import('viem').Hex;
1762
+ r: import('viem').Hex;
1763
+ s: import('viem').Hex;
1687
1764
  typeHex: import('viem').Hex | null;
1765
+ v: bigint;
1688
1766
  blockHash: `0x${string}`;
1689
1767
  blockNumber: bigint;
1690
1768
  transactionIndex: number;
1691
1769
  } | {
1692
1770
  type: "eip1559";
1693
1771
  chainId: 42161;
1772
+ to: import('viem').Address | null;
1694
1773
  from: import('viem').Address;
1695
1774
  gas: bigint;
1696
1775
  nonce: number;
1697
- to: import('viem').Address | null;
1698
1776
  value: bigint;
1699
- r: import('viem').Hex;
1700
- s: import('viem').Hex;
1701
- v: bigint;
1702
- yParity: number;
1703
1777
  blobVersionedHashes?: undefined | undefined;
1704
1778
  gasPrice?: undefined | undefined;
1705
1779
  maxFeePerBlobGas?: undefined | undefined;
@@ -1707,24 +1781,24 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
1707
1781
  maxPriorityFeePerGas: bigint;
1708
1782
  accessList: import('viem').AccessList;
1709
1783
  authorizationList?: undefined | undefined;
1784
+ yParity: number;
1710
1785
  hash: Hash;
1711
1786
  input: import('viem').Hex;
1787
+ r: import('viem').Hex;
1788
+ s: import('viem').Hex;
1712
1789
  typeHex: import('viem').Hex | null;
1790
+ v: bigint;
1713
1791
  blockHash: `0x${string}`;
1714
1792
  blockNumber: bigint;
1715
1793
  transactionIndex: number;
1716
1794
  } | {
1717
1795
  type: "eip4844";
1718
1796
  chainId: 42161;
1797
+ to: import('viem').Address | null;
1719
1798
  from: import('viem').Address;
1720
1799
  gas: bigint;
1721
1800
  nonce: number;
1722
- to: import('viem').Address | null;
1723
1801
  value: bigint;
1724
- r: import('viem').Hex;
1725
- s: import('viem').Hex;
1726
- v: bigint;
1727
- yParity: number;
1728
1802
  blobVersionedHashes: readonly import('viem').Hex[];
1729
1803
  gasPrice?: undefined | undefined;
1730
1804
  maxFeePerBlobGas: bigint;
@@ -1732,24 +1806,24 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
1732
1806
  maxPriorityFeePerGas: bigint;
1733
1807
  accessList: import('viem').AccessList;
1734
1808
  authorizationList?: undefined | undefined;
1809
+ yParity: number;
1735
1810
  hash: Hash;
1736
1811
  input: import('viem').Hex;
1812
+ r: import('viem').Hex;
1813
+ s: import('viem').Hex;
1737
1814
  typeHex: import('viem').Hex | null;
1815
+ v: bigint;
1738
1816
  blockHash: `0x${string}`;
1739
1817
  blockNumber: bigint;
1740
1818
  transactionIndex: number;
1741
1819
  } | {
1742
1820
  type: "eip7702";
1743
1821
  chainId: 42161;
1822
+ to: import('viem').Address | null;
1744
1823
  from: import('viem').Address;
1745
1824
  gas: bigint;
1746
1825
  nonce: number;
1747
- to: import('viem').Address | null;
1748
1826
  value: bigint;
1749
- r: import('viem').Hex;
1750
- s: import('viem').Hex;
1751
- v: bigint;
1752
- yParity: number;
1753
1827
  blobVersionedHashes?: undefined | undefined;
1754
1828
  gasPrice?: undefined | undefined;
1755
1829
  maxFeePerBlobGas?: undefined | undefined;
@@ -1757,30 +1831,34 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
1757
1831
  maxPriorityFeePerGas: bigint;
1758
1832
  accessList: import('viem').AccessList;
1759
1833
  authorizationList: import('viem').SignedAuthorizationList;
1834
+ yParity: number;
1760
1835
  hash: Hash;
1761
1836
  input: import('viem').Hex;
1837
+ r: import('viem').Hex;
1838
+ s: import('viem').Hex;
1762
1839
  typeHex: import('viem').Hex | null;
1840
+ v: bigint;
1763
1841
  blockHash: `0x${string}`;
1764
1842
  blockNumber: bigint;
1765
1843
  transactionIndex: number;
1766
1844
  } | {
1767
1845
  type: "deposit";
1846
+ to: import('viem').Address | null;
1768
1847
  from: import('viem').Address;
1769
1848
  gas: bigint;
1770
1849
  nonce: number;
1771
- to: import('viem').Address | null;
1772
1850
  value: bigint;
1773
- r: import('viem').Hex;
1774
- s: import('viem').Hex;
1775
- v: bigint;
1776
- yParity: number;
1777
1851
  gasPrice?: undefined | undefined | undefined;
1778
1852
  maxFeePerBlobGas?: undefined | undefined | undefined;
1779
1853
  maxFeePerGas: bigint;
1780
1854
  maxPriorityFeePerGas: bigint;
1855
+ yParity: number;
1781
1856
  hash: import('viem').Hash;
1782
1857
  input: import('viem').Hex;
1858
+ r: import('viem').Hex;
1859
+ s: import('viem').Hex;
1783
1860
  typeHex: import('viem').Hex | null;
1861
+ v: bigint;
1784
1862
  isSystemTx?: boolean | undefined;
1785
1863
  mint?: bigint | undefined | undefined | undefined;
1786
1864
  sourceHash: import('viem').Hex;
@@ -1791,15 +1869,11 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
1791
1869
  } | {
1792
1870
  type: "legacy";
1793
1871
  chainId: 10;
1872
+ to: import('viem').Address | null;
1794
1873
  from: import('viem').Address;
1795
1874
  gas: bigint;
1796
1875
  nonce: number;
1797
- to: import('viem').Address | null;
1798
1876
  value: bigint;
1799
- r: import('viem').Hex;
1800
- s: import('viem').Hex;
1801
- v: bigint;
1802
- yParity?: undefined | undefined | undefined;
1803
1877
  blobVersionedHashes?: undefined | undefined | undefined;
1804
1878
  gasPrice: bigint;
1805
1879
  maxFeePerBlobGas?: undefined | undefined | undefined;
@@ -1807,9 +1881,13 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
1807
1881
  maxPriorityFeePerGas?: undefined | undefined | undefined;
1808
1882
  accessList?: undefined | undefined | undefined;
1809
1883
  authorizationList?: undefined | undefined | undefined;
1884
+ yParity?: undefined | undefined | undefined;
1810
1885
  hash: import('viem').Hash;
1811
1886
  input: import('viem').Hex;
1887
+ r: import('viem').Hex;
1888
+ s: import('viem').Hex;
1812
1889
  typeHex: import('viem').Hex | null;
1890
+ v: bigint;
1813
1891
  isSystemTx?: undefined | undefined | undefined;
1814
1892
  mint?: undefined | undefined | undefined;
1815
1893
  sourceHash?: undefined | undefined | undefined;
@@ -1819,15 +1897,11 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
1819
1897
  } | {
1820
1898
  type: "eip2930";
1821
1899
  chainId: 10;
1900
+ to: import('viem').Address | null;
1822
1901
  from: import('viem').Address;
1823
1902
  gas: bigint;
1824
1903
  nonce: number;
1825
- to: import('viem').Address | null;
1826
1904
  value: bigint;
1827
- r: import('viem').Hex;
1828
- s: import('viem').Hex;
1829
- v: bigint;
1830
- yParity: number;
1831
1905
  blobVersionedHashes?: undefined | undefined | undefined;
1832
1906
  gasPrice: bigint;
1833
1907
  maxFeePerBlobGas?: undefined | undefined | undefined;
@@ -1835,9 +1909,13 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
1835
1909
  maxPriorityFeePerGas?: undefined | undefined | undefined;
1836
1910
  accessList: import('viem').AccessList;
1837
1911
  authorizationList?: undefined | undefined | undefined;
1912
+ yParity: number;
1838
1913
  hash: import('viem').Hash;
1839
1914
  input: import('viem').Hex;
1915
+ r: import('viem').Hex;
1916
+ s: import('viem').Hex;
1840
1917
  typeHex: import('viem').Hex | null;
1918
+ v: bigint;
1841
1919
  isSystemTx?: undefined | undefined | undefined;
1842
1920
  mint?: undefined | undefined | undefined;
1843
1921
  sourceHash?: undefined | undefined | undefined;
@@ -1847,15 +1925,11 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
1847
1925
  } | {
1848
1926
  type: "eip1559";
1849
1927
  chainId: 10;
1928
+ to: import('viem').Address | null;
1850
1929
  from: import('viem').Address;
1851
1930
  gas: bigint;
1852
1931
  nonce: number;
1853
- to: import('viem').Address | null;
1854
1932
  value: bigint;
1855
- r: import('viem').Hex;
1856
- s: import('viem').Hex;
1857
- v: bigint;
1858
- yParity: number;
1859
1933
  blobVersionedHashes?: undefined | undefined | undefined;
1860
1934
  gasPrice?: undefined | undefined | undefined;
1861
1935
  maxFeePerBlobGas?: undefined | undefined | undefined;
@@ -1863,9 +1937,13 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
1863
1937
  maxPriorityFeePerGas: bigint;
1864
1938
  accessList: import('viem').AccessList;
1865
1939
  authorizationList?: undefined | undefined | undefined;
1940
+ yParity: number;
1866
1941
  hash: import('viem').Hash;
1867
1942
  input: import('viem').Hex;
1943
+ r: import('viem').Hex;
1944
+ s: import('viem').Hex;
1868
1945
  typeHex: import('viem').Hex | null;
1946
+ v: bigint;
1869
1947
  isSystemTx?: undefined | undefined | undefined;
1870
1948
  mint?: undefined | undefined | undefined;
1871
1949
  sourceHash?: undefined | undefined | undefined;
@@ -1875,15 +1953,11 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
1875
1953
  } | {
1876
1954
  type: "eip4844";
1877
1955
  chainId: 10;
1956
+ to: import('viem').Address | null;
1878
1957
  from: import('viem').Address;
1879
1958
  gas: bigint;
1880
1959
  nonce: number;
1881
- to: import('viem').Address | null;
1882
1960
  value: bigint;
1883
- r: import('viem').Hex;
1884
- s: import('viem').Hex;
1885
- v: bigint;
1886
- yParity: number;
1887
1961
  blobVersionedHashes: readonly import('viem').Hex[];
1888
1962
  gasPrice?: undefined | undefined | undefined;
1889
1963
  maxFeePerBlobGas: bigint;
@@ -1891,9 +1965,13 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
1891
1965
  maxPriorityFeePerGas: bigint;
1892
1966
  accessList: import('viem').AccessList;
1893
1967
  authorizationList?: undefined | undefined | undefined;
1968
+ yParity: number;
1894
1969
  hash: import('viem').Hash;
1895
1970
  input: import('viem').Hex;
1971
+ r: import('viem').Hex;
1972
+ s: import('viem').Hex;
1896
1973
  typeHex: import('viem').Hex | null;
1974
+ v: bigint;
1897
1975
  isSystemTx?: undefined | undefined | undefined;
1898
1976
  mint?: undefined | undefined | undefined;
1899
1977
  sourceHash?: undefined | undefined | undefined;
@@ -1903,15 +1981,11 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
1903
1981
  } | {
1904
1982
  type: "eip7702";
1905
1983
  chainId: 10;
1984
+ to: import('viem').Address | null;
1906
1985
  from: import('viem').Address;
1907
1986
  gas: bigint;
1908
1987
  nonce: number;
1909
- to: import('viem').Address | null;
1910
1988
  value: bigint;
1911
- r: import('viem').Hex;
1912
- s: import('viem').Hex;
1913
- v: bigint;
1914
- yParity: number;
1915
1989
  blobVersionedHashes?: undefined | undefined | undefined;
1916
1990
  gasPrice?: undefined | undefined | undefined;
1917
1991
  maxFeePerBlobGas?: undefined | undefined | undefined;
@@ -1919,9 +1993,13 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
1919
1993
  maxPriorityFeePerGas: bigint;
1920
1994
  accessList: import('viem').AccessList;
1921
1995
  authorizationList: import('viem').SignedAuthorizationList;
1996
+ yParity: number;
1922
1997
  hash: import('viem').Hash;
1923
1998
  input: import('viem').Hex;
1999
+ r: import('viem').Hex;
2000
+ s: import('viem').Hex;
1924
2001
  typeHex: import('viem').Hex | null;
2002
+ v: bigint;
1925
2003
  isSystemTx?: undefined | undefined | undefined;
1926
2004
  mint?: undefined | undefined | undefined;
1927
2005
  sourceHash?: undefined | undefined | undefined;
@@ -1930,22 +2008,22 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
1930
2008
  transactionIndex: number;
1931
2009
  } | {
1932
2010
  type: "deposit";
2011
+ to: import('viem').Address | null;
1933
2012
  from: import('viem').Address;
1934
2013
  gas: bigint;
1935
2014
  nonce: number;
1936
- to: import('viem').Address | null;
1937
2015
  value: bigint;
1938
- r: import('viem').Hex;
1939
- s: import('viem').Hex;
1940
- v: bigint;
1941
- yParity: number;
1942
2016
  gasPrice?: undefined | undefined | undefined;
1943
2017
  maxFeePerBlobGas?: undefined | undefined | undefined;
1944
2018
  maxFeePerGas: bigint;
1945
2019
  maxPriorityFeePerGas: bigint;
2020
+ yParity: number;
1946
2021
  hash: import('viem').Hash;
1947
2022
  input: import('viem').Hex;
2023
+ r: import('viem').Hex;
2024
+ s: import('viem').Hex;
1948
2025
  typeHex: import('viem').Hex | null;
2026
+ v: bigint;
1949
2027
  isSystemTx?: boolean | undefined;
1950
2028
  mint?: bigint | undefined | undefined | undefined;
1951
2029
  sourceHash: import('viem').Hex;
@@ -1956,15 +2034,11 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
1956
2034
  } | {
1957
2035
  type: "legacy";
1958
2036
  chainId: 8453;
2037
+ to: import('viem').Address | null;
1959
2038
  from: import('viem').Address;
1960
2039
  gas: bigint;
1961
2040
  nonce: number;
1962
- to: import('viem').Address | null;
1963
2041
  value: bigint;
1964
- r: import('viem').Hex;
1965
- s: import('viem').Hex;
1966
- v: bigint;
1967
- yParity?: undefined | undefined | undefined;
1968
2042
  blobVersionedHashes?: undefined | undefined | undefined;
1969
2043
  gasPrice: bigint;
1970
2044
  maxFeePerBlobGas?: undefined | undefined | undefined;
@@ -1972,9 +2046,13 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
1972
2046
  maxPriorityFeePerGas?: undefined | undefined | undefined;
1973
2047
  accessList?: undefined | undefined | undefined;
1974
2048
  authorizationList?: undefined | undefined | undefined;
2049
+ yParity?: undefined | undefined | undefined;
1975
2050
  hash: import('viem').Hash;
1976
2051
  input: import('viem').Hex;
2052
+ r: import('viem').Hex;
2053
+ s: import('viem').Hex;
1977
2054
  typeHex: import('viem').Hex | null;
2055
+ v: bigint;
1978
2056
  isSystemTx?: undefined | undefined | undefined;
1979
2057
  mint?: undefined | undefined | undefined;
1980
2058
  sourceHash?: undefined | undefined | undefined;
@@ -1984,15 +2062,11 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
1984
2062
  } | {
1985
2063
  type: "eip2930";
1986
2064
  chainId: 8453;
2065
+ to: import('viem').Address | null;
1987
2066
  from: import('viem').Address;
1988
2067
  gas: bigint;
1989
2068
  nonce: number;
1990
- to: import('viem').Address | null;
1991
2069
  value: bigint;
1992
- r: import('viem').Hex;
1993
- s: import('viem').Hex;
1994
- v: bigint;
1995
- yParity: number;
1996
2070
  blobVersionedHashes?: undefined | undefined | undefined;
1997
2071
  gasPrice: bigint;
1998
2072
  maxFeePerBlobGas?: undefined | undefined | undefined;
@@ -2000,9 +2074,13 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
2000
2074
  maxPriorityFeePerGas?: undefined | undefined | undefined;
2001
2075
  accessList: import('viem').AccessList;
2002
2076
  authorizationList?: undefined | undefined | undefined;
2077
+ yParity: number;
2003
2078
  hash: import('viem').Hash;
2004
2079
  input: import('viem').Hex;
2080
+ r: import('viem').Hex;
2081
+ s: import('viem').Hex;
2005
2082
  typeHex: import('viem').Hex | null;
2083
+ v: bigint;
2006
2084
  isSystemTx?: undefined | undefined | undefined;
2007
2085
  mint?: undefined | undefined | undefined;
2008
2086
  sourceHash?: undefined | undefined | undefined;
@@ -2012,15 +2090,11 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
2012
2090
  } | {
2013
2091
  type: "eip1559";
2014
2092
  chainId: 8453;
2093
+ to: import('viem').Address | null;
2015
2094
  from: import('viem').Address;
2016
2095
  gas: bigint;
2017
2096
  nonce: number;
2018
- to: import('viem').Address | null;
2019
2097
  value: bigint;
2020
- r: import('viem').Hex;
2021
- s: import('viem').Hex;
2022
- v: bigint;
2023
- yParity: number;
2024
2098
  blobVersionedHashes?: undefined | undefined | undefined;
2025
2099
  gasPrice?: undefined | undefined | undefined;
2026
2100
  maxFeePerBlobGas?: undefined | undefined | undefined;
@@ -2028,9 +2102,13 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
2028
2102
  maxPriorityFeePerGas: bigint;
2029
2103
  accessList: import('viem').AccessList;
2030
2104
  authorizationList?: undefined | undefined | undefined;
2105
+ yParity: number;
2031
2106
  hash: import('viem').Hash;
2032
2107
  input: import('viem').Hex;
2108
+ r: import('viem').Hex;
2109
+ s: import('viem').Hex;
2033
2110
  typeHex: import('viem').Hex | null;
2111
+ v: bigint;
2034
2112
  isSystemTx?: undefined | undefined | undefined;
2035
2113
  mint?: undefined | undefined | undefined;
2036
2114
  sourceHash?: undefined | undefined | undefined;
@@ -2040,15 +2118,11 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
2040
2118
  } | {
2041
2119
  type: "eip4844";
2042
2120
  chainId: 8453;
2121
+ to: import('viem').Address | null;
2043
2122
  from: import('viem').Address;
2044
2123
  gas: bigint;
2045
2124
  nonce: number;
2046
- to: import('viem').Address | null;
2047
2125
  value: bigint;
2048
- r: import('viem').Hex;
2049
- s: import('viem').Hex;
2050
- v: bigint;
2051
- yParity: number;
2052
2126
  blobVersionedHashes: readonly import('viem').Hex[];
2053
2127
  gasPrice?: undefined | undefined | undefined;
2054
2128
  maxFeePerBlobGas: bigint;
@@ -2056,9 +2130,13 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
2056
2130
  maxPriorityFeePerGas: bigint;
2057
2131
  accessList: import('viem').AccessList;
2058
2132
  authorizationList?: undefined | undefined | undefined;
2133
+ yParity: number;
2059
2134
  hash: import('viem').Hash;
2060
2135
  input: import('viem').Hex;
2136
+ r: import('viem').Hex;
2137
+ s: import('viem').Hex;
2061
2138
  typeHex: import('viem').Hex | null;
2139
+ v: bigint;
2062
2140
  isSystemTx?: undefined | undefined | undefined;
2063
2141
  mint?: undefined | undefined | undefined;
2064
2142
  sourceHash?: undefined | undefined | undefined;
@@ -2068,15 +2146,11 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
2068
2146
  } | {
2069
2147
  type: "eip7702";
2070
2148
  chainId: 8453;
2149
+ to: import('viem').Address | null;
2071
2150
  from: import('viem').Address;
2072
2151
  gas: bigint;
2073
2152
  nonce: number;
2074
- to: import('viem').Address | null;
2075
2153
  value: bigint;
2076
- r: import('viem').Hex;
2077
- s: import('viem').Hex;
2078
- v: bigint;
2079
- yParity: number;
2080
2154
  blobVersionedHashes?: undefined | undefined | undefined;
2081
2155
  gasPrice?: undefined | undefined | undefined;
2082
2156
  maxFeePerBlobGas?: undefined | undefined | undefined;
@@ -2084,9 +2158,13 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
2084
2158
  maxPriorityFeePerGas: bigint;
2085
2159
  accessList: import('viem').AccessList;
2086
2160
  authorizationList: import('viem').SignedAuthorizationList;
2161
+ yParity: number;
2087
2162
  hash: import('viem').Hash;
2088
2163
  input: import('viem').Hex;
2164
+ r: import('viem').Hex;
2165
+ s: import('viem').Hex;
2089
2166
  typeHex: import('viem').Hex | null;
2167
+ v: bigint;
2090
2168
  isSystemTx?: undefined | undefined | undefined;
2091
2169
  mint?: undefined | undefined | undefined;
2092
2170
  sourceHash?: undefined | undefined | undefined;
@@ -2096,15 +2174,11 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
2096
2174
  } | {
2097
2175
  type: "legacy";
2098
2176
  chainId: 100;
2177
+ to: import('viem').Address | null;
2099
2178
  from: import('viem').Address;
2100
2179
  gas: bigint;
2101
2180
  nonce: number;
2102
- to: import('viem').Address | null;
2103
2181
  value: bigint;
2104
- r: import('viem').Hex;
2105
- s: import('viem').Hex;
2106
- v: bigint;
2107
- yParity?: undefined | undefined;
2108
2182
  blobVersionedHashes?: undefined | undefined;
2109
2183
  gasPrice: bigint;
2110
2184
  maxFeePerBlobGas?: undefined | undefined;
@@ -2112,24 +2186,24 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
2112
2186
  maxPriorityFeePerGas?: undefined | undefined;
2113
2187
  accessList?: undefined | undefined;
2114
2188
  authorizationList?: undefined | undefined;
2189
+ yParity?: undefined | undefined;
2115
2190
  hash: Hash;
2116
2191
  input: import('viem').Hex;
2192
+ r: import('viem').Hex;
2193
+ s: import('viem').Hex;
2117
2194
  typeHex: import('viem').Hex | null;
2195
+ v: bigint;
2118
2196
  blockHash: `0x${string}`;
2119
2197
  blockNumber: bigint;
2120
2198
  transactionIndex: number;
2121
2199
  } | {
2122
2200
  type: "eip2930";
2123
2201
  chainId: 100;
2202
+ to: import('viem').Address | null;
2124
2203
  from: import('viem').Address;
2125
2204
  gas: bigint;
2126
2205
  nonce: number;
2127
- to: import('viem').Address | null;
2128
2206
  value: bigint;
2129
- r: import('viem').Hex;
2130
- s: import('viem').Hex;
2131
- v: bigint;
2132
- yParity: number;
2133
2207
  blobVersionedHashes?: undefined | undefined;
2134
2208
  gasPrice: bigint;
2135
2209
  maxFeePerBlobGas?: undefined | undefined;
@@ -2137,24 +2211,24 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
2137
2211
  maxPriorityFeePerGas?: undefined | undefined;
2138
2212
  accessList: import('viem').AccessList;
2139
2213
  authorizationList?: undefined | undefined;
2214
+ yParity: number;
2140
2215
  hash: Hash;
2141
2216
  input: import('viem').Hex;
2217
+ r: import('viem').Hex;
2218
+ s: import('viem').Hex;
2142
2219
  typeHex: import('viem').Hex | null;
2220
+ v: bigint;
2143
2221
  blockHash: `0x${string}`;
2144
2222
  blockNumber: bigint;
2145
2223
  transactionIndex: number;
2146
2224
  } | {
2147
2225
  type: "eip1559";
2148
2226
  chainId: 100;
2227
+ to: import('viem').Address | null;
2149
2228
  from: import('viem').Address;
2150
2229
  gas: bigint;
2151
2230
  nonce: number;
2152
- to: import('viem').Address | null;
2153
2231
  value: bigint;
2154
- r: import('viem').Hex;
2155
- s: import('viem').Hex;
2156
- v: bigint;
2157
- yParity: number;
2158
2232
  blobVersionedHashes?: undefined | undefined;
2159
2233
  gasPrice?: undefined | undefined;
2160
2234
  maxFeePerBlobGas?: undefined | undefined;
@@ -2162,24 +2236,24 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
2162
2236
  maxPriorityFeePerGas: bigint;
2163
2237
  accessList: import('viem').AccessList;
2164
2238
  authorizationList?: undefined | undefined;
2239
+ yParity: number;
2165
2240
  hash: Hash;
2166
2241
  input: import('viem').Hex;
2242
+ r: import('viem').Hex;
2243
+ s: import('viem').Hex;
2167
2244
  typeHex: import('viem').Hex | null;
2245
+ v: bigint;
2168
2246
  blockHash: `0x${string}`;
2169
2247
  blockNumber: bigint;
2170
2248
  transactionIndex: number;
2171
2249
  } | {
2172
2250
  type: "eip4844";
2173
2251
  chainId: 100;
2252
+ to: import('viem').Address | null;
2174
2253
  from: import('viem').Address;
2175
2254
  gas: bigint;
2176
2255
  nonce: number;
2177
- to: import('viem').Address | null;
2178
2256
  value: bigint;
2179
- r: import('viem').Hex;
2180
- s: import('viem').Hex;
2181
- v: bigint;
2182
- yParity: number;
2183
2257
  blobVersionedHashes: readonly import('viem').Hex[];
2184
2258
  gasPrice?: undefined | undefined;
2185
2259
  maxFeePerBlobGas: bigint;
@@ -2187,24 +2261,24 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
2187
2261
  maxPriorityFeePerGas: bigint;
2188
2262
  accessList: import('viem').AccessList;
2189
2263
  authorizationList?: undefined | undefined;
2264
+ yParity: number;
2190
2265
  hash: Hash;
2191
2266
  input: import('viem').Hex;
2267
+ r: import('viem').Hex;
2268
+ s: import('viem').Hex;
2192
2269
  typeHex: import('viem').Hex | null;
2270
+ v: bigint;
2193
2271
  blockHash: `0x${string}`;
2194
2272
  blockNumber: bigint;
2195
2273
  transactionIndex: number;
2196
2274
  } | {
2197
2275
  type: "eip7702";
2198
2276
  chainId: 100;
2277
+ to: import('viem').Address | null;
2199
2278
  from: import('viem').Address;
2200
2279
  gas: bigint;
2201
2280
  nonce: number;
2202
- to: import('viem').Address | null;
2203
2281
  value: bigint;
2204
- r: import('viem').Hex;
2205
- s: import('viem').Hex;
2206
- v: bigint;
2207
- yParity: number;
2208
2282
  blobVersionedHashes?: undefined | undefined;
2209
2283
  gasPrice?: undefined | undefined;
2210
2284
  maxFeePerBlobGas?: undefined | undefined;
@@ -2212,30 +2286,34 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
2212
2286
  maxPriorityFeePerGas: bigint;
2213
2287
  accessList: import('viem').AccessList;
2214
2288
  authorizationList: import('viem').SignedAuthorizationList;
2289
+ yParity: number;
2215
2290
  hash: Hash;
2216
2291
  input: import('viem').Hex;
2292
+ r: import('viem').Hex;
2293
+ s: import('viem').Hex;
2217
2294
  typeHex: import('viem').Hex | null;
2295
+ v: bigint;
2218
2296
  blockHash: `0x${string}`;
2219
2297
  blockNumber: bigint;
2220
2298
  transactionIndex: number;
2221
2299
  } | {
2222
2300
  type: "deposit";
2301
+ to: import('viem').Address | null;
2223
2302
  from: import('viem').Address;
2224
2303
  gas: bigint;
2225
2304
  nonce: number;
2226
- to: import('viem').Address | null;
2227
2305
  value: bigint;
2228
- r: import('viem').Hex;
2229
- s: import('viem').Hex;
2230
- v: bigint;
2231
- yParity: number;
2232
2306
  gasPrice?: undefined | undefined | undefined;
2233
2307
  maxFeePerBlobGas?: undefined | undefined | undefined;
2234
2308
  maxFeePerGas: bigint;
2235
2309
  maxPriorityFeePerGas: bigint;
2310
+ yParity: number;
2236
2311
  hash: import('viem').Hash;
2237
2312
  input: import('viem').Hex;
2313
+ r: import('viem').Hex;
2314
+ s: import('viem').Hex;
2238
2315
  typeHex: import('viem').Hex | null;
2316
+ v: bigint;
2239
2317
  isSystemTx?: boolean | undefined;
2240
2318
  mint?: bigint | undefined | undefined | undefined;
2241
2319
  sourceHash: import('viem').Hex;
@@ -2246,15 +2324,11 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
2246
2324
  } | {
2247
2325
  type: "legacy";
2248
2326
  chainId: 130;
2327
+ to: import('viem').Address | null;
2249
2328
  from: import('viem').Address;
2250
2329
  gas: bigint;
2251
2330
  nonce: number;
2252
- to: import('viem').Address | null;
2253
2331
  value: bigint;
2254
- r: import('viem').Hex;
2255
- s: import('viem').Hex;
2256
- v: bigint;
2257
- yParity?: undefined | undefined | undefined;
2258
2332
  blobVersionedHashes?: undefined | undefined | undefined;
2259
2333
  gasPrice: bigint;
2260
2334
  maxFeePerBlobGas?: undefined | undefined | undefined;
@@ -2262,9 +2336,13 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
2262
2336
  maxPriorityFeePerGas?: undefined | undefined | undefined;
2263
2337
  accessList?: undefined | undefined | undefined;
2264
2338
  authorizationList?: undefined | undefined | undefined;
2339
+ yParity?: undefined | undefined | undefined;
2265
2340
  hash: import('viem').Hash;
2266
2341
  input: import('viem').Hex;
2342
+ r: import('viem').Hex;
2343
+ s: import('viem').Hex;
2267
2344
  typeHex: import('viem').Hex | null;
2345
+ v: bigint;
2268
2346
  isSystemTx?: undefined | undefined | undefined;
2269
2347
  mint?: undefined | undefined | undefined;
2270
2348
  sourceHash?: undefined | undefined | undefined;
@@ -2274,15 +2352,11 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
2274
2352
  } | {
2275
2353
  type: "eip2930";
2276
2354
  chainId: 130;
2355
+ to: import('viem').Address | null;
2277
2356
  from: import('viem').Address;
2278
2357
  gas: bigint;
2279
2358
  nonce: number;
2280
- to: import('viem').Address | null;
2281
2359
  value: bigint;
2282
- r: import('viem').Hex;
2283
- s: import('viem').Hex;
2284
- v: bigint;
2285
- yParity: number;
2286
2360
  blobVersionedHashes?: undefined | undefined | undefined;
2287
2361
  gasPrice: bigint;
2288
2362
  maxFeePerBlobGas?: undefined | undefined | undefined;
@@ -2290,9 +2364,13 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
2290
2364
  maxPriorityFeePerGas?: undefined | undefined | undefined;
2291
2365
  accessList: import('viem').AccessList;
2292
2366
  authorizationList?: undefined | undefined | undefined;
2367
+ yParity: number;
2293
2368
  hash: import('viem').Hash;
2294
2369
  input: import('viem').Hex;
2370
+ r: import('viem').Hex;
2371
+ s: import('viem').Hex;
2295
2372
  typeHex: import('viem').Hex | null;
2373
+ v: bigint;
2296
2374
  isSystemTx?: undefined | undefined | undefined;
2297
2375
  mint?: undefined | undefined | undefined;
2298
2376
  sourceHash?: undefined | undefined | undefined;
@@ -2302,15 +2380,11 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
2302
2380
  } | {
2303
2381
  type: "eip1559";
2304
2382
  chainId: 130;
2383
+ to: import('viem').Address | null;
2305
2384
  from: import('viem').Address;
2306
2385
  gas: bigint;
2307
2386
  nonce: number;
2308
- to: import('viem').Address | null;
2309
2387
  value: bigint;
2310
- r: import('viem').Hex;
2311
- s: import('viem').Hex;
2312
- v: bigint;
2313
- yParity: number;
2314
2388
  blobVersionedHashes?: undefined | undefined | undefined;
2315
2389
  gasPrice?: undefined | undefined | undefined;
2316
2390
  maxFeePerBlobGas?: undefined | undefined | undefined;
@@ -2318,9 +2392,13 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
2318
2392
  maxPriorityFeePerGas: bigint;
2319
2393
  accessList: import('viem').AccessList;
2320
2394
  authorizationList?: undefined | undefined | undefined;
2395
+ yParity: number;
2321
2396
  hash: import('viem').Hash;
2322
2397
  input: import('viem').Hex;
2398
+ r: import('viem').Hex;
2399
+ s: import('viem').Hex;
2323
2400
  typeHex: import('viem').Hex | null;
2401
+ v: bigint;
2324
2402
  isSystemTx?: undefined | undefined | undefined;
2325
2403
  mint?: undefined | undefined | undefined;
2326
2404
  sourceHash?: undefined | undefined | undefined;
@@ -2330,15 +2408,11 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
2330
2408
  } | {
2331
2409
  type: "eip4844";
2332
2410
  chainId: 130;
2411
+ to: import('viem').Address | null;
2333
2412
  from: import('viem').Address;
2334
2413
  gas: bigint;
2335
2414
  nonce: number;
2336
- to: import('viem').Address | null;
2337
2415
  value: bigint;
2338
- r: import('viem').Hex;
2339
- s: import('viem').Hex;
2340
- v: bigint;
2341
- yParity: number;
2342
2416
  blobVersionedHashes: readonly import('viem').Hex[];
2343
2417
  gasPrice?: undefined | undefined | undefined;
2344
2418
  maxFeePerBlobGas: bigint;
@@ -2346,9 +2420,13 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
2346
2420
  maxPriorityFeePerGas: bigint;
2347
2421
  accessList: import('viem').AccessList;
2348
2422
  authorizationList?: undefined | undefined | undefined;
2423
+ yParity: number;
2349
2424
  hash: import('viem').Hash;
2350
2425
  input: import('viem').Hex;
2426
+ r: import('viem').Hex;
2427
+ s: import('viem').Hex;
2351
2428
  typeHex: import('viem').Hex | null;
2429
+ v: bigint;
2352
2430
  isSystemTx?: undefined | undefined | undefined;
2353
2431
  mint?: undefined | undefined | undefined;
2354
2432
  sourceHash?: undefined | undefined | undefined;
@@ -2358,15 +2436,11 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
2358
2436
  } | {
2359
2437
  type: "eip7702";
2360
2438
  chainId: 130;
2439
+ to: import('viem').Address | null;
2361
2440
  from: import('viem').Address;
2362
2441
  gas: bigint;
2363
2442
  nonce: number;
2364
- to: import('viem').Address | null;
2365
2443
  value: bigint;
2366
- r: import('viem').Hex;
2367
- s: import('viem').Hex;
2368
- v: bigint;
2369
- yParity: number;
2370
2444
  blobVersionedHashes?: undefined | undefined | undefined;
2371
2445
  gasPrice?: undefined | undefined | undefined;
2372
2446
  maxFeePerBlobGas?: undefined | undefined | undefined;
@@ -2374,9 +2448,13 @@ export declare function useTxResponse({ hash, chainId, enabled, }: UseTxResponse
2374
2448
  maxPriorityFeePerGas: bigint;
2375
2449
  accessList: import('viem').AccessList;
2376
2450
  authorizationList: import('viem').SignedAuthorizationList;
2451
+ yParity: number;
2377
2452
  hash: import('viem').Hash;
2378
2453
  input: import('viem').Hex;
2454
+ r: import('viem').Hex;
2455
+ s: import('viem').Hex;
2379
2456
  typeHex: import('viem').Hex | null;
2457
+ v: bigint;
2380
2458
  isSystemTx?: undefined | undefined | undefined;
2381
2459
  mint?: undefined | undefined | undefined;
2382
2460
  sourceHash?: undefined | undefined | undefined;