@magic-sdk/provider 29.4.3-canary.934.17056569905.0 → 29.4.3-canary.934.17056583985.0

package/dist/types/core/sdk-exceptions.d.ts

@@ -0,0 +1,87 @@
+import { JsonRpcError, RPCErrorCode, SDKErrorCode, SDKWarningCode } from '@magic-sdk/types';
+import { BaseExtension } from '../modules/base-extension';
+/**
+ * This error type represents internal SDK errors. This could be developer
+ * mistakes (or Magic's mistakes), or execution errors unrelated to standard
+ * JavaScript exceptions.
+ */
+export declare class MagicSDKError extends Error {
+    code: SDKErrorCode;
+    rawMessage: string;
+    __proto__: ErrorConstructor;
+    constructor(code: SDKErrorCode, rawMessage: string);
+}
+/**
+ * This error type communicates exceptions that occur during execution in the
+ * Magic `<iframe>` context.
+ */
+export declare class MagicRPCError extends Error {
+    __proto__: ErrorConstructor;
+    code: RPCErrorCode | number;
+    rawMessage: string;
+    data: any;
+    constructor(sourceError?: JsonRpcError | null);
+}
+/**
+ * In contrast to `SDKError` objects, this "warning" type communicates important
+ * context that does not rise to the level of an exception. These should be
+ * logged rather than thrown.
+ */
+export declare class MagicSDKWarning {
+    code: SDKWarningCode;
+    rawMessage: string;
+    message: string;
+    constructor(code: SDKWarningCode, rawMessage: string);
+    /**
+     * Logs this warning to the console.
+     */
+    log(): void;
+}
+/**
+ * This error type is reserved for communicating errors that arise during
+ * execution of Magic SDK Extension methods. Compare this to the `SDKError`
+ * type, specifically in context of Extensions.
+ */
+export declare class MagicExtensionError<TData = any> extends Error {
+    code: string | number;
+    rawMessage: string;
+    data: TData;
+    __proto__: ErrorConstructor;
+    constructor(ext: BaseExtension<string>, code: string | number, rawMessage: string, data: TData);
+}
+/**
+ * In contrast to `MagicExtensionError` objects, this "warning" type
+ * communicates important context that does not rise to the level of an
+ * exception. These should be logged rather than thrown.
+ */
+export declare class MagicExtensionWarning {
+    code: string | number;
+    rawMessage: string;
+    message: string;
+    constructor(ext: BaseExtension<string>, code: string | number, rawMessage: string);
+    /**
+     * Logs this warning to the console.
+     */
+    log(): void;
+}
+export declare function createMissingApiKeyError(): MagicSDKError;
+export declare function createModalNotReadyError(): MagicSDKError;
+export declare function createMalformedResponseError(): MagicSDKError;
+export declare function createExtensionNotInitializedError(member: string): MagicSDKError;
+export declare function createIncompatibleExtensionsError(extensions: BaseExtension<string>[]): MagicSDKError;
+export declare function createInvalidArgumentError(options: {
+    procedure: string;
+    argument: number;
+    expected: string;
+    received: string;
+}): MagicSDKError;
+export declare function createDuplicateIframeWarning(): MagicSDKWarning;
+export declare function createSynchronousWeb3MethodWarning(): MagicSDKWarning;
+export declare function createReactNativeEndpointConfigurationWarning(): MagicSDKWarning;
+export declare function createDeprecationWarning(options: {
+    method: string;
+    removalVersions: {
+        [P in 'magic-sdk' | '@magic-sdk/react-native' | '@magic-sdk/react-native-bare' | '@magic-sdk/react-native-expo']: string;
+    };
+    useInstead?: string;
+}): MagicSDKWarning;

package/dist/types/core/sdk.d.ts

@@ -0,0 +1,75 @@
+import { EthNetworkConfiguration, SupportedLocale } from '@magic-sdk/types';
+import { AuthModule } from '../modules/auth';
+import { UserModule } from '../modules/user';
+import { WalletModule } from '../modules/wallet';
+import { ThirdPartyWalletsModule } from '../modules/third-party-wallets';
+import { RPCProviderModule } from '../modules/rpc-provider';
+import { ViewController } from './view-controller';
+import { BaseExtension } from '../modules/base-extension';
+import { NFTModule } from '../modules/nft';
+export type MagicSDKExtensionsOption<TCustomExtName extends string = string> = BaseExtension<string>[] | {
+    [P in TCustomExtName]: BaseExtension<string>;
+};
+export interface MagicSDKAdditionalConfiguration<TCustomExtName extends string = string, TExt extends MagicSDKExtensionsOption<TCustomExtName> = any> {
+    endpoint?: string;
+    locale?: SupportedLocale;
+    network?: EthNetworkConfiguration;
+    extensions?: TExt;
+    testMode?: boolean;
+    deferPreload?: boolean;
+    useStorageCache?: boolean;
+    meta?: any;
+    authConfig?: {
+        skipDIDToken: boolean;
+    };
+}
+export declare class SDKBase {
+    readonly apiKey: string;
+    private static readonly __overlays__;
+    protected readonly endpoint: string;
+    protected readonly parameters: string;
+    protected readonly networkHash: string;
+    readonly testMode: boolean;
+    readonly useStorageCache: boolean;
+    /**
+     * Contains methods for starting a Magic SDK authentication flow.
+     */
+    readonly auth: AuthModule;
+    /**
+     * Contains methods for interacting with user data, checking login
+     * status, generating cryptographically-secure ID tokens, and more.
+     */
+    readonly user: UserModule;
+    /**
+     * Contains methods previously under the `ConnectExtension`, including
+     * login, show wallet UI, request user info, and more.
+     */
+    readonly wallet: WalletModule;
+    /**
+     * Contains methods for interacting with NFTs, including purchase.
+     */
+    readonly nft: NFTModule;
+    /**
+     * Contains internal methods for third-party wallets.
+     */
+    thirdPartyWallets: ThirdPartyWalletsModule;
+    /**
+     * Contains a Web3-compliant provider. Pass this module to your Web3/Ethers
+     * instance for automatic compatibility with Ethereum methods.
+     */
+    readonly rpcProvider: RPCProviderModule;
+    /**
+     * Creates an instance of Magic SDK.
+     */
+    constructor(apiKey: string, options?: MagicSDKAdditionalConfiguration);
+    /**
+     * Represents the view controller associated with this `MagicSDK` instance.
+     */
+    protected get overlay(): ViewController;
+    /**
+     * Preloads the Magic view, allowing for faster initial requests in browser
+     * environments. Awaiting the returned promise will signal when the Magic view
+     * has completed loading and is ready for requests.
+     */
+    preload(): Promise<void>;
+}

package/dist/types/core/view-controller.d.ts

@@ -0,0 +1,61 @@
+import { MagicIncomingWindowMessage, MagicOutgoingWindowMessage, JsonRpcRequestPayload, MagicMessageEvent, MagicMessageRequest } from '@magic-sdk/types';
+import { JsonRpcResponse } from './json-rpc';
+interface RemoveEventListenerFunction {
+    (): void;
+}
+export declare abstract class ViewController {
+    protected readonly endpoint: string;
+    protected readonly parameters: string;
+    protected readonly networkHash: string;
+    isReadyForRequest: boolean;
+    protected readonly messageHandlers: Set<(event: MagicMessageEvent) => any>;
+    protected isConnectedToInternet: boolean;
+    protected lastPongTime: null | number;
+    protected heartbeatIntervalTimer: ReturnType<typeof setInterval> | null;
+    protected heartbeatDebounce: () => void;
+    /**
+     * Create an instance of `ViewController`
+     *
+     * @param endpoint - The URL for the relevant iframe context.
+     * @param parameters - The unique, encoded query parameters for the
+     * relevant iframe context.
+     * @param networkHash - The hash of the network that this sdk instance is connected to
+     * for multi-chain scenarios
+     */
+    constructor(endpoint: string, parameters: string, networkHash: string);
+    protected abstract init(): void;
+    protected abstract _post(data: MagicMessageRequest): Promise<void>;
+    protected abstract hideOverlay(): void;
+    protected abstract showOverlay(): void;
+    protected abstract checkRelayerExistsInDOM(): Promise<boolean>;
+    protected abstract reloadRelayer(): Promise<void>;
+    /**
+     * Send a payload to the Magic `<iframe>` for processing and automatically
+     * handle the acknowledging follow-up event(s).
+     *
+     * @param msgType - The type of message to encode with the data.
+     * @param payload - The JSON RPC payload to emit via `window.postMessage`.
+     */
+    post<ResultType = any>(msgType: MagicOutgoingWindowMessage, payload: JsonRpcRequestPayload[]): Promise<JsonRpcResponse<ResultType>[]>;
+    post<ResultType = any>(msgType: MagicOutgoingWindowMessage, payload: JsonRpcRequestPayload): Promise<JsonRpcResponse<ResultType>>;
+    /**
+     * Listen for events received with the given `msgType`.
+     *
+     * @param msgType - The `msgType` encoded with the event data.
+     * @param handler - A handler function to execute on each event received.
+     * @return A `void` function to remove the attached event.
+     */
+    on(msgType: MagicIncomingWindowMessage, handler: (this: Window, event: MagicMessageEvent) => any): RemoveEventListenerFunction;
+    waitForReady(): Promise<void>;
+    /**
+     * Listen for messages sent from the underlying Magic `<WebView>`.
+     */
+    private listen;
+    /**
+     * Sends periodic pings to check the connection.
+     * If no pong is received or it’s stale, the iframe is reloaded.
+     */
+    private heartBeatCheck;
+    protected stopHeartBeat(): void;
+}
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,8 @@
+export { SDKBase } from './core/sdk';
+export type { MagicSDKAdditionalConfiguration, MagicSDKExtensionsOption } from './core/sdk';
+export { createSDK } from './core/sdk-environment';
+export { ViewController } from './core/view-controller';
+export * from './core/sdk-exceptions';
+export { Extension } from './modules/base-extension';
+export type { WithExtensions, InstanceWithExtensions } from './modules/base-extension';
+export * from './util';

package/dist/types/modules/auth.d.ts

@@ -0,0 +1,129 @@
+import { LoginWithMagicLinkConfiguration, LoginWithSmsConfiguration, LoginWithEmailOTPConfiguration, UpdateEmailConfiguration, LoginWithCredentialConfiguration } from '@magic-sdk/types';
+import { BaseModule } from './base-module';
+export declare const ProductConsolidationMethodRemovalVersions: {
+    'magic-sdk': string;
+    '@magic-sdk/react-native': string;
+    '@magic-sdk/react-native-bare': string;
+    '@magic-sdk/react-native-expo': string;
+};
+export declare class AuthModule extends BaseModule {
+    /**
+     * Initiate the "magic link" login flow for a user. If the flow is successful,
+     * this method will return a Decentralized ID token (with a default lifespan
+     * of 15 minutes).
+     */
+    loginWithMagicLink(configuration: LoginWithMagicLinkConfiguration): import("..").PromiEvent<string | null, {
+        "email-sent": () => void;
+        "email-not-deliverable": () => void;
+        retry: () => void;
+    } & {
+        "device-needs-approval": () => void;
+        "device-verification-email-sent": () => void;
+        "device-verification-link-expired": () => void;
+        "device-approved": () => void;
+        "device-retry": () => void;
+    } & {
+        done: (result: string | null) => void;
+        error: (reason: any) => void;
+        settled: () => void;
+        "closed-by-user": () => void;
+    }>;
+    /**
+     * Initiate an SMS login flow for a user. If successful,
+     * this method will return a Decenteralized ID token (with a default lifespan
+     * of 15 minutes)
+     */
+    loginWithSMS(configuration: LoginWithSmsConfiguration): import("..").PromiEvent<string | null, {
+        "verify-sms-otp": (otp: string) => void;
+        cancel: () => void;
+        retry: () => void;
+        "sms-otp-sent": () => void;
+        "invalid-sms-otp": () => void;
+        "expired-sms-otp": () => void;
+    } & {
+        "device-needs-approval": () => void;
+        "device-verification-email-sent": () => void;
+        "device-verification-link-expired": () => void;
+        "device-approved": () => void;
+        "device-retry": () => void;
+    } & {
+        done: (result: string | null) => void;
+        error: (reason: any) => void;
+        settled: () => void;
+        "closed-by-user": () => void;
+    }>;
+    /**
+     * Initiate an Email with OTP login flow for a user. If successful,
+     * this method will return a Decenteralized ID token (with a default lifespan
+     * of 15 minutes)
+     */
+    loginWithEmailOTP(configuration: LoginWithEmailOTPConfiguration): import("..").PromiEvent<string | null, {
+        "email-otp-sent": () => void;
+        "login-throttled": () => void;
+        "invalid-email-otp": () => void;
+        "invalid-mfa-otp": () => void;
+        "expired-email-otp": () => void;
+        "mfa-sent-handle": () => void;
+        "recovery-code-sent-handle": () => void;
+        "invalid-recovery-code": () => void;
+        "recovery-code-success": () => void;
+        "Auth/id-token-created": (idToken: string) => void;
+        "Wallet/wallet-info-fetched": () => void;
+        "verify-email-otp": (otp: string) => void;
+        "verify-mfa-code": (mfa: string) => void;
+        "lost-device": () => void;
+        "verify-recovery-code": (recoveryCode: string) => void;
+        cancel: () => void;
+    } & {
+        "device-needs-approval": () => void;
+        "device-verification-email-sent": () => void;
+        "device-verification-link-expired": () => void;
+        "device-approved": () => void;
+        "device-retry": () => void;
+    } & {
+        done: (result: string | null) => void;
+        error: (reason: any) => void;
+        settled: () => void;
+        "closed-by-user": () => void;
+    }>;
+    /**
+     * Log a user in with a special one-time-use credential token. This is
+     * currently used during magic link flows with a configured redirect to
+     * hydrate the user session at the end of the flow. If the flow is successful,
+     * this method will return a Decentralized ID token (with a default lifespan
+     * of 15 minutes).
+     *
+     * If no argument is provided, a credential is automatically parsed from
+     * `window.location.search`.
+     */
+    loginWithCredential(configuration?: LoginWithCredentialConfiguration): import("..").PromiEvent<string | null, {
+        done: (result: string | null) => void;
+        error: (reason: any) => void;
+        settled: () => void;
+        "closed-by-user": () => void;
+    }>;
+    setAuthorizationToken(jwt: string): import("..").PromiEvent<boolean, {
+        done: (result: boolean) => void;
+        error: (reason: any) => void;
+        settled: () => void;
+        "closed-by-user": () => void;
+    }>;
+    updateEmailWithUI(configuration: UpdateEmailConfiguration): import("..").PromiEvent<string | null, {
+        "UpdateEmail/new-email-needs-verification": () => void;
+        "UpdateEmail/email-updated": () => void;
+        "UpdateEmail/new-email-invalid-email-otp": () => void;
+        "UpdateEmail/new-email-verification-email-not-deliverable": () => void;
+        "UpdateEmail/new-email-verification-email-expired": () => void;
+        "UpdateEmail/new-email-verification-email-sent": () => void;
+        "UpdateEmail/new-email-invalid": () => void;
+        "UpdateEmail/new-email-already-exists": () => void;
+        "UpdateEmail/new-email-verification-cancel": () => void;
+        "UpdateEmail/retry-with-new-email": (email?: string) => void;
+        "UpdateEmail/new-email-verify-otp": (otp: string) => void;
+    } & import("@magic-sdk/types").RecencyCheckEventHandlers & {
+        done: (result: string | null) => void;
+        error: (reason: any) => void;
+        settled: () => void;
+        "closed-by-user": () => void;
+    }>;
+}

package/dist/types/modules/base-extension.d.ts

@@ -0,0 +1,113 @@
+import { createJsonRpcRequestPayload, standardizeJsonRpcRequestPayload } from '../core/json-rpc';
+import { BaseModule } from './base-module';
+import { SDKBase, MagicSDKAdditionalConfiguration, MagicSDKExtensionsOption } from '../core/sdk';
+import { MagicExtensionError, MagicExtensionWarning } from '../core/sdk-exceptions';
+import { createPromiEvent, encodeJSON, decodeJSON, storage, isPromiEvent } from '../util';
+export declare abstract class BaseExtension<TName extends string, TConfig extends any = any> extends BaseModule {
+    /**
+     * A structure describing the platform and version compatibility of this
+     * extension.
+     */
+    compat?: {
+        'magic-sdk': boolean | string;
+        '@magic-sdk/react-native': boolean | string;
+        '@magic-sdk/react-native-bare': boolean | string;
+        '@magic-sdk/react-native-expo': boolean | string;
+    };
+    abstract readonly name: TName;
+    abstract readonly config: TConfig;
+    private __sdk_access_field_descriptors__;
+    private __is_initialized__;
+    protected utils: {
+        createPromiEvent: typeof createPromiEvent;
+        isPromiEvent: typeof isPromiEvent;
+        encodeJSON: typeof encodeJSON;
+        decodeJSON: typeof decodeJSON;
+        createJsonRpcRequestPayload: typeof createJsonRpcRequestPayload;
+        standardizeJsonRpcRequestPayload: typeof standardizeJsonRpcRequestPayload;
+        storage: typeof storage;
+    };
+    constructor();
+    /**
+     * Registers a Magic SDK instance with this Extension.
+     *
+     * @internal
+     */
+    init(sdk: SDKBase): void;
+    /**
+     * Creates a deprecation warning wrapped with a native Magic SDK warning type.
+     * Best practice is to warn users of upcoming deprecations at least one major
+     * version before the change is implemented. You can use this method to
+     * communicate deprecations in a manner consistent with Magic SDK core code.
+     */
+    protected createDeprecationWarning(options: {
+        method: string;
+        removalVersion: string;
+        useInstead?: string;
+    }): MagicExtensionWarning;
+    /**
+     * Creates a warning wrapped with a native Magic SDK warning type. This
+     * maintains consistency in warning messaging for consumers of Magic SDK and
+     * this Extension.
+     */
+    protected createWarning(code: string | number, message: string): MagicExtensionWarning;
+    /**
+     * Creates an error wrapped with a native Magic SDK error type. This maintains
+     * consistency in error handling for consumers of Magic SDK and this
+     * Extension.
+     */
+    protected createError<TData = any>(code: string | number, message: string, data: TData): MagicExtensionError<TData>;
+}
+declare abstract class InternalExtension<TName extends string, TConfig extends any = any> extends BaseExtension<TName> {
+    abstract readonly config: TConfig;
+}
+/**
+ * A base class representing "extensions" to the core Magic JS APIs. Extensions
+ * enable new functionality by composing Magic endpoints methods together.
+ */
+export declare class Extension {
+    /**
+     * This is a special constructor used to mark "official" extensions. These
+     * extensions are designed for special interaction with the Magic iframe using
+     * custom JSON RPC methods, business logic, and global configurations. This is
+     * intended for internal-use only (and provides no useful advantage to
+     * open-source extension developers over the regular `Extension` class).
+     *
+     * @internal
+     */
+    static Internal: typeof InternalExtension;
+}
+/**
+ * These fields are exposed on the `Extension` type,
+ * but should be hidden from the public interface.
+ */
+type HiddenExtensionFields = 'name' | 'init' | 'config' | 'compat';
+/**
+ * Gets the type contained in an array type.
+ */
+type UnwrapArray<T extends any[]> = T extends Array<infer P> ? P : never;
+/**
+ * Create a union type of Extension names from an
+ * array of Extension types given by `TExt`.
+ */
+type ExtensionNames<TExt extends BaseExtension<string>[]> = UnwrapArray<TExt> extends BaseExtension<infer R> ? R : never;
+/**
+ * From the literal Extension name type given by `TExtName`,
+ * extract a dictionary of Extension types.
+ */
+type GetExtensionFromName<TExt extends BaseExtension<string>[], TExtName extends string> = {
+    [P in TExtName]: Extract<UnwrapArray<TExt>, BaseExtension<TExtName>>;
+}[TExtName];
+/**
+ * Wraps a Magic SDK constructor with the necessary type
+ * information to support a strongly-typed `Extension` interface.
+ */
+export type WithExtensions<SDK extends SDKBase> = {
+    new <TCustomExtName extends string, TExt extends MagicSDKExtensionsOption<TCustomExtName>>(apiKey: string, options?: MagicSDKAdditionalConfiguration<TCustomExtName, TExt>): InstanceWithExtensions<SDK, TExt>;
+};
+export type InstanceWithExtensions<SDK extends SDKBase, TExt extends MagicSDKExtensionsOption> = SDK & {
+    [P in Exclude<TExt extends BaseExtension<string>[] ? ExtensionNames<TExt> : keyof TExt, number>]: TExt extends BaseExtension<string>[] ? Omit<GetExtensionFromName<TExt, P>, HiddenExtensionFields> : TExt extends {
+        [P in Exclude<TExt extends BaseExtension<string>[] ? ExtensionNames<TExt> : keyof TExt, number>]: BaseExtension<string>;
+    } ? Omit<TExt[P], HiddenExtensionFields> : never;
+};
+export {};

package/dist/types/modules/base-module.d.ts

@@ -0,0 +1,27 @@
+import { JsonRpcRequestPayload, IntermediaryEvents } from '@magic-sdk/types';
+import type { SDKBase } from '../core/sdk';
+import type { ViewController } from '../core/view-controller';
+import type { EventsDefinition } from '../util/events';
+export declare class BaseModule {
+    protected sdk: SDKBase;
+    constructor(sdk: SDKBase);
+    /**
+     * The `ViewController` for the SDK instance registered to this module.
+     */
+    protected get overlay(): ViewController;
+    /**
+     * Emits promisified requests to the Magic `<iframe>` context.
+     */
+    protected request<ResultType = any, Events extends EventsDefinition = void>(payload: Partial<JsonRpcRequestPayload>): import("../util/promise-tools").PromiEvent<ResultType, Events extends void ? {
+        done: (result: ResultType) => void;
+        error: (reason: any) => void;
+        settled: () => void;
+        "closed-by-user": () => void;
+    } : Events & {
+        done: (result: ResultType) => void;
+        error: (reason: any) => void;
+        settled: () => void;
+        "closed-by-user": () => void;
+    }>;
+    protected createIntermediaryEvent<T = Function>(eventType: IntermediaryEvents, payloadId: string): T;
+}

package/dist/types/modules/nft.d.ts

@@ -0,0 +1,22 @@
+import { NFTCheckoutRequest, NFTCheckoutEvents, NFTPurchaseRequest, NFTPurchaseResponse, NFTTransferRequest } from '@magic-sdk/types';
+import { BaseModule } from './base-module';
+export declare class NFTModule extends BaseModule {
+    purchase(options: NFTPurchaseRequest): import("..").PromiEvent<NFTPurchaseResponse, {
+        done: (result: NFTPurchaseResponse) => void;
+        error: (reason: any) => void;
+        settled: () => void;
+        "closed-by-user": () => void;
+    }>;
+    checkout(options: NFTCheckoutRequest): import("..").PromiEvent<import("@magic-sdk/types").NFTResponse, NFTCheckoutEvents & {
+        done: (result: import("@magic-sdk/types").NFTResponse) => void;
+        error: (reason: any) => void;
+        settled: () => void;
+        "closed-by-user": () => void;
+    }>;
+    transfer(options: NFTTransferRequest): import("..").PromiEvent<import("@magic-sdk/types").NFTResponse, {
+        done: (result: import("@magic-sdk/types").NFTResponse) => void;
+        error: (reason: any) => void;
+        settled: () => void;
+        "closed-by-user": () => void;
+    }>;
+}

package/dist/types/modules/rpc-provider.d.ts

@@ -0,0 +1,50 @@
+import { JsonRpcRequestPayload, JsonRpcRequestCallback, JsonRpcBatchRequestCallback, JsonRpcResponsePayload, ProviderEnableEvents } from '@magic-sdk/types';
+import { BaseModule } from './base-module';
+import { PromiEvent } from '../util/promise-tools';
+import { EventsDefinition, TypedEmitter } from '../util/events';
+/** */
+export declare class RPCProviderModule extends BaseModule implements TypedEmitter {
+    readonly isMagic = true;
+    sendAsync(payload: Partial<JsonRpcRequestPayload>, onRequestComplete: JsonRpcRequestCallback): void;
+    sendAsync(payload: Partial<JsonRpcRequestPayload>[], onRequestComplete: JsonRpcBatchRequestCallback): void;
+    sendAsync(payload: Partial<JsonRpcRequestPayload> | Partial<JsonRpcRequestPayload>[], onRequestComplete: JsonRpcRequestCallback | JsonRpcBatchRequestCallback): void;
+    send<ResultType = any>(method: string, params?: any[]): PromiEvent<ResultType>;
+    send(payload: JsonRpcRequestPayload | JsonRpcRequestPayload[], onRequestComplete: JsonRpcRequestCallback): void;
+    send<ResultType>(payload: JsonRpcRequestPayload, none: void): JsonRpcResponsePayload<ResultType>;
+    enable(): PromiEvent<string[], ProviderEnableEvents & {
+        done: (result: string[]) => void;
+        error: (reason: any) => void;
+        settled: () => void;
+        "closed-by-user": () => void;
+    }>;
+    /**
+     * Here, we wrap `BaseModule.request` with an additional check
+     * to determine if the RPC method requires a test-mode prefix.
+     */
+    protected request<ResultType = any, Events extends EventsDefinition = void>(payload: Partial<JsonRpcRequestPayload>): PromiEvent<ResultType, Events extends void ? {
+        done: (result: ResultType) => void;
+        error: (reason: any) => void;
+        settled: () => void;
+        "closed-by-user": () => void;
+    } : Events & {
+        done: (result: ResultType) => void;
+        error: (reason: any) => void;
+        settled: () => void;
+        "closed-by-user": () => void;
+    }>;
+    /**
+     * Prefixes Ethereum RPC methods with a `testMode` identifier. This is done so
+     * that Magic's <iframe> can handle signing methods using test-specific keys.
+     */
+    private prefixPayloadMethodForTestMode;
+    on: (event: string | symbol, fn: (...args: any[]) => void, context?: any) => this;
+    once: (event: string | symbol, fn: (...args: any[]) => void, context?: any) => this;
+    addListener: (event: string | symbol, fn: (...args: any[]) => void, context?: any) => this;
+    off: (event: string | symbol, fn?: ((...args: any[]) => void) | undefined, context?: any, once?: boolean | undefined) => this;
+    removeListener: (event: string | symbol, fn?: ((...args: any[]) => void) | undefined, context?: any, once?: boolean | undefined) => this;
+    removeAllListeners: (event?: string | symbol | undefined) => this;
+    emit: <T extends string | symbol>(event: T, ...args: any[]) => boolean;
+    eventNames: () => (string | symbol)[];
+    listeners: <T extends string | symbol>(event: T) => ((...args: any[]) => void)[];
+    listenerCount: (event: string | symbol) => number;
+}

package/dist/types/modules/third-party-wallets.d.ts

@@ -0,0 +1,26 @@
+import { JsonRpcRequestPayload, ThirdPartyWalletEvents } from '@magic-sdk/types';
+import { BaseModule } from './base-module';
+import { PromiEvent } from '../util';
+export declare class ThirdPartyWalletsModule extends BaseModule {
+    eventListeners: {
+        event: ThirdPartyWalletEvents;
+        callback: (payloadId: string) => Promise<void>;
+    }[];
+    enabledWallets: Record<string, boolean>;
+    isConnected: boolean;
+    resetThirdPartyWalletState(): void;
+    requestOverride(payload: Partial<JsonRpcRequestPayload>): PromiEvent<any, {
+        done: (result: any) => void;
+        error: (reason: any) => void;
+        settled: () => void;
+        "closed-by-user": () => void;
+    }>;
+    private isLoggedIn;
+    private getInfo;
+    private logout;
+    private web3modalRequest;
+    private web3modalIsLoggedIn;
+    private formatWeb3modalGetInfoResponse;
+    private web3modalGetInfo;
+    private web3modalLogout;
+}