@openfort/react 0.0.32 → 0.0.34

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 (10) hide show
  1. package/build/components/Openfort/context.d.ts +0 -2
  2. package/build/components/Openfort/types.d.ts +0 -2
  3. package/build/hooks/openfort/useExtendedWalletClient.d.ts +389 -0
  4. package/build/hooks/openfort/useGrantPermissions.d.ts +107 -0
  5. package/build/hooks/useEnsFallbackConfig.d.ts +1 -42
  6. package/build/index.d.ts +1 -0
  7. package/build/index.es.js +405 -271
  8. package/build/index.es.js.map +1 -1
  9. package/build/version.d.ts +1 -1
  10. package/package.json +1 -1
package/build/components/Openfort/context.d.ts CHANGED
@@ -27,8 +27,6 @@ export type ContextValue = {
27
27
  setConnector: React.Dispatch<React.SetStateAction<Connector>>;
28
28
  errorMessage: ErrorMessage;
29
29
  debugMode?: boolean;
30
- log: (...props: any) => void;
31
- displayError: (message: string | React.ReactNode | null, code?: any) => void;
32
30
  resize: number;
33
31
  triggerResize: () => void;
34
32
  uiConfig: OpenfortUIOptionsExtended;
package/build/components/Openfort/types.d.ts CHANGED
@@ -91,7 +91,6 @@ export type ConnectUIOptions = {
91
91
  /** Buffer polyfill, needed for bundlers that do not provide Node polyfills (e.g. CRA, Vite, etc.). */
92
92
  bufferPolyfill?: boolean;
93
93
  customAvatar?: React.FC<CustomAvatarProps>;
94
- initialChainId?: number;
95
94
  enforceSupportedChains?: boolean;
96
95
  /** Blur intensity applied to the background when the modal is open. */
97
96
  overlayBlur?: number;
@@ -123,7 +122,6 @@ export type OpenfortUIOptionsExtended = {
123
122
  /** Buffer polyfill, needed for bundlers that do not provide Node polyfills (e.g. CRA, Vite, etc.). */
124
123
  bufferPolyfill?: boolean;
125
124
  customAvatar?: React.FC<CustomAvatarProps>;
126
- initialChainId?: number;
127
125
  enforceSupportedChains?: boolean;
128
126
  ethereumOnboardingUrl?: string;
129
127
  walletOnboardingUrl?: string;
package/build/hooks/openfort/useExtendedWalletClient.d.ts ADDED
@@ -0,0 +1,389 @@
1
+ export declare function useExtendedWalletClient(): import("viem").Client<import("viem").CustomTransport, import("viem").Chain, {
2
+ client: import("viem").Client<import("viem").Transport, import("viem").Chain | undefined, {
3
+ address: import("viem").Address;
4
+ nonceManager?: import("viem").NonceManager | undefined;
5
+ sign?: ((parameters: {
6
+ hash: import("viem").Hash;
7
+ }) => Promise<import("viem").Hex>) | undefined | undefined;
8
+ signAuthorization?: ((parameters: import("viem").AuthorizationRequest) => Promise<import("viem/accounts").SignAuthorizationReturnType>) | undefined | undefined;
9
+ signMessage: ({ message }: {
10
+ message: import("viem").SignableMessage;
11
+ }) => Promise<import("viem").Hex>;
12
+ signTransaction: <serializer extends import("viem").SerializeTransactionFn<import("viem").TransactionSerializable> = import("viem").SerializeTransactionFn<import("viem").TransactionSerializable>, transaction extends Parameters<serializer>[0] = Parameters<serializer>[0]>(transaction: transaction, options?: {
13
+ serializer?: serializer | undefined;
14
+ } | undefined) => Promise<import("viem").Hex>;
15
+ signTypedData: <const typedData extends import("viem").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: import("viem").TypedDataDefinition<typedData, primaryType>) => Promise<import("viem").Hex>;
16
+ publicKey: import("viem").Hex;
17
+ source: string;
18
+ type: "local";
19
+ } | import("viem").JsonRpcAccount | undefined>;
20
+ entryPoint: {
21
+ abi: import("viem").Abi;
22
+ address: import("viem").Address;
23
+ version: import("viem/_types/account-abstraction").EntryPointVersion;
24
+ };
25
+ extend?: object | undefined;
26
+ getAddress: () => Promise<import("viem").Address>;
27
+ decodeCalls?: ((data: import("viem").Hex) => Promise<readonly {
28
+ to: import("viem").Hex;
29
+ data?: import("viem").Hex | undefined;
30
+ value?: bigint | undefined;
31
+ }[]>) | undefined | undefined;
32
+ encodeCalls: (calls: readonly {
33
+ to: import("viem").Hex;
34
+ data?: import("viem").Hex | undefined;
35
+ value?: bigint | undefined;
36
+ }[]) => Promise<import("viem").Hex>;
37
+ getFactoryArgs: () => Promise<{
38
+ factory?: import("viem").Address | undefined;
39
+ factoryData?: import("viem").Hex | undefined;
40
+ }>;
41
+ getNonce: (parameters?: {
42
+ key?: bigint | undefined;
43
+ } | undefined) => Promise<bigint>;
44
+ getStubSignature: (parameters?: import("viem/_types/account-abstraction").UserOperationRequest | undefined) => Promise<import("viem").Hex>;
45
+ nonceKeyManager?: import("viem").NonceManager | undefined;
46
+ sign?: ((parameters: {
47
+ hash: import("viem").Hash;
48
+ }) => Promise<import("viem").Hex>) | undefined | undefined;
49
+ signMessage: (parameters: {
50
+ message: import("viem").SignableMessage;
51
+ }) => Promise<import("viem").Hex>;
52
+ signTypedData: <const typedData extends import("viem").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: import("viem").TypedDataDefinition<typedData, primaryType>) => Promise<import("viem").Hex>;
53
+ signUserOperation: (parameters: import("viem").UnionPartialBy<import("viem/_types/account-abstraction").UserOperation, "sender"> & {
54
+ chainId?: number | undefined;
55
+ }) => Promise<import("viem").Hex>;
56
+ userOperation?: {
57
+ estimateGas?: ((userOperation: import("viem/_types/account-abstraction").UserOperationRequest) => Promise<import("viem").ExactPartial<import("viem/_types/account-abstraction/types/userOperation").EstimateUserOperationGasReturnType> | undefined>) | undefined;
58
+ } | undefined | undefined;
59
+ authorization?: undefined | undefined;
60
+ address: import("viem").Address;
61
+ isDeployed: () => Promise<boolean>;
62
+ type: "smart";
63
+ nonceManager?: undefined;
64
+ signAuthorization?: undefined;
65
+ signTransaction?: undefined;
66
+ publicKey?: undefined;
67
+ source?: undefined;
68
+ } | {
69
+ client: import("viem").Client<import("viem").Transport, import("viem").Chain | undefined, {
70
+ address: import("viem").Address;
71
+ nonceManager?: import("viem").NonceManager | undefined;
72
+ sign?: ((parameters: {
73
+ hash: import("viem").Hash;
74
+ }) => Promise<import("viem").Hex>) | undefined | undefined;
75
+ signAuthorization?: ((parameters: import("viem").AuthorizationRequest) => Promise<import("viem/accounts").SignAuthorizationReturnType>) | undefined | undefined;
76
+ signMessage: ({ message }: {
77
+ message: import("viem").SignableMessage;
78
+ }) => Promise<import("viem").Hex>;
79
+ signTransaction: <serializer extends import("viem").SerializeTransactionFn<import("viem").TransactionSerializable> = import("viem").SerializeTransactionFn<import("viem").TransactionSerializable>, transaction extends Parameters<serializer>[0] = Parameters<serializer>[0]>(transaction: transaction, options?: {
80
+ serializer?: serializer | undefined;
81
+ } | undefined) => Promise<import("viem").Hex>;
82
+ signTypedData: <const typedData extends import("viem").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: import("viem").TypedDataDefinition<typedData, primaryType>) => Promise<import("viem").Hex>;
83
+ publicKey: import("viem").Hex;
84
+ source: string;
85
+ type: "local";
86
+ } | import("viem").JsonRpcAccount | undefined>;
87
+ entryPoint: {
88
+ abi: import("viem").Abi;
89
+ address: import("viem").Address;
90
+ version: import("viem/_types/account-abstraction").EntryPointVersion;
91
+ };
92
+ extend?: object | undefined;
93
+ getAddress: () => Promise<import("viem").Address>;
94
+ decodeCalls?: ((data: import("viem").Hex) => Promise<readonly {
95
+ to: import("viem").Hex;
96
+ data?: import("viem").Hex | undefined;
97
+ value?: bigint | undefined;
98
+ }[]>) | undefined | undefined;
99
+ encodeCalls: (calls: readonly {
100
+ to: import("viem").Hex;
101
+ data?: import("viem").Hex | undefined;
102
+ value?: bigint | undefined;
103
+ }[]) => Promise<import("viem").Hex>;
104
+ getFactoryArgs: () => Promise<{
105
+ factory?: import("viem").Address | undefined;
106
+ factoryData?: import("viem").Hex | undefined;
107
+ }>;
108
+ getNonce: (parameters?: {
109
+ key?: bigint | undefined;
110
+ } | undefined) => Promise<bigint>;
111
+ getStubSignature: (parameters?: import("viem/_types/account-abstraction").UserOperationRequest | undefined) => Promise<import("viem").Hex>;
112
+ nonceKeyManager?: import("viem").NonceManager | undefined;
113
+ sign?: ((parameters: {
114
+ hash: import("viem").Hash;
115
+ }) => Promise<import("viem").Hex>) | undefined | undefined;
116
+ signMessage: (parameters: {
117
+ message: import("viem").SignableMessage;
118
+ }) => Promise<import("viem").Hex>;
119
+ signTypedData: <const typedData extends import("viem").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: import("viem").TypedDataDefinition<typedData, primaryType>) => Promise<import("viem").Hex>;
120
+ signUserOperation: (parameters: import("viem").UnionPartialBy<import("viem/_types/account-abstraction").UserOperation, "sender"> & {
121
+ chainId?: number | undefined;
122
+ }) => Promise<import("viem").Hex>;
123
+ userOperation?: {
124
+ estimateGas?: ((userOperation: import("viem/_types/account-abstraction").UserOperationRequest) => Promise<import("viem").ExactPartial<import("viem/_types/account-abstraction/types/userOperation").EstimateUserOperationGasReturnType> | undefined>) | undefined;
125
+ } | undefined | undefined;
126
+ authorization: {
127
+ account: import("viem").PrivateKeyAccount;
128
+ address: import("viem").Address;
129
+ };
130
+ address: import("viem").Address;
131
+ isDeployed: () => Promise<boolean>;
132
+ type: "smart";
133
+ nonceManager?: undefined;
134
+ signAuthorization?: undefined;
135
+ signTransaction?: undefined;
136
+ publicKey?: undefined;
137
+ source?: undefined;
138
+ } | {
139
+ address: `0x${string}`;
140
+ type: "json-rpc";
141
+ extend?: undefined;
142
+ nonceManager?: undefined;
143
+ sign?: undefined;
144
+ signAuthorization?: undefined;
145
+ signMessage?: undefined;
146
+ signTransaction?: undefined;
147
+ signTypedData?: undefined;
148
+ publicKey?: undefined;
149
+ source?: undefined;
150
+ client?: undefined;
151
+ entryPoint?: undefined;
152
+ getAddress?: undefined;
153
+ decodeCalls?: undefined;
154
+ encodeCalls?: undefined;
155
+ getFactoryArgs?: undefined;
156
+ getNonce?: undefined;
157
+ getStubSignature?: undefined;
158
+ nonceKeyManager?: undefined;
159
+ signUserOperation?: undefined;
160
+ userOperation?: undefined;
161
+ authorization?: undefined;
162
+ isDeployed?: undefined;
163
+ } | {
164
+ address: import("viem").Address;
165
+ nonceManager?: import("viem").NonceManager | undefined;
166
+ sign?: ((parameters: {
167
+ hash: import("viem").Hash;
168
+ }) => Promise<import("viem").Hex>) | undefined | undefined;
169
+ signAuthorization?: ((parameters: import("viem").AuthorizationRequest) => Promise<import("viem/accounts").SignAuthorizationReturnType>) | undefined | undefined;
170
+ signMessage: ({ message }: {
171
+ message: import("viem").SignableMessage;
172
+ }) => Promise<import("viem").Hex>;
173
+ signTransaction: <serializer extends import("viem").SerializeTransactionFn<import("viem").TransactionSerializable> = import("viem").SerializeTransactionFn<import("viem").TransactionSerializable>, transaction extends Parameters<serializer>[0] = Parameters<serializer>[0]>(transaction: transaction, options?: {
174
+ serializer?: serializer | undefined;
175
+ } | undefined) => Promise<import("viem").Hex>;
176
+ signTypedData: <const typedData extends import("viem").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: import("viem").TypedDataDefinition<typedData, primaryType>) => Promise<import("viem").Hex>;
177
+ publicKey: import("viem").Hex;
178
+ source: string;
179
+ type: "local";
180
+ extend?: undefined;
181
+ client?: undefined;
182
+ entryPoint?: undefined;
183
+ getAddress?: undefined;
184
+ decodeCalls?: undefined;
185
+ encodeCalls?: undefined;
186
+ getFactoryArgs?: undefined;
187
+ getNonce?: undefined;
188
+ getStubSignature?: undefined;
189
+ nonceKeyManager?: undefined;
190
+ signUserOperation?: undefined;
191
+ userOperation?: undefined;
192
+ authorization?: undefined;
193
+ isDeployed?: undefined;
194
+ }, import("viem").WalletRpcSchema, {
195
+ grantPermissions: (parameters: import("viem/experimental").GrantPermissionsParameters) => Promise<import("viem/experimental").GrantPermissionsReturnType>;
196
+ } & import("viem").WalletActions<import("viem").Chain, {
197
+ client: import("viem").Client<import("viem").Transport, import("viem").Chain | undefined, {
198
+ address: import("viem").Address;
199
+ nonceManager?: import("viem").NonceManager | undefined;
200
+ sign?: ((parameters: {
201
+ hash: import("viem").Hash;
202
+ }) => Promise<import("viem").Hex>) | undefined | undefined;
203
+ signAuthorization?: ((parameters: import("viem").AuthorizationRequest) => Promise<import("viem/accounts").SignAuthorizationReturnType>) | undefined | undefined;
204
+ signMessage: ({ message }: {
205
+ message: import("viem").SignableMessage;
206
+ }) => Promise<import("viem").Hex>;
207
+ signTransaction: <serializer extends import("viem").SerializeTransactionFn<import("viem").TransactionSerializable> = import("viem").SerializeTransactionFn<import("viem").TransactionSerializable>, transaction extends Parameters<serializer>[0] = Parameters<serializer>[0]>(transaction: transaction, options?: {
208
+ serializer?: serializer | undefined;
209
+ } | undefined) => Promise<import("viem").Hex>;
210
+ signTypedData: <const typedData extends import("viem").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: import("viem").TypedDataDefinition<typedData, primaryType>) => Promise<import("viem").Hex>;
211
+ publicKey: import("viem").Hex;
212
+ source: string;
213
+ type: "local";
214
+ } | import("viem").JsonRpcAccount | undefined>;
215
+ entryPoint: {
216
+ abi: import("viem").Abi;
217
+ address: import("viem").Address;
218
+ version: import("viem/_types/account-abstraction").EntryPointVersion;
219
+ };
220
+ extend?: object | undefined;
221
+ getAddress: () => Promise<import("viem").Address>;
222
+ decodeCalls?: ((data: import("viem").Hex) => Promise<readonly {
223
+ to: import("viem").Hex;
224
+ data?: import("viem").Hex | undefined;
225
+ value?: bigint | undefined;
226
+ }[]>) | undefined | undefined;
227
+ encodeCalls: (calls: readonly {
228
+ to: import("viem").Hex;
229
+ data?: import("viem").Hex | undefined;
230
+ value?: bigint | undefined;
231
+ }[]) => Promise<import("viem").Hex>;
232
+ getFactoryArgs: () => Promise<{
233
+ factory?: import("viem").Address | undefined;
234
+ factoryData?: import("viem").Hex | undefined;
235
+ }>;
236
+ getNonce: (parameters?: {
237
+ key?: bigint | undefined;
238
+ } | undefined) => Promise<bigint>;
239
+ getStubSignature: (parameters?: import("viem/_types/account-abstraction").UserOperationRequest | undefined) => Promise<import("viem").Hex>;
240
+ nonceKeyManager?: import("viem").NonceManager | undefined;
241
+ sign?: ((parameters: {
242
+ hash: import("viem").Hash;
243
+ }) => Promise<import("viem").Hex>) | undefined | undefined;
244
+ signMessage: (parameters: {
245
+ message: import("viem").SignableMessage;
246
+ }) => Promise<import("viem").Hex>;
247
+ signTypedData: <const typedData extends import("viem").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: import("viem").TypedDataDefinition<typedData, primaryType>) => Promise<import("viem").Hex>;
248
+ signUserOperation: (parameters: import("viem").UnionPartialBy<import("viem/_types/account-abstraction").UserOperation, "sender"> & {
249
+ chainId?: number | undefined;
250
+ }) => Promise<import("viem").Hex>;
251
+ userOperation?: {
252
+ estimateGas?: ((userOperation: import("viem/_types/account-abstraction").UserOperationRequest) => Promise<import("viem").ExactPartial<import("viem/_types/account-abstraction/types/userOperation").EstimateUserOperationGasReturnType> | undefined>) | undefined;
253
+ } | undefined | undefined;
254
+ authorization?: undefined | undefined;
255
+ address: import("viem").Address;
256
+ isDeployed: () => Promise<boolean>;
257
+ type: "smart";
258
+ nonceManager?: undefined;
259
+ signAuthorization?: undefined;
260
+ signTransaction?: undefined;
261
+ publicKey?: undefined;
262
+ source?: undefined;
263
+ } | {
264
+ client: import("viem").Client<import("viem").Transport, import("viem").Chain | undefined, {
265
+ address: import("viem").Address;
266
+ nonceManager?: import("viem").NonceManager | undefined;
267
+ sign?: ((parameters: {
268
+ hash: import("viem").Hash;
269
+ }) => Promise<import("viem").Hex>) | undefined | undefined;
270
+ signAuthorization?: ((parameters: import("viem").AuthorizationRequest) => Promise<import("viem/accounts").SignAuthorizationReturnType>) | undefined | undefined;
271
+ signMessage: ({ message }: {
272
+ message: import("viem").SignableMessage;
273
+ }) => Promise<import("viem").Hex>;
274
+ signTransaction: <serializer extends import("viem").SerializeTransactionFn<import("viem").TransactionSerializable> = import("viem").SerializeTransactionFn<import("viem").TransactionSerializable>, transaction extends Parameters<serializer>[0] = Parameters<serializer>[0]>(transaction: transaction, options?: {
275
+ serializer?: serializer | undefined;
276
+ } | undefined) => Promise<import("viem").Hex>;
277
+ signTypedData: <const typedData extends import("viem").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: import("viem").TypedDataDefinition<typedData, primaryType>) => Promise<import("viem").Hex>;
278
+ publicKey: import("viem").Hex;
279
+ source: string;
280
+ type: "local";
281
+ } | import("viem").JsonRpcAccount | undefined>;
282
+ entryPoint: {
283
+ abi: import("viem").Abi;
284
+ address: import("viem").Address;
285
+ version: import("viem/_types/account-abstraction").EntryPointVersion;
286
+ };
287
+ extend?: object | undefined;
288
+ getAddress: () => Promise<import("viem").Address>;
289
+ decodeCalls?: ((data: import("viem").Hex) => Promise<readonly {
290
+ to: import("viem").Hex;
291
+ data?: import("viem").Hex | undefined;
292
+ value?: bigint | undefined;
293
+ }[]>) | undefined | undefined;
294
+ encodeCalls: (calls: readonly {
295
+ to: import("viem").Hex;
296
+ data?: import("viem").Hex | undefined;
297
+ value?: bigint | undefined;
298
+ }[]) => Promise<import("viem").Hex>;
299
+ getFactoryArgs: () => Promise<{
300
+ factory?: import("viem").Address | undefined;
301
+ factoryData?: import("viem").Hex | undefined;
302
+ }>;
303
+ getNonce: (parameters?: {
304
+ key?: bigint | undefined;
305
+ } | undefined) => Promise<bigint>;
306
+ getStubSignature: (parameters?: import("viem/_types/account-abstraction").UserOperationRequest | undefined) => Promise<import("viem").Hex>;
307
+ nonceKeyManager?: import("viem").NonceManager | undefined;
308
+ sign?: ((parameters: {
309
+ hash: import("viem").Hash;
310
+ }) => Promise<import("viem").Hex>) | undefined | undefined;
311
+ signMessage: (parameters: {
312
+ message: import("viem").SignableMessage;
313
+ }) => Promise<import("viem").Hex>;
314
+ signTypedData: <const typedData extends import("viem").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: import("viem").TypedDataDefinition<typedData, primaryType>) => Promise<import("viem").Hex>;
315
+ signUserOperation: (parameters: import("viem").UnionPartialBy<import("viem/_types/account-abstraction").UserOperation, "sender"> & {
316
+ chainId?: number | undefined;
317
+ }) => Promise<import("viem").Hex>;
318
+ userOperation?: {
319
+ estimateGas?: ((userOperation: import("viem/_types/account-abstraction").UserOperationRequest) => Promise<import("viem").ExactPartial<import("viem/_types/account-abstraction/types/userOperation").EstimateUserOperationGasReturnType> | undefined>) | undefined;
320
+ } | undefined | undefined;
321
+ authorization: {
322
+ account: import("viem").PrivateKeyAccount;
323
+ address: import("viem").Address;
324
+ };
325
+ address: import("viem").Address;
326
+ isDeployed: () => Promise<boolean>;
327
+ type: "smart";
328
+ nonceManager?: undefined;
329
+ signAuthorization?: undefined;
330
+ signTransaction?: undefined;
331
+ publicKey?: undefined;
332
+ source?: undefined;
333
+ } | {
334
+ address: `0x${string}`;
335
+ type: "json-rpc";
336
+ extend?: undefined;
337
+ nonceManager?: undefined;
338
+ sign?: undefined;
339
+ signAuthorization?: undefined;
340
+ signMessage?: undefined;
341
+ signTransaction?: undefined;
342
+ signTypedData?: undefined;
343
+ publicKey?: undefined;
344
+ source?: undefined;
345
+ client?: undefined;
346
+ entryPoint?: undefined;
347
+ getAddress?: undefined;
348
+ decodeCalls?: undefined;
349
+ encodeCalls?: undefined;
350
+ getFactoryArgs?: undefined;
351
+ getNonce?: undefined;
352
+ getStubSignature?: undefined;
353
+ nonceKeyManager?: undefined;
354
+ signUserOperation?: undefined;
355
+ userOperation?: undefined;
356
+ authorization?: undefined;
357
+ isDeployed?: undefined;
358
+ } | {
359
+ address: import("viem").Address;
360
+ nonceManager?: import("viem").NonceManager | undefined;
361
+ sign?: ((parameters: {
362
+ hash: import("viem").Hash;
363
+ }) => Promise<import("viem").Hex>) | undefined | undefined;
364
+ signAuthorization?: ((parameters: import("viem").AuthorizationRequest) => Promise<import("viem/accounts").SignAuthorizationReturnType>) | undefined | undefined;
365
+ signMessage: ({ message }: {
366
+ message: import("viem").SignableMessage;
367
+ }) => Promise<import("viem").Hex>;
368
+ signTransaction: <serializer extends import("viem").SerializeTransactionFn<import("viem").TransactionSerializable> = import("viem").SerializeTransactionFn<import("viem").TransactionSerializable>, transaction extends Parameters<serializer>[0] = Parameters<serializer>[0]>(transaction: transaction, options?: {
369
+ serializer?: serializer | undefined;
370
+ } | undefined) => Promise<import("viem").Hex>;
371
+ signTypedData: <const typedData extends import("viem").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: import("viem").TypedDataDefinition<typedData, primaryType>) => Promise<import("viem").Hex>;
372
+ publicKey: import("viem").Hex;
373
+ source: string;
374
+ type: "local";
375
+ extend?: undefined;
376
+ client?: undefined;
377
+ entryPoint?: undefined;
378
+ getAddress?: undefined;
379
+ decodeCalls?: undefined;
380
+ encodeCalls?: undefined;
381
+ getFactoryArgs?: undefined;
382
+ getNonce?: undefined;
383
+ getStubSignature?: undefined;
384
+ nonceKeyManager?: undefined;
385
+ signUserOperation?: undefined;
386
+ userOperation?: undefined;
387
+ authorization?: undefined;
388
+ isDeployed?: undefined;
389
+ }>> | undefined;
package/build/hooks/openfort/useGrantPermissions.d.ts ADDED
@@ -0,0 +1,107 @@
1
+ import type { Hex } from 'viem';
2
+ import type { GrantPermissionsParameters, GrantPermissionsReturnType } from 'viem/experimental';
3
+ import { OpenfortError, type OpenfortHookOptions } from '../../types';
4
+ type GrantPermissionsRequest = {
5
+ request: GrantPermissionsParameters;
6
+ sessionKey: Hex;
7
+ };
8
+ type GrantPermissionsResult = {
9
+ address: `0x${string}`;
10
+ privateKey: `0x${string}`;
11
+ } & GrantPermissionsReturnType;
12
+ type GrantPermissionsHookResult = {
13
+ error?: OpenfortError;
14
+ } & Partial<GrantPermissionsResult>;
15
+ type GrantPermissionsHookOptions = OpenfortHookOptions<GrantPermissionsHookResult>;
16
+ /**
17
+ * Hook for granting permissions to session keys (EIP-7715)
18
+ *
19
+ * This hook manages the creation and authorization of session keys, allowing users to
20
+ * delegate permissions to specific accounts for a limited time. This enables use cases
21
+ * like session-based authentication and gasless transactions within defined scopes.
22
+ * The hook leverages EIP-7715 for permission granting.
23
+ *
24
+ * @param hookOptions - Optional configuration with callback functions
25
+ * @returns Current grant permissions state and actions
26
+ *
27
+ * @example
28
+ * ```tsx
29
+ * import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
30
+ * import { useGrantPermissions } from '@openfort/openfort-react';
31
+ *
32
+ * const { grantPermissions, isLoading, isError, error } = useGrantPermissions({
33
+ * onSuccess: (result) => console.log('Permissions granted:', result),
34
+ * onError: (error) => console.error('Permission grant failed:', error),
35
+ * });
36
+ *
37
+ * // Grant permissions to a session key
38
+ * const handleGrantPermissions = async () => {
39
+ * try {
40
+ * // Generate a new session key
41
+ * const sessionKey = generatePrivateKey();
42
+ * const accountSession = privateKeyToAccount(sessionKey).address;
43
+ *
44
+ * const result = await grantPermissions({
45
+ * sessionKey,
46
+ * request: {
47
+ * signer: {
48
+ * type: 'account',
49
+ * data: {
50
+ * id: accountSession,
51
+ * },
52
+ * },
53
+ * expiry: 60 * 60 * 24, // 24 hours
54
+ * permissions: [
55
+ * {
56
+ * type: 'contract-call',
57
+ * data: {
58
+ * address: '0x2522f4fc9af2e1954a3d13f7a5b2683a00a4543a',
59
+ * },
60
+ * },
61
+ * ],
62
+ * },
63
+ * });
64
+ *
65
+ * if (result.address) {
66
+ * console.log('Session created with address:', result.address);
67
+ * console.log('Session private key:', result.privateKey);
68
+ * }
69
+ * } catch (error) {
70
+ * console.error('Failed to grant permissions:', error);
71
+ * }
72
+ * };
73
+ *
74
+ * // Check permission grant state
75
+ * if (isLoading) {
76
+ * console.log('Granting permissions...');
77
+ * } else if (isError) {
78
+ * console.error('Permission grant error:', error);
79
+ * }
80
+ *
81
+ * // Example usage in component
82
+ * return (
83
+ * <div>
84
+ * <button
85
+ * onClick={handleGrantPermissions}
86
+ * disabled={isLoading}
87
+ * >
88
+ * {isLoading ? 'Granting Permissions...' : 'Create Session'}
89
+ * </button>
90
+ *
91
+ * {isError && (
92
+ * <p>Error: {error?.message}</p>
93
+ * )}
94
+ * </div>
95
+ * );
96
+ * ```
97
+ */
98
+ export declare const useGrantPermissions: (hookOptions?: GrantPermissionsHookOptions) => {
99
+ isLoading: boolean;
100
+ isError: boolean;
101
+ isSuccess: boolean;
102
+ error: OpenfortError | null | undefined;
103
+ grantPermissions: ({ request, sessionKey }: GrantPermissionsRequest, options?: GrantPermissionsHookOptions) => Promise<GrantPermissionsHookResult>;
104
+ data: GrantPermissionsResult | null;
105
+ reset: () => void;
106
+ };
107
+ export {};
package/build/hooks/useEnsFallbackConfig.d.ts CHANGED
@@ -1,42 +1 @@
1
- export declare function useEnsFallbackConfig(): import("wagmi").Config<readonly [{
2
- blockExplorers: {
3
- readonly default: {
4
- readonly name: "Etherscan";
5
- readonly url: "https://etherscan.io";
6
- readonly apiUrl: "https://api.etherscan.io/api";
7
- };
8
- };
9
- blockTime: 12000;
10
- contracts: {
11
- readonly ensUniversalResolver: {
12
- readonly address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
13
- readonly blockCreated: 23085558;
14
- };
15
- readonly multicall3: {
16
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
17
- readonly blockCreated: 14353601;
18
- };
19
- };
20
- ensTlds?: readonly string[] | undefined;
21
- id: 1;
22
- name: "Ethereum";
23
- nativeCurrency: {
24
- readonly name: "Ether";
25
- readonly symbol: "ETH";
26
- readonly decimals: 18;
27
- };
28
- experimental_preconfirmationTime?: number | undefined | undefined;
29
- rpcUrls: {
30
- readonly default: {
31
- readonly http: readonly ["https://eth.merkle.io"];
32
- };
33
- };
34
- sourceId?: number | undefined | undefined;
35
- testnet?: boolean | undefined | undefined;
36
- custom?: Record<string, unknown> | undefined;
37
- fees?: import("viem").ChainFees<undefined> | undefined;
38
- formatters?: undefined;
39
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
40
- }], {
41
- 1: import("viem").HttpTransport<undefined, false>;
42
- }, readonly import("wagmi").CreateConnectorFn[]> | undefined;
1
+ export declare function useEnsFallbackConfig(): undefined;
package/build/index.d.ts CHANGED
@@ -15,6 +15,7 @@ export { useSignOut } from './hooks/openfort/auth/useSignOut';
15
15
  export { useWalletAuth } from './hooks/openfort/auth/useWalletAuth';
16
16
  export { type SignAuthorizationParameters, type SignAuthorizationReturnType, use7702Authorization, } from './hooks/openfort/use7702Authorization';
17
17
  export { useConnectWithSiwe } from './hooks/openfort/useConnectWithSiwe';
18
+ export { useGrantPermissions } from './hooks/openfort/useGrantPermissions';
18
19
  export { useUI } from './hooks/openfort/useUI';
19
20
  export { useUser } from './hooks/openfort/useUser';
20
21
  export { UserWallet, useWallets } from './hooks/openfort/useWallets';