@0xsequence/provider 0.0.0-2021823181734

package/dist/declarations/src/commands/index.d.ts

@@ -0,0 +1,20 @@
+import { BigNumberish, BytesLike } from 'ethers';
+import { TypedDataDomain, TypedDataField } from '@ethersproject/abstract-signer';
+import { WalletContext, ChainIdLike } from '@0xsequence/network';
+import { TypedData } from '@0xsequence/utils';
+import { DecodedSignature, WalletConfig } from '@0xsequence/config';
+import { Wallet } from '../wallet';
+export declare class WalletCommands {
+    private wallet;
+    constructor(walletProvider: Wallet);
+    signMessage(message: BytesLike, chainId?: ChainIdLike, allSigners?: boolean): Promise<string>;
+    signAuthMessage(message: BytesLike, allSigners?: boolean): Promise<string>;
+    signTypedData(domain: TypedDataDomain, types: Record<string, Array<TypedDataField>>, message: Record<string, any>, chainId?: ChainIdLike, allSigners?: boolean): Promise<string>;
+    signAuthTypedData(domain: TypedDataDomain, types: Record<string, Array<TypedDataField>>, message: Record<string, any>, allSigners?: boolean): Promise<string>;
+    isValidSignature(address: string, digest: Uint8Array, signature: string, chainId: number, walletContext?: WalletContext): Promise<boolean | undefined>;
+    isValidMessageSignature(address: string, message: string | Uint8Array, signature: string, chainId: number, walletContext?: WalletContext): Promise<boolean | undefined>;
+    isValidTypedDataSignature(address: string, typedData: TypedData, signature: string, chainId: number, walletContext?: WalletContext): Promise<boolean | undefined>;
+    recoverWalletConfig: (address: string, digest: BytesLike, signature: string | DecodedSignature, chainId: BigNumberish, walletContext?: any) => Promise<WalletConfig>;
+    recoverWalletConfigFromMessage: (address: string, message: string | Uint8Array, signature: string | DecodedSignature, chainId: BigNumberish, walletContext?: any) => Promise<WalletConfig>;
+    recoverWalletConfigFromTypedData: (address: string, typedData: TypedData, signature: string | DecodedSignature, chainId: BigNumberish, walletContext?: any) => Promise<WalletConfig>;
+}

package/dist/declarations/src/index.d.ts

@@ -0,0 +1,5 @@
+export * from './transports';
+export * from './types';
+export * from './wallet';
+export * from './provider';
+export * from './utils';

package/dist/declarations/src/provider.d.ts

@@ -0,0 +1,59 @@
+import { ethers } from 'ethers';
+import { BytesLike } from '@ethersproject/bytes';
+import { Web3Provider as EthersWeb3Provider, JsonRpcProvider } from '@ethersproject/providers';
+import { TypedDataDomain, TypedDataField, TypedDataSigner } from '@ethersproject/abstract-signer';
+import { NetworkConfig, Networks, WalletContext, ChainIdLike, JsonRpcHandler, JsonRpcFetchFunc, JsonRpcRequest, JsonRpcResponseCallback, JsonRpcSender } from '@0xsequence/network';
+import { Signer } from '@0xsequence/wallet';
+import { WalletConfig, WalletState } from '@0xsequence/config';
+import { Relayer } from '@0xsequence/relayer';
+import { Deferrable } from '@0xsequence/utils';
+import { Transaction, TransactionRequest, TransactionResponse, SignedTransactions } from '@0xsequence/transactions';
+export declare class Web3Provider extends EthersWeb3Provider implements JsonRpcHandler {
+    static isSequenceProvider(cand: any): cand is Web3Provider;
+    readonly _sender: JsonRpcSender;
+    readonly _isSequenceProvider: boolean;
+    readonly _defaultChainId?: number;
+    constructor(provider: JsonRpcProvider | JsonRpcHandler | JsonRpcFetchFunc, defaultChainId?: ChainIdLike);
+    sendAsync(request: JsonRpcRequest, callback: JsonRpcResponseCallback | ((error: any, response: any) => void), chainId?: number): void;
+    send(method: string, params: Array<any>, chainId?: number): Promise<any>;
+    getSigner(): Web3Signer;
+    getChainId(): Promise<number>;
+}
+export declare function isSequenceProvider(provider: any): provider is Web3Provider;
+export declare class LocalWeb3Provider extends Web3Provider {
+    constructor(signer: Signer, networks?: Networks);
+}
+export declare class Web3Signer extends Signer implements TypedDataSigner {
+    readonly provider: Web3Provider;
+    readonly defaultChainId?: number;
+    constructor(provider: Web3Provider, defaultChainId?: number);
+    _address: string;
+    _index: number;
+    _context: WalletContext;
+    _networks: NetworkConfig[];
+    private _providers;
+    getAddress(): Promise<string>;
+    signTransaction(transaction: Deferrable<TransactionRequest>): Promise<string>;
+    connect(provider: ethers.providers.Provider): ethers.providers.JsonRpcSigner;
+    getProvider(chainId?: number): Promise<Web3Provider | undefined>;
+    getSender(chainId?: number): Promise<Web3Provider | undefined>;
+    getRelayer(chainId?: number): Promise<Relayer | undefined>;
+    getWalletContext(): Promise<WalletContext>;
+    getWalletConfig(chainId?: ChainIdLike): Promise<WalletConfig[]>;
+    getWalletState(chainId?: ChainIdLike): Promise<WalletState[]>;
+    getNetworks(): Promise<NetworkConfig[]>;
+    getSigners(): Promise<string[]>;
+    signMessage(message: BytesLike, chainId?: ChainIdLike, allSigners?: boolean): Promise<string>;
+    signTypedData(domain: TypedDataDomain, types: Record<string, Array<TypedDataField>>, message: Record<string, any>, chainId?: ChainIdLike, allSigners?: boolean): Promise<string>;
+    sendTransaction(transaction: Deferrable<TransactionRequest>, chainId?: ChainIdLike, allSigners?: boolean): Promise<TransactionResponse>;
+    sendTransactionBatch(transactions: Deferrable<TransactionRequest[] | Transaction[]>, chainId?: ChainIdLike, allSigners?: boolean): Promise<TransactionResponse>;
+    signTransactions(transaction: Deferrable<TransactionRequest>, chainId?: ChainIdLike, allSigners?: boolean): Promise<SignedTransactions>;
+    sendSignedTransactions(signedTxs: SignedTransactions, chainId?: ChainIdLike): Promise<TransactionResponse>;
+    updateConfig(newConfig?: WalletConfig): Promise<[WalletConfig, TransactionResponse | undefined]>;
+    publishConfig(): Promise<TransactionResponse | undefined>;
+    isDeployed(chainId?: ChainIdLike): Promise<boolean>;
+    _signTypedData(domain: TypedDataDomain, types: Record<string, Array<TypedDataField>>, message: Record<string, any>, chainId?: ChainIdLike, allSigners?: boolean): Promise<string>;
+    sendUncheckedTransaction(transaction: Deferrable<TransactionRequest>, chainId?: ChainIdLike): Promise<string>;
+    connectUnchecked(): ethers.providers.JsonRpcSigner;
+    unlock(password: string): Promise<boolean>;
+}

package/dist/declarations/src/transports/base-provider-transport.d.ts

@@ -0,0 +1,40 @@
+import { ProviderTransport, ProviderMessage, ProviderMessageRequest, ProviderEventTypes, ProviderMessageResponse, ProviderMessageResponseCallback, OpenState, OpenWalletIntent, ConnectDetails, WalletSession, ProviderRpcError, InitState, TypedEventEmitter } from '../types';
+import { NetworkConfig, WalletContext } from '@0xsequence/network';
+export declare const PROVIDER_OPEN_TIMEOUT = 30000;
+export declare const nextMessageIdx: () => number;
+export declare abstract class BaseProviderTransport implements ProviderTransport {
+    protected pendingMessageRequests: ProviderMessageRequest[];
+    protected responseCallbacks: Map<number, ProviderMessageResponseCallback>;
+    protected state: OpenState;
+    protected confirmationOnly: boolean;
+    protected events: TypedEventEmitter<ProviderEventTypes>;
+    protected openPayload: {
+        sessionId?: string;
+        session?: WalletSession;
+    } | undefined;
+    protected connectPayload: ConnectDetails | undefined;
+    protected accountsChangedPayload: string | undefined;
+    protected networksPayload: NetworkConfig[] | undefined;
+    protected walletContextPayload: WalletContext | undefined;
+    protected _sessionId?: string;
+    protected _init: InitState;
+    protected _registered: boolean;
+    constructor();
+    get registered(): boolean;
+    register(): void;
+    unregister(): void;
+    openWallet(path?: string, intent?: OpenWalletIntent, networkId?: string | number): void;
+    closeWallet(): void;
+    isOpened(): boolean;
+    isConnected(): boolean;
+    sendAsync: (request: any, callback: any, chainId?: number | undefined) => Promise<void>;
+    handleMessage(message: ProviderMessage<any>): void;
+    sendMessageRequest: (message: ProviderMessageRequest) => Promise<ProviderMessageResponse>;
+    sendMessage(message: ProviderMessage<any>): void;
+    on<K extends keyof ProviderEventTypes>(event: K, fn: ProviderEventTypes[K]): void;
+    once<K extends keyof ProviderEventTypes>(event: K, fn: ProviderEventTypes[K]): void;
+    emit<K extends keyof ProviderEventTypes>(event: K, ...args: Parameters<ProviderEventTypes[K]>): boolean;
+    waitUntilOpened: (openTimeout?: number) => Promise<WalletSession | undefined>;
+    waitUntilConnected: () => Promise<ConnectDetails>;
+    protected close(error?: ProviderRpcError): void;
+}

package/dist/declarations/src/transports/base-wallet-transport.d.ts

@@ -0,0 +1,38 @@
+import { WalletTransport, ProviderMessage, ProviderMessageRequest, ProviderMessageResponse, ProviderRpcError, InitState, ConnectDetails, WalletSession, TransportSession } from '../types';
+import { WalletRequestHandler } from './wallet-request-handler';
+import { NetworkConfig, WalletContext } from '@0xsequence/network';
+export declare abstract class BaseWalletTransport implements WalletTransport {
+    protected walletRequestHandler: WalletRequestHandler;
+    protected _sessionId: string;
+    protected _registered: boolean;
+    protected _init: InitState;
+    protected _initNonce: string;
+    protected _initCallback?: (error?: string) => void;
+    protected appOrigin?: string;
+    constructor(walletRequestHandler: WalletRequestHandler);
+    get registered(): boolean;
+    register(): void;
+    unregister(): void;
+    sendAsync: (request: any, callback: any, chainId?: number | undefined) => Promise<never>;
+    handleMessage: (message: ProviderMessage<any>) => Promise<void>;
+    sendMessageRequest: (message: ProviderMessageRequest) => Promise<ProviderMessageResponse>;
+    sendMessage(message: ProviderMessage<any>): void;
+    notifyOpen(openInfo: {
+        chainId?: string;
+        sessionId?: string;
+        session?: WalletSession;
+        error?: string;
+    }): void;
+    notifyClose(error?: ProviderRpcError): void;
+    notifyConnect(connectDetails: ConnectDetails): void;
+    notifyDisconnect(error?: ProviderRpcError): void;
+    notifyAccountsChanged(accounts: string[]): void;
+    notifyChainChanged(chainIdHex: string): void;
+    notifyNetworks(networks: NetworkConfig[]): void;
+    notifyWalletContext(walletContext: WalletContext): void;
+    protected isValidInitAck(message: ProviderMessage<any>): boolean;
+    private init;
+    protected open: ({ sessionId, intent, networkId }: TransportSession) => Promise<boolean>;
+    private saveTransportSession;
+    protected getCachedTransportSession: () => TransportSession | null;
+}

package/dist/declarations/src/transports/extension-transport/base-injected-transport.d.ts

@@ -0,0 +1,18 @@
+import { EventEmitter2 as EventEmitter } from 'eventemitter2';
+import { ProviderMessageResponseCallback, ProviderMessageRequest, ProviderMessageResponse } from '../../types';
+interface Stream {
+    on(ev: string | symbol, fn: (...args: any[]) => void): void;
+    writable: boolean;
+    write(chunk: any, cb?: (error: Error | null | undefined) => void): boolean;
+}
+export declare abstract class BaseInjectedTransport extends EventEmitter {
+    private stream;
+    protected responseCallbacks: Map<number, ProviderMessageResponseCallback>;
+    private _messageIdx;
+    protected nextMessageIdx: () => number;
+    constructor(stream: Stream);
+    private handleMessage;
+    protected sendMessageRequest: (message: ProviderMessageRequest) => Promise<ProviderMessageResponse>;
+    private sendMessage;
+}
+export {};

package/dist/declarations/src/transports/extension-transport/extension-message-handler.d.ts

@@ -0,0 +1,12 @@
+import { WalletRequestHandler } from '../wallet-request-handler';
+import { BaseWalletTransport } from '../base-wallet-transport';
+import { ProviderMessage } from '../../types';
+import { Runtime } from 'webextension-polyfill-ts';
+export declare const CHANNEL_ID = "sequence-extension-message-handler";
+export declare class ExtensionMessageHandler extends BaseWalletTransport {
+    runtime: Runtime.Static;
+    private port;
+    constructor(walletRequestHandler: WalletRequestHandler, runtime: Runtime.Static);
+    register(): void;
+    sendMessage(message: ProviderMessage<any>): void;
+}

package/dist/declarations/src/transports/extension-transport/extension-message-provider.d.ts

@@ -0,0 +1,11 @@
+import { OpenWalletIntent, ProviderMessage } from '../../types';
+import { BaseProviderTransport } from '../base-provider-transport';
+import { Runtime } from 'webextension-polyfill-ts';
+export declare class ExtensionMessageProvider extends BaseProviderTransport {
+    constructor(runtime: Runtime.Static);
+    register: () => void;
+    sendMessage(message: ProviderMessage<any>): void;
+    unregister(): void;
+    openWallet(path?: string, intent?: OpenWalletIntent, networkId?: string | number): void;
+    closeWallet(): void;
+}

package/dist/declarations/src/transports/extension-transport/index.d.ts

@@ -0,0 +1,3 @@
+export * from './extension-message-handler';
+export * from './extension-message-provider';
+export * from './base-injected-transport';

package/dist/declarations/src/transports/index.d.ts

@@ -0,0 +1,7 @@
+export * from './base-provider-transport';
+export * from './base-wallet-transport';
+export * from './proxy-transport';
+export * from './mux-transport';
+export * from './window-transport';
+export * from './wallet-request-handler';
+export * from './extension-transport';

package/dist/declarations/src/transports/mux-transport/index.d.ts

@@ -0,0 +1 @@
+export * from './mux-message-provider';

package/dist/declarations/src/transports/mux-transport/mux-message-provider.d.ts

@@ -0,0 +1,22 @@
+import { ProviderMessage, ProviderTransport, ProviderEventTypes, ProviderMessageRequest, ProviderMessageResponse, WalletSession, OpenWalletIntent, ConnectDetails } from '../../types';
+export declare class MuxMessageProvider implements ProviderTransport {
+    private messageProviders;
+    private provider;
+    constructor(...messageProviders: ProviderTransport[]);
+    add(...messageProviders: ProviderTransport[]): void;
+    register: () => void;
+    unregister: () => void;
+    openWallet: (path?: string | undefined, intent?: OpenWalletIntent | undefined, networkId?: string | number | undefined) => void;
+    closeWallet(): void;
+    isOpened(): boolean;
+    isConnected(): boolean;
+    on<K extends keyof ProviderEventTypes>(event: K, fn: ProviderEventTypes[K]): void;
+    once<K extends keyof ProviderEventTypes>(event: K, fn: ProviderEventTypes[K]): void;
+    emit<K extends keyof ProviderEventTypes>(event: K, ...args: Parameters<ProviderEventTypes[K]>): boolean;
+    sendAsync: (request: any, callback: any, chainId?: number | undefined) => Promise<void>;
+    sendMessage(message: ProviderMessage<any>): void;
+    sendMessageRequest: (message: ProviderMessageRequest) => Promise<ProviderMessageResponse>;
+    handleMessage(message: ProviderMessage<any>): void;
+    waitUntilOpened: () => Promise<WalletSession | undefined>;
+    waitUntilConnected: () => Promise<ConnectDetails>;
+}

package/dist/declarations/src/transports/proxy-transport/index.d.ts

@@ -0,0 +1,3 @@
+export * from './proxy-message-channel';
+export * from './proxy-message-provider';
+export * from './proxy-message-handler';

package/dist/declarations/src/transports/proxy-transport/proxy-message-channel.d.ts

@@ -0,0 +1,15 @@
+import { ProviderMessage, ProviderMessageTransport, ProviderEventTypes, TypedEventEmitter } from '../../types';
+export declare class ProxyMessageChannel {
+    app: ProxyMessageChannelPort;
+    wallet: ProxyMessageChannelPort;
+    constructor();
+}
+export declare class ProxyMessageChannelPort implements ProviderMessageTransport {
+    conn: ProviderMessageTransport;
+    events: TypedEventEmitter<ProxyEventTypes>;
+    handleMessage: (message: ProviderMessage<any>) => void;
+    sendMessage: (message: ProviderMessage<any>) => void;
+    on<K extends keyof ProxyEventTypes>(event: K, fn: ProxyEventTypes[K]): void;
+    once<K extends keyof ProxyEventTypes>(event: K, fn: ProxyEventTypes[K]): void;
+}
+export declare type ProxyEventTypes = Pick<ProviderEventTypes, 'open' | 'close' | 'connect' | 'disconnect'>;

package/dist/declarations/src/transports/proxy-transport/proxy-message-handler.d.ts

@@ -0,0 +1,12 @@
+import { BaseWalletTransport } from '../base-wallet-transport';
+import { WalletRequestHandler } from '../wallet-request-handler';
+import { ProviderMessage } from '../../types';
+import { ProxyMessageChannelPort } from './proxy-message-channel';
+export declare class ProxyMessageHandler extends BaseWalletTransport {
+    private port;
+    constructor(walletRequestHandler: WalletRequestHandler, port: ProxyMessageChannelPort);
+    register(): void;
+    restoreSession(): void;
+    unregister(): void;
+    sendMessage(message: ProviderMessage<any>): void;
+}

package/dist/declarations/src/transports/proxy-transport/proxy-message-provider.d.ts

@@ -0,0 +1,12 @@
+import { BaseProviderTransport } from '../base-provider-transport';
+import { ProviderMessage, OpenWalletIntent } from '../../types';
+import { ProxyMessageChannelPort } from './proxy-message-channel';
+export declare class ProxyMessageProvider extends BaseProviderTransport {
+    private port;
+    constructor(port: ProxyMessageChannelPort);
+    register: () => void;
+    unregister: () => void;
+    openWallet: (path?: string | undefined, intent?: OpenWalletIntent | undefined, networkId?: string | number | undefined) => void;
+    closeWallet(): void;
+    sendMessage(message: ProviderMessage<any>): void;
+}

package/dist/declarations/src/transports/wallet-request-handler.d.ts

@@ -0,0 +1,51 @@
+import { ProviderMessageRequest, ProviderMessageResponse, ProviderMessageRequestHandler, MessageToSign, ProviderRpcError, ConnectOptions, ConnectDetails, PromptConnectDetails, WalletSession, ProviderEventTypes } from '../types';
+import { ExternalProvider } from '@ethersproject/providers';
+import { Networks, NetworkConfig, JsonRpcHandler } from '@0xsequence/network';
+import { Signer } from '@0xsequence/wallet';
+import { TransactionRequest } from '@0xsequence/transactions';
+export interface WalletSignInOptions {
+    connect?: boolean;
+    mainnetNetworks?: Networks;
+    testnetNetworks?: Networks;
+    defaultNetworkId?: string | number;
+}
+export declare class WalletRequestHandler implements ExternalProvider, JsonRpcHandler, ProviderMessageRequestHandler {
+    private signer;
+    private prompter;
+    private mainnetNetworks;
+    private testnetNetworks;
+    private _connectOptions?;
+    private _defaultNetworkId?;
+    private _chainId?;
+    private events;
+    constructor(signer: Signer | null, prompter: WalletUserPrompter | null, mainnetNetworks: Networks, testnetNetworks?: Networks);
+    signIn(signer: Signer | null, options?: WalletSignInOptions): Promise<void>;
+    connect(options?: ConnectOptions): Promise<ConnectDetails>;
+    promptConnect: (options?: ConnectOptions | undefined) => Promise<ConnectDetails>;
+    sendMessageRequest(message: ProviderMessageRequest): Promise<ProviderMessageResponse>;
+    sendAsync: (request: any, callback: any, chainId?: number | undefined) => Promise<void>;
+    on<K extends keyof ProviderEventTypes>(event: K, fn: ProviderEventTypes[K]): void;
+    once<K extends keyof ProviderEventTypes>(event: K, fn: ProviderEventTypes[K]): void;
+    getAddress(): Promise<string>;
+    getChainId(): Promise<number>;
+    get connectOptions(): ConnectOptions | undefined;
+    setConnectOptions(options: ConnectOptions | undefined): void;
+    get defaultNetworkId(): string | number | undefined;
+    setDefaultNetwork(chainId: string | number, notifyNetworks?: boolean): Promise<number | undefined>;
+    getNetworks(jsonRpcResponse?: boolean): Promise<NetworkConfig[]>;
+    walletSession(): Promise<WalletSession | undefined>;
+    notifyConnect(connectDetails: ConnectDetails): void;
+    notifyDisconnect(): void;
+    notifyNetworks(networks?: NetworkConfig[]): Promise<void>;
+    notifyWalletContext(): Promise<void>;
+    notifyClose(error?: ProviderRpcError): void;
+    isSignedIn(): boolean;
+    getSigner(): Signer | null;
+    setSigner(signer: Signer | null): void;
+}
+export interface WalletUserPrompter {
+    promptConnect(options?: ConnectOptions): Promise<PromptConnectDetails>;
+    promptSignMessage(message: MessageToSign): Promise<string>;
+    promptSignTransaction(txn: TransactionRequest, chaindId?: number): Promise<string>;
+    promptSendTransaction(txn: TransactionRequest, chaindId?: number): Promise<string>;
+}

package/dist/declarations/src/transports/window-transport/index.d.ts

@@ -0,0 +1,2 @@
+export * from './window-message-provider';
+export * from './window-message-handler';

package/dist/declarations/src/transports/window-transport/window-message-handler.d.ts

@@ -0,0 +1,15 @@
+import { ProviderMessage } from '../../types';
+import { WalletRequestHandler } from '../wallet-request-handler';
+import { BaseWalletTransport } from '../base-wallet-transport';
+export declare class WindowMessageHandler extends BaseWalletTransport {
+    protected parentWindow: Window;
+    private _isPopup;
+    constructor(walletRequestHandler: WalletRequestHandler);
+    register(): void;
+    unregister(): void;
+    private onWindowEvent;
+    sendMessage(message: ProviderMessage<any>): void;
+    get isPopup(): boolean;
+    private postMessage;
+    private getWindowTransportSession;
+}

package/dist/declarations/src/transports/window-transport/window-message-provider.d.ts

@@ -0,0 +1,13 @@
+import { OpenWalletIntent, ProviderMessage } from '../../types';
+import { BaseProviderTransport } from '../base-provider-transport';
+export declare class WindowMessageProvider extends BaseProviderTransport {
+    private walletURL;
+    private walletWindow;
+    constructor(walletAppURL: string);
+    register: () => void;
+    unregister: () => void;
+    openWallet: (path?: string | undefined, intent?: OpenWalletIntent | undefined, networkId?: string | number | undefined) => void;
+    closeWallet(): void;
+    private onWindowEvent;
+    sendMessage(message: ProviderMessage<any>): void;
+}

package/dist/declarations/src/types.d.ts

@@ -0,0 +1,170 @@
+import { NetworkConfig, WalletContext, JsonRpcRequest, JsonRpcResponse, JsonRpcHandler } from '@0xsequence/network';
+import { TypedData } from '@0xsequence/utils';
+export interface ProviderTransport extends JsonRpcHandler, ProviderMessageTransport, ProviderMessageRequestHandler {
+    register(): void;
+    unregister(): void;
+    openWallet(path?: string, intent?: OpenWalletIntent, networkId?: string | number): void;
+    closeWallet(): void;
+    isOpened(): boolean;
+    isConnected(): boolean;
+    on<K extends keyof ProviderEventTypes>(event: K, fn: ProviderEventTypes[K]): void;
+    once<K extends keyof ProviderEventTypes>(event: K, fn: ProviderEventTypes[K]): void;
+    emit<K extends keyof ProviderEventTypes>(event: K, ...args: Parameters<ProviderEventTypes[K]>): boolean;
+    waitUntilOpened(): Promise<WalletSession | undefined>;
+    waitUntilConnected(): Promise<ConnectDetails>;
+}
+export interface WalletTransport extends JsonRpcHandler, ProviderMessageTransport, ProviderMessageRequestHandler {
+    register(): void;
+    unregister(): void;
+    notifyOpen(openInfo: {
+        chainId?: string;
+        sessionId?: string;
+        session?: WalletSession;
+        error?: string;
+    }): void;
+    notifyClose(error?: ProviderRpcError): void;
+    notifyConnect(connectDetails: ConnectDetails): void;
+    notifyAccountsChanged(accounts: string[]): void;
+    notifyChainChanged(chainIdHex: string): void;
+    notifyNetworks(networks: NetworkConfig[]): void;
+}
+export interface ProviderMessage<T> {
+    idx: number;
+    type: string;
+    data: T;
+    chainId?: number;
+}
+export declare type ProviderMessageRequest = ProviderMessage<JsonRpcRequest>;
+export declare type ProviderMessageResponse = ProviderMessage<JsonRpcResponse>;
+export declare type ProviderMessageResponseCallback = (error?: ProviderRpcError, response?: ProviderMessageResponse) => void;
+export interface ProviderRpcError extends Error {
+    message: string;
+    code?: number;
+    data?: {
+        [key: string]: any;
+    };
+}
+export interface ProviderMessageRequestHandler {
+    sendMessageRequest(message: ProviderMessageRequest): Promise<ProviderMessageResponse>;
+}
+export interface ProviderMessageTransport {
+    handleMessage(message: ProviderMessage<any>): void;
+    sendMessage(message: ProviderMessage<any>): void;
+}
+export declare type WindowSessionParam = 'sid' | 'net' | 'intent';
+export interface WindowSessionParams extends URLSearchParams {
+    get(name: WindowSessionParam): string | null;
+    set(name: WindowSessionParam, value: string): void;
+}
+export declare class WindowSessionParams extends URLSearchParams {
+    static new(init?: Record<WindowSessionParam, string> | string): WindowSessionParams;
+}
+export interface TransportSession {
+    sessionId?: string | null;
+    networkId?: string | number | null;
+    intent?: OpenWalletIntent;
+}
+export declare enum EventType {
+    OPEN = "open",
+    CLOSE = "close",
+    MESSAGE = "message",
+    CONNECT = "connect",
+    DISCONNECT = "disconnect",
+    ACCOUNTS_CHANGED = "accountsChanged",
+    CHAIN_CHANGED = "chainChanged",
+    NETWORKS = "networks",
+    WALLET_CONTEXT = "walletContext",
+    INIT = "init",
+    DEBUG = "_debug"
+}
+export interface WalletEventTypes {
+    'open': (openInfo: {
+        chainId?: string;
+        sessionId?: string;
+        session?: WalletSession;
+        error?: string;
+    }) => void;
+    'close': (error?: ProviderRpcError) => void;
+    'connect': (connectDetails: ConnectDetails) => void;
+    'disconnect': (error?: ProviderRpcError) => void;
+    'accountsChanged': (accounts: string[]) => void;
+    'chainChanged': (chainIdHex: string) => void;
+    'networks': (networks: NetworkConfig[]) => void;
+    'walletContext': (walletContext: WalletContext) => void;
+}
+export interface ProviderEventTypes extends WalletEventTypes {
+    'message': (message: ProviderMessageResponse) => void;
+}
+export declare enum OpenState {
+    CLOSED = 0,
+    OPENING = 1,
+    OPENED = 2
+}
+export declare enum InitState {
+    NIL = 0,
+    SENT_NONCE = 1,
+    OK = 2
+}
+export interface ConnectOptions {
+    networkId?: string | number;
+    app?: string;
+    origin?: string;
+    expiry?: number;
+    authorize?: boolean;
+    askForEmail?: boolean;
+    refresh?: boolean;
+    keepWalletOpened?: boolean;
+}
+export interface ConnectDetails {
+    chainId?: string;
+    error?: string;
+    connected: boolean;
+    session?: WalletSession;
+    proof?: ETHAuthProof;
+    email?: string;
+}
+export declare type PromptConnectDetails = Pick<ConnectDetails, 'chainId' | 'error' | 'connected' | 'proof' | 'email'>;
+export declare type OpenWalletIntent = {
+    type: 'connect';
+    options?: ConnectOptions;
+} | {
+    type: 'jsonRpcRequest';
+    method: string;
+};
+export interface MessageToSign {
+    message?: string;
+    typedData?: TypedData;
+    chainId?: number;
+}
+export interface ETHAuthProof {
+    typedData: TypedData;
+    proofString: string;
+}
+export interface WalletSession {
+    walletContext?: WalletContext;
+    accountAddress?: string;
+    networks?: NetworkConfig[];
+    providerCache?: {
+        [key: string]: any;
+    };
+}
+export declare class ProviderError extends Error {
+    constructor(message?: string);
+}
+export declare const ErrSignedInRequired: ProviderError;
+export interface TypedEventEmitter<Events> {
+    addListener<E extends keyof Events>(event: E, listener: Events[E]): this;
+    on<E extends keyof Events>(event: E, listener: Events[E]): this;
+    once<E extends keyof Events>(event: E, listener: Events[E]): this;
+    prependListener<E extends keyof Events>(event: E, listener: Events[E]): this;
+    prependOnceListener<E extends keyof Events>(event: E, listener: Events[E]): this;
+    off<E extends keyof Events>(event: E, listener: Events[E]): this;
+    removeAllListeners<E extends keyof Events>(event?: E): this;
+    removeListener<E extends keyof Events>(event: E, listener: Events[E]): this;
+    emit<E extends keyof Events>(event: E, ...args: Arguments<Events[E]>): boolean;
+    eventNames(): (keyof Events | string | symbol)[];
+    listeners<E extends keyof Events>(event: E): Function[];
+    listenerCount<E extends keyof Events>(event: E): number;
+}
+declare type Arguments<T> = [T] extends [(...args: infer U) => any] ? U : [T] extends [void] ? [] : [T];
+export {};

package/dist/declarations/src/utils.d.ts

@@ -0,0 +1,14 @@
+import { BigNumberish, BytesLike } from 'ethers';
+import { WalletConfig, DecodedSignature } from '@0xsequence/config';
+import { Web3Provider } from './provider';
+export declare const isValidSignature: (address: string, digest: Uint8Array, sig: string, provider: Web3Provider, chainId?: number | undefined, walletContext?: any) => Promise<boolean | undefined>;
+export declare const recoverWalletConfig: (address: string, digest: BytesLike, signature: string | DecodedSignature, chainId: BigNumberish, walletContext?: any) => Promise<WalletConfig>;
+export declare const isBrowserExtension: () => boolean;
+export declare class LocalStore<T extends Object = string> {
+    def?: T | undefined;
+    readonly key: string;
+    constructor(key: string, def?: T | undefined);
+    get(): T | undefined;
+    set(val: T | undefined): void;
+    del(): void;
+}