@imtbl/passport 2.0.0-alpha.0

package/dist/types/starkEx/workflows/transfer.d.ts

@@ -0,0 +1,21 @@
+import { imx } from '@imtbl/generated-clients';
+import { StarkSigner, NftTransferDetails, UnsignedTransferRequest } from '@imtbl/x-client';
+import { UserImx } from '../../types';
+import GuardianClient from '../../guardian';
+type TransferRequest = {
+    request: UnsignedTransferRequest;
+    user: UserImx;
+    starkSigner: StarkSigner;
+    transfersApi: imx.TransfersApi;
+    guardianClient: GuardianClient;
+};
+type BatchTransfersParams = {
+    request: Array<NftTransferDetails>;
+    user: UserImx;
+    starkSigner: StarkSigner;
+    transfersApi: imx.TransfersApi;
+    guardianClient: GuardianClient;
+};
+export declare function transfer({ request, transfersApi, starkSigner, user, guardianClient, }: TransferRequest): Promise<imx.CreateTransferResponseV1>;
+export declare function batchNftTransfer({ user, starkSigner, request, transfersApi, guardianClient, }: BatchTransfersParams): Promise<imx.CreateTransferResponse>;
+export {};

package/dist/types/starkEx/workflows/transfer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/storage/LocalForageAsyncStorage.d.ts

@@ -0,0 +1,11 @@
+import { AsyncStorage } from 'oidc-client-ts';
+export declare class LocalForageAsyncStorage implements AsyncStorage {
+    private storage;
+    constructor(name: string, driver: string | string[]);
+    get length(): Promise<number>;
+    clear(): Promise<void>;
+    getItem(key: string): Promise<string | null>;
+    key(index: number): Promise<string | null>;
+    removeItem(key: string): Promise<void>;
+    setItem(key: string, value: string): Promise<void>;
+}

package/dist/types/storage/device_credentials_manager.d.ts

@@ -0,0 +1,7 @@
+import { DeviceTokenResponse, PKCEData } from '../types';
+export default class DeviceCredentialsManager {
+    areValid(tokenResponse: DeviceTokenResponse): boolean;
+    private isTokenValid;
+    savePKCEData(data: PKCEData): void;
+    getPKCEData(): PKCEData | null;
+}

package/dist/types/test/mocks.d.ts

@@ -0,0 +1,56 @@
+import { User, UserImx, UserZkEvm } from '../types';
+import { PassportConfiguration } from '../config';
+import { ChainId } from '../network/chains';
+export declare const mockErrorMessage = "Server is down";
+export declare const mockStarkSignature = "starkSignature";
+export declare const chainId = ChainId.IMTBL_ZKEVM_TESTNET;
+export declare const chainIdHex = "0x34a1";
+export declare const chainIdEip155 = "eip155:13473";
+export declare const testConfig: PassportConfiguration;
+export declare const mockUser: User;
+export declare const mockUserImx: UserImx;
+export declare const mockUserZkEvm: UserZkEvm;
+export declare const mockLinkedAddresses: {
+    data: {
+        sub: string;
+        linked_addresses: string[];
+    };
+};
+export declare const mockListChains: {
+    data: {
+        result: {
+            id: string;
+            name: string;
+            rpc_url: string;
+        }[];
+    };
+};
+export declare const mockLinkedWallet: {
+    data: {
+        address: string;
+        type: string;
+        created_at: string;
+        updated_at: string;
+        name: string;
+        clientName: string;
+    };
+    status: number;
+};
+export declare const mockApiError: {
+    response: {
+        data: {
+            code: string;
+            message: string;
+        };
+        status: number;
+    };
+};
+export declare const mockPassportBadRequest: {
+    response: {
+        data: {
+            code: string;
+            message: string;
+        };
+        status: number;
+    };
+};

package/dist/types/types.d.ts

@@ -0,0 +1,166 @@
+import { Environment, ModuleConfiguration } from '@imtbl/config';
+import { EthSigner, IMXClient, StarkSigner } from '@imtbl/x-client';
+import { ImxApiClients } from '@imtbl/generated-clients';
+import { Flow } from '@imtbl/metrics';
+export declare enum PassportEvents {
+    LOGGED_OUT = "loggedOut",
+    LOGGED_IN = "loggedIn",
+    ACCOUNTS_REQUESTED = "accountsRequested"
+}
+export type AccountsRequestedEvent = {
+    environment: Environment;
+    sendTransaction: (params: Array<any>, flow: Flow) => Promise<string>;
+    walletAddress: string;
+    passportClient: string;
+    flow?: Flow;
+};
+export interface PassportEventMap extends Record<string, any> {
+    [PassportEvents.LOGGED_OUT]: [];
+    [PassportEvents.LOGGED_IN]: [User];
+    [PassportEvents.ACCOUNTS_REQUESTED]: [AccountsRequestedEvent];
+}
+export type UserProfile = {
+    email?: string;
+    nickname?: string;
+    sub: string;
+};
+export type User = {
+    idToken?: string;
+    accessToken: string;
+    refreshToken?: string;
+    profile: UserProfile;
+    expired?: boolean;
+    imx?: {
+        ethAddress: string;
+        starkAddress: string;
+        userAdminAddress: string;
+    };
+    zkEvm?: {
+        ethAddress: string;
+        userAdminAddress: string;
+    };
+};
+export type PassportMetadata = {
+    imx_eth_address: string;
+    imx_stark_address: string;
+    imx_user_admin_address: string;
+    zkevm_eth_address: string;
+    zkevm_user_admin_address: string;
+};
+export interface OidcConfiguration {
+    clientId: string;
+    logoutRedirectUri?: string;
+    logoutMode?: 'redirect' | 'silent';
+    redirectUri: string;
+    scope?: string;
+    audience?: string;
+}
+export interface PassportOverrides {
+    authenticationDomain: string;
+    magicPublishableApiKey: string;
+    magicProviderId: string;
+    passportDomain: string;
+    imxPublicApiDomain: string;
+    immutableXClient: IMXClient;
+    zkEvmRpcUrl: string;
+    relayerUrl: string;
+    indexerMrBasePath: string;
+    orderBookMrBasePath: string;
+    passportMrBasePath: string;
+    imxApiClients?: ImxApiClients;
+}
+export interface PopupOverlayOptions {
+    disableGenericPopupOverlay?: boolean;
+    disableBlockedPopupOverlay?: boolean;
+}
+export interface PassportModuleConfiguration extends ModuleConfiguration<PassportOverrides>, OidcConfiguration {
+    /**
+     * This flag indicates that Passport is being used in a cross-sdk bridge scenario
+     * and not directly on the web.
+     */
+    crossSdkBridgeEnabled?: boolean;
+    /**
+     * Optional referrer URL to be sent with JSON-RPC requests.
+     * If specified, this value will be passed as the referrer in fetch options.
+     */
+    jsonRpcReferrer?: string;
+    /**
+     * Options for disabling the Passport popup overlays.
+     */
+    popupOverlayOptions?: PopupOverlayOptions;
+    /**
+     * This flag controls whether a deploy transaction is sent before signing an ERC191 message.
+     *
+     * @default false - By default, this behavior is disabled and the user will not be asked
+     * to approve a deploy transaction before signing.
+     */
+    forceScwDeployBeforeMessageSignature?: boolean;
+}
+type WithRequired<T, K extends keyof T> = T & {
+    [P in K]-?: T[P];
+};
+export type UserImx = WithRequired<User, 'imx'>;
+export type UserZkEvm = WithRequired<User, 'zkEvm'>;
+export declare const isUserZkEvm: (user: User) => user is UserZkEvm;
+export declare const isUserImx: (user: User) => user is UserImx;
+export type DeviceConnectResponse = {
+    code: string;
+    deviceCode: string;
+    url: string;
+    interval: number;
+};
+export type DeviceCodeResponse = {
+    device_code: string;
+    user_code: string;
+    verification_uri: string;
+    expires_in: number;
+    interval: number;
+    verification_uri_complete: string;
+};
+export type DeviceTokenResponse = {
+    access_token: string;
+    refresh_token?: string;
+    id_token: string;
+    token_type: string;
+    expires_in: number;
+};
+export type TokenPayload = {
+    exp?: number;
+};
+export type IdTokenPayload = {
+    passport?: PassportMetadata;
+    email: string;
+    nickname: string;
+    aud: string;
+    sub: string;
+    exp: number;
+    iss: string;
+    iat: number;
+};
+export type DeviceErrorResponse = {
+    error: string;
+    error_description: string;
+};
+export type PKCEData = {
+    state: string;
+    verifier: string;
+};
+export type IMXSigners = {
+    starkSigner: StarkSigner;
+    ethSigner: EthSigner;
+};
+export type LinkWalletParams = {
+    type: string;
+    walletAddress: string;
+    signature: string;
+    nonce: string;
+};
+export type LinkedWallet = {
+    address: string;
+    type: string;
+    created_at: string;
+    updated_at: string;
+    name?: string;
+    clientName: string;
+};
+export {};

package/dist/types/utils/lazyLoad.d.ts

@@ -0,0 +1,2 @@
+export declare const lazyLoad: <T, Y = void>(promiseToAwait: () => Promise<Y>, initialiseFunction: (arg: Y) => Promise<T> | T) => Promise<T>;
+export declare const lazyDocumentReady: <T>(initialiseFunction: () => Promise<T> | T) => Promise<T>;

package/dist/types/utils/lazyLoad.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/utils/logger.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    warn: (...args: any[]) => void;
+};
+export default _default;

package/dist/types/utils/metrics.d.ts

@@ -0,0 +1,3 @@
+import { Flow } from '@imtbl/metrics';
+export declare const withMetrics: <T>(fn: (flow: Flow) => T, flowName: string) => T;
+export declare const withMetricsAsync: <T>(fn: (flow: Flow) => Promise<T>, flowName: string) => Promise<T>;

package/dist/types/utils/metrics.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/utils/string.d.ts

@@ -0,0 +1 @@
+export declare const hexToString: (hex: string) => string;

package/dist/types/utils/string.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/utils/token.d.ts

@@ -0,0 +1,3 @@
+import { User as OidcUser } from 'oidc-client-ts';
+export declare function isIdTokenExpired(idToken: string | undefined): boolean;
+export declare function isTokenExpired(oidcUser: OidcUser): boolean;

package/dist/types/utils/token.test.d.ts

@@ -0,0 +1 @@
+export declare const mockValidIdToken: string;

package/dist/types/utils/typedEventEmitter.d.ts

@@ -0,0 +1,6 @@
+export default class TypedEventEmitter<TEvents extends Record<string, any>> {
+    private emitter;
+    emit<TEventName extends keyof TEvents & string>(eventName: TEventName, ...eventArg: TEvents[TEventName]): void;
+    on<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: (...eventArg: TEvents[TEventName]) => void): void;
+    removeListener<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: (...eventArg: TEvents[TEventName]) => void): void;
+}

package/dist/types/utils/typedEventEmitter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/zkEvm/JsonRpcError.d.ts

@@ -0,0 +1,25 @@
+/**
+ * ProviderErrors should take priority over RpcErrorCodes
+ * https://eips.ethereum.org/EIPS/eip-1193#provider-errors
+ * https://eips.ethereum.org/EIPS/eip-1474#error-codes
+ */
+export declare enum ProviderErrorCode {
+    USER_REJECTED_REQUEST = 4001,
+    UNAUTHORIZED = 4100,
+    UNSUPPORTED_METHOD = 4200,
+    DISCONNECTED = 4900
+}
+export declare enum RpcErrorCode {
+    RPC_SERVER_ERROR = -32000,
+    INVALID_REQUEST = -32600,
+    METHOD_NOT_FOUND = -32601,
+    INVALID_PARAMS = -32602,
+    INTERNAL_ERROR = -32603,
+    PARSE_ERROR = -32700,
+    TRANSACTION_REJECTED = -32003
+}
+export declare class JsonRpcError extends Error {
+    readonly message: string;
+    readonly code: ProviderErrorCode | RpcErrorCode;
+    constructor(code: ProviderErrorCode | RpcErrorCode, message: string);
+}

package/dist/types/zkEvm/index.d.ts

@@ -0,0 +1,2 @@
+export * from './zkEvmProvider';
+export * from './types';

package/dist/types/zkEvm/personalSign.d.ts

@@ -0,0 +1,15 @@
+import { Flow } from '@imtbl/metrics';
+import { Signer, JsonRpcProvider } from 'ethers';
+import GuardianClient from '../guardian';
+import { RelayerClient } from './relayerClient';
+interface PersonalSignParams {
+    ethSigner: Signer;
+    rpcProvider: JsonRpcProvider;
+    params: any[];
+    zkEvmAddress: string;
+    guardianClient: GuardianClient;
+    relayerClient: RelayerClient;
+    flow: Flow;
+}
+export declare const personalSign: ({ params, ethSigner, zkEvmAddress, rpcProvider, guardianClient, relayerClient, flow, }: PersonalSignParams) => Promise<string>;
+export {};

package/dist/types/zkEvm/personalSign.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/zkEvm/provider/eip6963.d.ts

@@ -0,0 +1,3 @@
+import { EIP6963ProviderDetail, EIP6963ProviderInfo } from '../types';
+export declare const passportProviderInfo: EIP6963ProviderInfo;
+export declare function announceProvider(detail: EIP6963ProviderDetail): void;

package/dist/types/zkEvm/relayerClient.d.ts

@@ -0,0 +1,59 @@
+import { BytesLike, JsonRpcProvider } from 'ethers';
+import AuthManager from '../authManager';
+import { PassportConfiguration } from '../config';
+import { FeeOption, RelayerTransaction, TypedDataPayload } from './types';
+export type RelayerClientInput = {
+    config: PassportConfiguration;
+    rpcProvider: JsonRpcProvider;
+    authManager: AuthManager;
+};
+type EthSendTransactionRequest = {
+    method: 'eth_sendTransaction';
+    params: {
+        to: string;
+        data: BytesLike;
+        chainId: string;
+    }[];
+};
+type ImGetTransactionByHashRequest = {
+    method: 'im_getTransactionByHash';
+    params: string[];
+};
+type ImGetFeeOptionsRequest = {
+    method: 'im_getFeeOptions';
+    params: {
+        userAddress: string;
+        data: BytesLike;
+        chainId: string;
+    }[];
+};
+type ImSignRequest = {
+    method: 'im_sign';
+    params: {
+        chainId: string;
+        address: string;
+        message: string;
+    }[];
+};
+type ImSignTypedDataRequest = {
+    method: 'im_signTypedData';
+    params: {
+        chainId: string;
+        address: string;
+        eip712Payload: TypedDataPayload;
+    }[];
+};
+export type RelayerTransactionRequest = EthSendTransactionRequest | ImGetTransactionByHashRequest | ImGetFeeOptionsRequest | ImSignTypedDataRequest | ImSignRequest;
+export declare class RelayerClient {
+    private readonly config;
+    private readonly rpcProvider;
+    private readonly authManager;
+    constructor({ config, rpcProvider, authManager }: RelayerClientInput);
+    private postToRelayer;
+    ethSendTransaction(to: string, data: BytesLike): Promise<string>;
+    imGetTransactionByHash(hash: string): Promise<RelayerTransaction>;
+    imGetFeeOptions(userAddress: string, data: BytesLike): Promise<FeeOption[]>;
+    imSignTypedData(address: string, eip712Payload: TypedDataPayload): Promise<string>;
+    imSign(address: string, message: string): Promise<string>;
+}
+export {};

package/dist/types/zkEvm/relayerClient.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/zkEvm/sendDeployTransactionAndPersonalSign.d.ts

@@ -0,0 +1,6 @@
+import { TransactionParams } from './transactionHelpers';
+type EthSendDeployTransactionParams = TransactionParams & {
+    params: Array<any>;
+};
+export declare const sendDeployTransactionAndPersonalSign: ({ params, ethSigner, rpcProvider, relayerClient, guardianClient, zkEvmAddress, flow, }: EthSendDeployTransactionParams) => Promise<string>;
+export {};

package/dist/types/zkEvm/sendDeployTransactionAndPersonalSign.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/zkEvm/sendTransaction.d.ts

@@ -0,0 +1,6 @@
+import { TransactionParams } from './transactionHelpers';
+type EthSendTransactionParams = TransactionParams & {
+    params: Array<any>;
+};
+export declare const sendTransaction: ({ params, ethSigner, rpcProvider, relayerClient, guardianClient, zkEvmAddress, flow, }: EthSendTransactionParams) => Promise<string>;
+export {};

package/dist/types/zkEvm/sendTransaction.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/zkEvm/sessionActivity/errorBoundary.d.ts

@@ -0,0 +1 @@
+export declare function errorBoundary<T extends (...args: any[]) => any>(fn: T, fallbackResult?: ReturnType<T>): (...args: Parameters<T>) => ReturnType<T>;

package/dist/types/zkEvm/sessionActivity/request.d.ts

@@ -0,0 +1,15 @@
+import { Environment } from '@imtbl/config';
+export declare const setupClient: (environment: Environment) => void;
+type CheckParams = {
+    clientId: string;
+    wallet?: string;
+    checkCount?: number;
+    sendCount?: number;
+};
+export type CheckResponse = {
+    contractAddress?: string;
+    functionName?: string;
+    delay?: number;
+};
+export declare function get(queries: CheckParams): Promise<CheckResponse | undefined>;
+export {};

package/dist/types/zkEvm/sessionActivity/sessionActivity.d.ts

@@ -0,0 +1,2 @@
+import { AccountsRequestedEvent } from '../../types';
+export declare const trackSessionActivity: (args: AccountsRequestedEvent) => Promise<void>;

package/dist/types/zkEvm/signEjectionTransaction.d.ts

@@ -0,0 +1,6 @@
+import { EjectionTransactionParams, EjectionTransactionResponse } from './transactionHelpers';
+type EthSendTransactionEjectionParams = EjectionTransactionParams & {
+    params: Array<any>;
+};
+export declare const signEjectionTransaction: ({ params, ethSigner, zkEvmAddress, flow, }: EthSendTransactionEjectionParams) => Promise<EjectionTransactionResponse>;
+export {};

package/dist/types/zkEvm/signEjectionTransaction.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/zkEvm/signTypedDataV4.d.ts

@@ -0,0 +1,14 @@
+import { Flow } from '@imtbl/metrics';
+import { Signer, JsonRpcProvider } from 'ethers';
+import GuardianClient from '../guardian';
+import { RelayerClient } from './relayerClient';
+export type SignTypedDataV4Params = {
+    ethSigner: Signer;
+    rpcProvider: JsonRpcProvider;
+    relayerClient: RelayerClient;
+    method: string;
+    params: Array<any>;
+    guardianClient: GuardianClient;
+    flow: Flow;
+};
+export declare const signTypedDataV4: ({ params, method, ethSigner, rpcProvider, relayerClient, guardianClient, flow, }: SignTypedDataV4Params) => Promise<string>;

package/dist/types/zkEvm/signTypedDataV4.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/zkEvm/transactionHelpers.d.ts

@@ -0,0 +1,29 @@
+import { Flow } from '@imtbl/metrics';
+import { Signer, TransactionRequest, JsonRpcProvider, BigNumberish } from 'ethers';
+import { RelayerClient } from './relayerClient';
+import GuardianClient from '../guardian';
+export type TransactionParams = {
+    ethSigner: Signer;
+    rpcProvider: JsonRpcProvider;
+    guardianClient: GuardianClient;
+    relayerClient: RelayerClient;
+    zkEvmAddress: string;
+    flow: Flow;
+};
+export type EjectionTransactionParams = Pick<TransactionParams, 'ethSigner' | 'zkEvmAddress' | 'flow'>;
+export type EjectionTransactionResponse = {
+    to: string;
+    data: string;
+    chainId: string;
+};
+export declare const pollRelayerTransaction: (relayerClient: RelayerClient, relayerId: string, flow: Flow) => Promise<import("./types").RelayerTransaction>;
+export declare const prepareAndSignTransaction: ({ transactionRequest, ethSigner, rpcProvider, guardianClient, relayerClient, zkEvmAddress, flow, }: TransactionParams & {
+    transactionRequest: TransactionRequest;
+}) => Promise<{
+    signedTransactions: string;
+    relayerId: string;
+    nonce: BigNumberish;
+}>;
+export declare const prepareAndSignEjectionTransaction: ({ transactionRequest, ethSigner, zkEvmAddress, flow, }: EjectionTransactionParams & {
+    transactionRequest: TransactionRequest;
+}) => Promise<EjectionTransactionResponse>;

package/dist/types/zkEvm/transactionHelpers.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/zkEvm/types.d.ts

@@ -0,0 +1,114 @@
+import { BigNumberish } from 'ethers';
+import { JsonRpcError } from './JsonRpcError';
+export declare enum RelayerTransactionStatus {
+    PENDING = "PENDING",
+    SUBMITTED = "SUBMITTED",
+    SUCCESSFUL = "SUCCESSFUL",
+    REVERTED = "REVERTED",
+    FAILED = "FAILED",
+    CANCELLED = "CANCELLED"
+}
+export interface RelayerTransaction {
+    status: RelayerTransactionStatus;
+    chainId: string;
+    relayerId: string;
+    hash: string;
+    statusMessage?: string;
+}
+export interface FeeOption {
+    tokenPrice: string;
+    tokenSymbol: string;
+    tokenDecimals: number;
+    tokenAddress: string;
+    recipientAddress: string;
+}
+export interface MetaTransaction {
+    to: string;
+    value?: BigNumberish | null;
+    data?: string | null;
+    nonce?: BigNumberish | null;
+    gasLimit?: BigNumberish;
+    delegateCall?: boolean;
+    revertOnError?: boolean;
+}
+export interface MetaTransactionNormalised {
+    delegateCall: boolean;
+    revertOnError: boolean;
+    gasLimit: BigNumberish;
+    target: string;
+    value: BigNumberish;
+    data: string;
+}
+export interface TypedDataPayload {
+    types: {
+        EIP712Domain: Array<{
+            name: string;
+            type: string;
+        }>;
+        [key: string]: Array<{
+            name: string;
+            type: string;
+        }>;
+    };
+    domain: {
+        name?: string;
+        version?: string;
+        chainId?: string;
+        verifyingContract?: string;
+        salt?: string;
+    };
+    primaryType: string;
+    message: Record<string, any>;
+}
+export interface RequestArguments {
+    method: string;
+    params?: Array<any>;
+}
+export type JsonRpcRequestPayload = RequestArguments & {
+    jsonrpc?: string;
+    id?: string | number;
+};
+export interface JsonRpcRequestCallback {
+    (err: JsonRpcError | null, result?: JsonRpcResponsePayload | (JsonRpcResponsePayload | null)[] | null): void;
+}
+export interface JsonRpcResponsePayload {
+    result?: Array<any> | null;
+    error?: JsonRpcError | null;
+    jsonrpc?: string;
+    id?: string | number;
+}
+export type Provider = {
+    request: (request: RequestArguments) => Promise<any>;
+    on: (event: string, listener: (...args: any[]) => void) => void;
+    removeListener: (event: string, listener: (...args: any[]) => void) => void;
+    isPassport: boolean;
+};
+export declare enum ProviderEvent {
+    ACCOUNTS_CHANGED = "accountsChanged"
+}
+export type AccountsChangedEvent = Array<string>;
+export interface ProviderEventMap extends Record<string, any> {
+    [ProviderEvent.ACCOUNTS_CHANGED]: [AccountsChangedEvent];
+}
+/**
+ * Event detail from the `eip6963:announceProvider` event.
+ */
+export interface EIP6963ProviderDetail {
+    info: EIP6963ProviderInfo;
+    provider: Provider;
+}
+/**
+ * Metadata of the EIP-1193 Provider.
+ */
+export interface EIP6963ProviderInfo {
+    icon: `data:image/${string}`;
+    name: string;
+    rdns: string;
+    uuid: string;
+}
+/**
+ * Event type to announce an EIP-1193 Provider.
+ */
+export interface EIP6963AnnounceProviderEvent extends CustomEvent<EIP6963ProviderDetail> {
+    type: 'eip6963:announceProvider';
+}

package/dist/types/zkEvm/user/index.d.ts

@@ -0,0 +1 @@
+export * from './registerZkEvmUser';