@0xsequence/provider 1.0.5 → 1.1.0

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

@@ -0,0 +1,74 @@
+import { JsonRpcRequest, NetworkConfig } from "@0xsequence/network";
+import { ConnectDetails, ConnectOptions, ItemStore, MuxTransportTemplate, OpenWalletIntent, OptionalChainId, OptionalEIP6492, ProviderTransport, WalletEventTypes, WalletSession } from "./index.js";
+import { commons } from "@0xsequence/core";
+import { TypedData } from "@0xsequence/utils";
+import { ethers } from "ethers";
+/**
+ *  This session class is meant to persist the state of the wallet connection
+ *  whitin the dapp. This enables the client to retain the wallet address (and some more)
+ *  even if the user refreshes the page. Otherwise we would have to open the popup again.
+ */
+export declare class SequenceClientSession {
+    private store;
+    static readonly SESSION_LOCALSTORE_KEY = "@sequence.session";
+    constructor(store: ItemStore);
+    connectedSession(): Required<WalletSession>;
+    hasSession(): boolean;
+    setSession(session: WalletSession): void;
+    getSession(): WalletSession | undefined;
+    clearSession(): Promise<void>;
+}
+/**
+ *  The wallet webapp doesn't really care what's the "default chain" for the user.
+ *  so we don't even bother to send this information to the wallet. Instead, we
+ *  track it locally using storage, that way the data stays always in sync.
+ */
+export declare class DefaultChainIdTracker {
+    private store;
+    private startingChainId;
+    static readonly SESSION_CHAIN_ID_KEY = "@sequence.session.defaultChainId";
+    callbacks: ((chainId: number) => void)[];
+    constructor(store: ItemStore, startingChainId?: number);
+    onDefaultChainIdChanged(callback: (chainId: number) => void): () => void;
+    setDefaultChainId(chainId: number): void;
+    getDefaultChainId(): number;
+}
+/**
+ *  This is a wallet client for sequence wallet-webapp. It connects using *some* transport
+ *  and it allows to perform all sequence specific (or write) operations related to the wallet.
+ *
+ *  It doesn't implement a full ethereum Provider, it doesn't include read-only methods.
+ */
+export declare class SequenceClient {
+    private readonly session;
+    private readonly defaultChainId;
+    private readonly callbacks;
+    readonly transport: ProviderTransport;
+    constructor(transport: ProviderTransport | MuxTransportTemplate, store: ItemStore, defaultChainId?: number);
+    registerCallback<K extends keyof WalletEventTypes>(eventName: K, callback: WalletEventTypes[K]): () => void;
+    onOpen(callback: WalletEventTypes['open']): () => void;
+    onClose(callback: WalletEventTypes['close']): () => void;
+    onConnect(callback: WalletEventTypes['connect']): () => void;
+    onDisconnect(callback: WalletEventTypes['disconnect']): () => void;
+    onNetworks(callback: WalletEventTypes['networks']): () => void;
+    onAccountsChanged(callback: WalletEventTypes['accountsChanged']): () => void;
+    onWalletContext(callback: WalletEventTypes['walletContext']): () => void;
+    onDefaultChainIdChanged(callback: WalletEventTypes['chainChanged']): () => void;
+    getChainId(): number;
+    setDefaultChainId(chainId: number): void;
+    openWallet(path?: string, intent?: OpenWalletIntent): Promise<boolean>;
+    closeWallet(): void;
+    isOpened(): boolean;
+    isConnected(): boolean;
+    getSession(): WalletSession | undefined;
+    getAddress(): string;
+    connect(options: ConnectOptions): Promise<ConnectDetails>;
+    disconnect(): Promise<void>;
+    send(request: JsonRpcRequest, chainId?: number): Promise<any>;
+    getNetworks(pull?: boolean): Promise<NetworkConfig[]>;
+    signMessage(message: ethers.BytesLike, options?: OptionalEIP6492 & OptionalChainId): Promise<string>;
+    signTypedData(typedData: TypedData, options?: OptionalEIP6492 & OptionalChainId): Promise<string>;
+    sendTransaction(tx: (ethers.providers.TransactionRequest[] | ethers.providers.TransactionRequest), options?: OptionalChainId): Promise<string>;
+    getWalletContext(): Promise<commons.context.VersionedContext>;
+    getOnchainWalletConfig(options?: OptionalChainId): Promise<commons.config.Config>;
+}

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

@@ -1,5 +1,7 @@
 export * from "./transports/index.js";
 export * from "./types.js";
-export * from "./wallet.js";
 export * from "./provider.js";
 export * from "./utils.js";
+export * from "./client.js";
+export * from "./signer.js";
+export * from "./init.js";

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

@@ -0,0 +1,25 @@
+import { ChainIdLike, NetworkConfig } from "@0xsequence/network";
+import { MuxTransportTemplate } from "./transports/index.js";
+import { ItemStore } from "./utils.js";
+import { SequenceProvider } from "./provider.js";
+export interface ProviderConfig {
+    localStorage?: ItemStore;
+    defaultNetwork?: ChainIdLike;
+    networks?: Partial<NetworkConfig>[];
+    transports?: MuxTransportTemplate;
+}
+export declare const DefaultProviderConfig: {
+    transports: {
+        walletAppURL: string;
+        windowTransport: {
+            enabled: boolean;
+        };
+        proxyTransport: {
+            enabled: boolean;
+        };
+    };
+    defaultNetwork: number;
+};
+export declare const initWallet: (partialConfig?: Partial<ProviderConfig>) => SequenceProvider;
+export declare const unregisterWallet: () => void;
+export declare const getWallet: () => SequenceProvider;

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

@@ -1,68 +1,132 @@
-import { ethers, BytesLike, Bytes, providers, TypedDataDomain, TypedDataField } from 'ethers';
-import { NetworkConfig, ChainIdLike, JsonRpcHandler, JsonRpcFetchFunc, JsonRpcRequest, JsonRpcResponseCallback, JsonRpcSender } from '@0xsequence/network';
-import { Signer } from '@0xsequence/wallet';
-import { Relayer } from '@0xsequence/relayer';
-import { Deferrable } from '@0xsequence/utils';
-import { commons } from '@0xsequence/core';
-import { Account, AccountStatus } from '@0xsequence/account';
-import { ExtendedTransactionRequest } from "./extended.js";
-export declare class Web3Provider extends providers.Web3Provider implements JsonRpcHandler {
-    static isSequenceProvider(cand: any): cand is Web3Provider;
-    readonly _sender: JsonRpcSender;
-    readonly _isSequenceProvider: boolean;
-    readonly _defaultChainId?: number;
-    constructor(provider: providers.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>;
-    request(request: {
-        method: string;
-        params?: Array<any>;
-        chainId?: number;
-    }): Promise<any>;
-    getSigner(): Web3Signer;
-    getChainId(): Promise<number>;
+import { ethers } from "ethers";
+import { SequenceClient } from "./client.js";
+import { ChainIdLike, NetworkConfig } from "@0xsequence/network";
+import { ConnectDetails, ConnectOptions, EIP1193Provider, OpenWalletIntent, OptionalChainIdLike, WalletSession } from "./types.js";
+import { commons } from "@0xsequence/core";
+import { WalletUtils } from "./utils/index.js";
+import { SequenceSigner, SingleNetworkSequenceSigner } from "./signer.js";
+export interface ISequenceProvider {
+    readonly _isSequenceProvider: true;
+    connect(options?: ConnectOptions): Promise<ConnectDetails>;
+    disconnect(): void;
+    isConnected(): boolean;
+    getSession(): WalletSession | undefined;
+    listAccounts(): string[];
+    getAddress(): string;
     getNetworks(): Promise<NetworkConfig[]>;
-}
-export declare function isSequenceProvider(provider: any): provider is Web3Provider;
-export declare class LocalWeb3Provider extends Web3Provider {
-    constructor(account: Account, networks?: NetworkConfig[]);
-}
-interface TypedDataSigner {
-    _signTypedData(domain: TypedDataDomain, types: Record<string, Array<TypedDataField>>, value: Record<string, any>): Promise<string>;
-}
-export declare class Web3Signer extends Signer implements TypedDataSigner {
-    readonly provider: Web3Provider;
-    readonly defaultChainId?: number;
-    constructor(provider: Web3Provider, defaultChainId?: number);
-    _address: string;
-    _index: number;
-    _context: commons.context.VersionedContext;
-    _networks: NetworkConfig[];
-    private _providers;
-    getAddress(): Promise<string>;
-    signTransaction(transaction: Deferrable<ethers.providers.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>;
+    getChainId(): number;
+    setDefaultChainId(chainId: ChainIdLike): void;
+    isOpened(): boolean;
+    openWallet(path?: string, intent?: OpenWalletIntent): Promise<boolean>;
+    closeWallet(): void;
+    getProvider(): SequenceProvider;
+    getProvider(chainId: ChainIdLike): SingleNetworkSequenceProvider;
+    getProvider(chainId?: ChainIdLike): SequenceProvider | SingleNetworkSequenceProvider;
+    getSigner(): SequenceSigner;
+    getSigner(chainId: ChainIdLike): SingleNetworkSequenceSigner;
+    getSigner(chainId?: ChainIdLike): SequenceSigner | SingleNetworkSequenceSigner;
     getWalletContext(): Promise<commons.context.VersionedContext>;
     getWalletConfig(chainId?: ChainIdLike): Promise<commons.config.Config>;
-    getWalletState(chainId?: ChainIdLike): Promise<AccountStatus>;
+    utils: WalletUtils;
+}
+export declare class SequenceProvider extends ethers.providers.BaseProvider implements ISequenceProvider, EIP1193Provider {
+    readonly client: SequenceClient;
+    private readonly providerFor;
+    readonly networks: NetworkConfig[];
+    private readonly singleNetworkProviders;
+    readonly _isSequenceProvider = true;
+    readonly utils: WalletUtils;
+    readonly signer: SequenceSigner;
+    constructor(client: SequenceClient, providerFor: (networkId: number) => ethers.providers.JsonRpcProvider, networks?: NetworkConfig[]);
+    getSigner(): SequenceSigner;
+    getSigner(chainId: ChainIdLike): SingleNetworkSequenceSigner;
+    getSigner(chainId?: ChainIdLike): SequenceSigner | SingleNetworkSequenceSigner;
+    connect(options: ConnectOptions): Promise<ConnectDetails>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    getSession(): WalletSession | undefined;
+    listAccounts(): string[];
+    getAddress(): string;
     getNetworks(): Promise<NetworkConfig[]>;
-    getSigners(): Promise<string[]>;
-    signMessage(message: BytesLike, chainId?: ChainIdLike, sequenceVerified?: boolean): Promise<string>;
-    signTypedData(domain: TypedDataDomain, types: Record<string, Array<TypedDataField>>, message: Record<string, any>, chainId?: ChainIdLike, sequenceVerified?: boolean): Promise<string>;
-    sendTransaction(transaction: Deferrable<ExtendedTransactionRequest>, chainId?: ChainIdLike): Promise<commons.transaction.TransactionResponse>;
-    sendTransactionBatch(transactions: Deferrable<ethers.providers.TransactionRequest[]>, chainId?: ChainIdLike): Promise<ethers.providers.TransactionResponse>;
-    signTransactions(transaction: Deferrable<ethers.providers.TransactionRequest>, chainId?: ChainIdLike): Promise<commons.transaction.SignedTransactionBundle>;
-    sendSignedTransactions(signedTxs: commons.transaction.SignedTransactionBundle, chainId?: ChainIdLike): Promise<ethers.providers.TransactionResponse>;
-    updateConfig(newConfig?: commons.config.Config): Promise<[commons.config.Config, ethers.providers.TransactionResponse | undefined]>;
-    publishConfig(): Promise<ethers.providers.TransactionResponse | undefined>;
-    isDeployed(chainId?: ChainIdLike): Promise<boolean>;
-    _legacySignMessage(message: Bytes | string, chainId?: ChainIdLike): Promise<string>;
-    _signTypedData(domain: TypedDataDomain, types: Record<string, Array<TypedDataField>>, message: Record<string, any>, chainId?: ChainIdLike): Promise<string>;
-    sendUncheckedTransaction(transaction: Deferrable<ExtendedTransactionRequest>, chainId?: ChainIdLike): Promise<string>;
-    connectUnchecked(): ethers.providers.JsonRpcSigner;
-    unlock(password: string): Promise<boolean>;
+    getChainId(): number;
+    setDefaultChainId(chainId: ChainIdLike): void;
+    isOpened(): boolean;
+    closeWallet(): void;
+    getWalletContext(): Promise<commons.context.VersionedContext>;
+    getWalletConfig(chainId?: ChainIdLike): Promise<commons.config.Config>;
+    authorize(options: ConnectOptions): Promise<ConnectDetails>;
+    openWallet(path?: string, intent?: OpenWalletIntent): Promise<boolean>;
+    toChainId(chainId: ChainIdLike): number;
+    toChainId(chainId?: ChainIdLike): number | undefined;
+    /**
+     *  Resolves the chainId to use for the given request. If no chainId is provided,
+     *  it uses the chainId defined by the client (default chainId). This can be
+     *  overriden to build a single-network SequenceProvider.
+     */
+    protected useChainId(chainId?: ChainIdLike): Promise<number>;
+    /**
+     *  This generates a provider that ONLY works for the given chainId.
+     *  the generated provider can't switch networks, and can't handle requests
+     *  for other networks.
+     */
+    getProvider(): SequenceProvider;
+    getProvider(chainId: ChainIdLike): SingleNetworkSequenceProvider;
+    getProvider(chainId?: ChainIdLike): SequenceProvider | SingleNetworkSequenceProvider;
+    /**
+     *  This returns a subprovider, this is a regular non-sequence provider that
+     *  can be used to fulfill read only requests on a given network.
+     */
+    _getSubprovider(chainId?: ChainIdLike): Promise<ethers.providers.JsonRpcProvider>;
+    perform(method: string, params: any): Promise<any>;
+    send(method: string, params: any): Promise<any>;
+    request(request: {
+        method: string;
+        params?: any[] | undefined;
+    }): Promise<any>;
+    detectNetwork(): Promise<ethers.providers.Network>;
+    waitForTransaction(transactionHash: string, confirmations?: number, timeout?: number, optionals?: OptionalChainIdLike): Promise<ethers.providers.TransactionReceipt>;
+    getBlockNumber(optionals?: OptionalChainIdLike): Promise<number>;
+    getGasPrice(optionals?: OptionalChainIdLike): Promise<ethers.BigNumber>;
+    getBalance(addressOrName: string | Promise<string>, blockTag?: ethers.providers.BlockTag | Promise<ethers.providers.BlockTag>, optionals?: OptionalChainIdLike): Promise<ethers.BigNumber>;
+    getTransactionCount(addressOrName: string | Promise<string>, blockTag?: ethers.providers.BlockTag | Promise<ethers.providers.BlockTag>, optionals?: OptionalChainIdLike): Promise<number>;
+    getCode(addressOrName: string | Promise<string>, blockTag?: ethers.providers.BlockTag | Promise<ethers.providers.BlockTag>, optionals?: OptionalChainIdLike): Promise<string>;
+    getStorageAt(addressOrName: string | Promise<string>, position: ethers.BigNumberish | Promise<ethers.BigNumberish>, blockTag?: ethers.providers.BlockTag | Promise<ethers.providers.BlockTag>, optionals?: OptionalChainIdLike): Promise<string>;
+    call(transaction: ethers.utils.Deferrable<ethers.providers.TransactionRequest>, blockTag?: ethers.providers.BlockTag | Promise<ethers.providers.BlockTag>, optionals?: OptionalChainIdLike): Promise<string>;
+    estimateGas(transaction: ethers.utils.Deferrable<ethers.providers.TransactionRequest>, optionals?: OptionalChainIdLike): Promise<ethers.BigNumber>;
+    getBlock(blockHashOrBlockTag: ethers.providers.BlockTag | string | Promise<ethers.providers.BlockTag | string>, optionals?: OptionalChainIdLike): Promise<ethers.providers.Block>;
+    getTransaction(transactionHash: string | Promise<string>, optionals?: OptionalChainIdLike): Promise<ethers.providers.TransactionResponse>;
+    getLogs(filter: ethers.providers.Filter | Promise<ethers.providers.Filter>, optionals?: OptionalChainIdLike): Promise<ethers.providers.Log[]>;
+    supportsENS(): Promise<boolean>;
+    getResolver(name: string): Promise<ethers.providers.Resolver | null>;
+    resolveName(name: string | Promise<string>): Promise<string | null>;
+    lookupAddress(address: string | Promise<string>): Promise<string | null>;
+    getAvatar(nameOrAddress: string): Promise<string | null>;
+    static is: (provider: any) => provider is SequenceProvider;
+}
+/**
+ *  This is the same provider, but it only allows a single network at a time.
+ *  the network defined by the constructor is the only one that can be used.
+ *
+ *  Attempting to call any method with a different network will throw an error.
+ *  Attempting to change the network of this provider will throw an error.
+ *
+ *  NOTICE: These networks won't support ENS unless they are the mainnet.
+ */
+export declare class SingleNetworkSequenceProvider extends SequenceProvider {
+    readonly chainId: ChainIdLike;
+    readonly _isSingleNetworkSequenceProvider = true;
+    constructor(client: SequenceClient, providerFor: (networkId: number) => ethers.providers.JsonRpcProvider, chainId: ChainIdLike);
+    private _useChainId;
+    protected useChainId(chainId?: ChainIdLike): Promise<number>;
+    getChainId(): number;
+    getNetwork(): Promise<NetworkConfig>;
+    /**
+     *  Override getProvider and getSigner so they always use `useChainId`
+     *  this way they can't return providers and signers that can switch networks,
+     *  or that don't match the chainId of this signer.
+     */
+    getProvider(chainId?: ChainIdLike): SingleNetworkSequenceProvider;
+    getSigner(chainId?: ChainIdLike): SingleNetworkSequenceSigner;
+    setDefaultChainId(_chainId: ChainIdLike): void;
+    static is(cand: any): cand is SingleNetworkSequenceProvider;
 }
-export {};

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

@@ -0,0 +1,87 @@
+import { ethers } from "ethers";
+import { SequenceProvider, SingleNetworkSequenceProvider } from "./provider.js";
+import { SequenceClient } from "./client.js";
+import { commons } from "@0xsequence/core";
+import { ChainIdLike, NetworkConfig } from "@0xsequence/network";
+import { WalletUtils } from "./utils/index.js";
+import { OptionalChainIdLike, OptionalEIP6492 } from "./types.js";
+export interface ISequenceSigner extends ethers.Signer {
+    getProvider(): SequenceProvider;
+    getProvider(chainId: ChainIdLike): SingleNetworkSequenceProvider;
+    getProvider(chainId?: ChainIdLike): SequenceProvider | SingleNetworkSequenceProvider;
+    getSigner(): SequenceSigner;
+    getSigner(chainId: ChainIdLike): SingleNetworkSequenceSigner;
+    getSigner(chainId?: ChainIdLike): SequenceSigner | SingleNetworkSequenceSigner;
+    getWalletConfig(chainId?: ChainIdLike): Promise<commons.config.Config>;
+    getNetworks(): Promise<NetworkConfig[]>;
+    signMessage(message: ethers.BytesLike, options?: OptionalChainIdLike & OptionalEIP6492): Promise<string>;
+    signTypedData(domain: ethers.TypedDataDomain, types: Record<string, Array<ethers.TypedDataField>>, message: Record<string, any>, options?: OptionalChainIdLike & OptionalEIP6492): Promise<string>;
+    sendTransaction(transaction: (ethers.utils.Deferrable<ethers.providers.TransactionRequest>[] | ethers.utils.Deferrable<ethers.providers.TransactionRequest>), options?: OptionalChainIdLike): Promise<commons.transaction.TransactionResponse>;
+    utils: WalletUtils;
+}
+export declare class SequenceSigner implements ISequenceSigner {
+    client: SequenceClient;
+    provider: SequenceProvider;
+    private readonly singleNetworkSigners;
+    readonly _isSigner: boolean;
+    readonly _isSequenceSigner: boolean;
+    get utils(): WalletUtils;
+    constructor(client: SequenceClient, provider: SequenceProvider);
+    getAddress(): Promise<string>;
+    connect(provider: ethers.providers.Provider): SequenceSigner;
+    getSigner(): SequenceSigner;
+    getSigner(chainId: ChainIdLike): SingleNetworkSequenceSigner;
+    getSigner(chainId?: ChainIdLike): SingleNetworkSequenceSigner | SequenceSigner;
+    /**
+     *  Resolves the chainId to use for the given request. If no chainId is provided,
+     *  it uses the chainId defined by the client (default chainId). This can be
+     *  overriden to build a single-network SequenceProvider.
+     */
+    protected useChainId(chainId?: ChainIdLike): number;
+    signMessage(message: ethers.BytesLike, options?: OptionalChainIdLike & OptionalEIP6492): Promise<string>;
+    signTypedData(domain: ethers.TypedDataDomain, types: Record<string, Array<ethers.TypedDataField>>, message: Record<string, any>, options?: OptionalChainIdLike & OptionalEIP6492): Promise<string>;
+    getProvider(): SequenceProvider;
+    getProvider(chainId: ChainIdLike): SingleNetworkSequenceProvider;
+    getProvider(chainId?: ChainIdLike): SingleNetworkSequenceProvider | SequenceProvider;
+    sendTransaction(transaction: (ethers.utils.Deferrable<ethers.providers.TransactionRequest>[] | ethers.utils.Deferrable<ethers.providers.TransactionRequest>), options?: OptionalChainIdLike): Promise<ethers.providers.TransactionResponse>;
+    getWalletConfig(chainId?: ChainIdLike | undefined): Promise<commons.config.Config>;
+    getNetworks(): Promise<NetworkConfig[]>;
+    getBalance(blockTag?: ethers.providers.BlockTag | undefined, optionals?: OptionalChainIdLike): Promise<ethers.BigNumber>;
+    estimateGas(transaction: ethers.utils.Deferrable<ethers.providers.TransactionRequest>, optionals?: OptionalChainIdLike): Promise<ethers.BigNumber>;
+    call(transaction: ethers.utils.Deferrable<ethers.providers.TransactionRequest>, blockTag?: ethers.providers.BlockTag | undefined, optionals?: OptionalChainIdLike): Promise<string>;
+    getChainId(): Promise<number>;
+    getGasPrice(optionals?: OptionalChainIdLike): Promise<ethers.BigNumber>;
+    getFeeData(optionals?: OptionalChainIdLike): Promise<ethers.providers.FeeData>;
+    resolveName(name: string): Promise<string>;
+    _checkProvider(_operation?: string | undefined): void;
+    populateTransaction(_transaction: ethers.utils.Deferrable<ethers.providers.TransactionRequest>): Promise<ethers.providers.TransactionRequest>;
+    checkTransaction(_transaction: ethers.utils.Deferrable<ethers.providers.TransactionRequest>): ethers.utils.Deferrable<ethers.providers.TransactionRequest>;
+    getTransactionCount(_blockTag?: ethers.providers.BlockTag | undefined): Promise<number>;
+    signTransaction(_transaction: ethers.utils.Deferrable<commons.transaction.Transactionish>): Promise<string>;
+    static is(cand: any): cand is SequenceSigner;
+}
+/**
+ *  This is the same provider, but it only allows a single network at a time.
+ *  the network defined by the constructor is the only one that can be used.
+ *
+ *  Attempting to call any method with a different network will throw an error.
+ *  Attempting to change the network of this provider will throw an error.
+ *
+ *  NOTICE: These networks won't support ENS unless they are the mainnet.
+ */
+export declare class SingleNetworkSequenceSigner extends SequenceSigner {
+    readonly chainId: ChainIdLike;
+    readonly _isSingleNetworkSequenceSigner = true;
+    constructor(client: SequenceClient, provider: SequenceProvider, chainId: ChainIdLike);
+    private _useChainId;
+    protected useChainId(chainId?: ChainIdLike): number;
+    getChainId(): Promise<number>;
+    /**
+     *  Override getProvider and getSigner so they always use `useChainId`
+     *  this way they can't return providers and signers that can switch networks,
+     *  or that don't match the chainId of this signer.
+     */
+    getProvider(chainId?: ChainIdLike): SingleNetworkSequenceProvider;
+    getSigner(chainId?: ChainIdLike | undefined): SingleNetworkSequenceSigner;
+    static is(cand: any): cand is SingleNetworkSequenceSigner;
+}

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

@@ -1,9 +1,30 @@
 import { ProviderMessage, ProviderTransport, ProviderEventTypes, ProviderMessageRequest, ProviderMessageResponse, WalletSession, OpenWalletIntent, ConnectDetails } from "../../types.js";
 import { JsonRpcRequest, JsonRpcResponseCallback } from '@0xsequence/network';
+import { ProxyMessageChannelPort } from "../proxy-transport/index.js";
+import { Runtime } from 'webextension-polyfill';
+export type MuxTransportTemplate = {
+    walletAppURL?: string;
+    windowTransport?: {
+        enabled: boolean;
+    };
+    proxyTransport?: {
+        enabled: boolean;
+        appPort?: ProxyMessageChannelPort;
+    };
+    extensionTransport?: {
+        enabled: boolean;
+        runtime: Runtime.Static;
+    };
+    unrealTransport?: {
+        enabled: boolean;
+    };
+};
+export declare function isMuxTransportTemplate(obj: any): obj is MuxTransportTemplate;
 export declare class MuxMessageProvider implements ProviderTransport {
     private messageProviders;
     private provider;
     constructor(...messageProviders: ProviderTransport[]);
+    static new(template: MuxTransportTemplate): MuxMessageProvider;
     add(...messageProviders: ProviderTransport[]): void;
     register: () => void;
     unregister: () => void;

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

@@ -19,7 +19,6 @@ export declare class WalletRequestHandler implements ExternalProvider, JsonRpcHa
     onConnectOptionsChange: ((connectOptions: ConnectOptions | undefined) => void) | undefined;
     constructor(account: Account | null | undefined, prompter: WalletUserPrompter | null, networks: NetworkConfig[]);
     defaultChainId(): number;
-    private findNetworkID;
     signIn(account: Account | null, options?: WalletSignInOptions): Promise<void>;
     signOut(): void;
     signerReset(): void;

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

@@ -1,6 +1,6 @@
 import { ETHAuthProof as AuthETHAuthProof } from '@0xsequence/auth';
 import { commons } from '@0xsequence/core';
-import { JsonRpcHandler, JsonRpcRequest, JsonRpcResponse, NetworkConfig, ProviderRpcError as NetworkProviderRpcError } from '@0xsequence/network';
+import { ChainIdLike, JsonRpcHandler, JsonRpcRequest, JsonRpcResponse, NetworkConfig, ProviderRpcError as NetworkProviderRpcError } from '@0xsequence/network';
 import { TypedData } from '@0xsequence/utils';
 export interface ProviderTransport extends JsonRpcHandler, ProviderMessageTransport, ProviderMessageRequestHandler {
     register(): void;
@@ -15,6 +15,7 @@ export interface ProviderTransport extends JsonRpcHandler, ProviderMessageTransp
     waitUntilOpened(): Promise<WalletSession | undefined>;
     waitUntilConnected(): Promise<ConnectDetails>;
 }
+export declare function isProviderTransport(transport: any): transport is ProviderTransport;
 export interface WalletTransport extends JsonRpcHandler, ProviderMessageTransport, ProviderMessageRequestHandler {
     register(): void;
     unregister(): void;
@@ -103,11 +104,8 @@ export declare enum InitState {
     OK = 2
 }
 export interface ConnectOptions {
-    /** Specifies the default network a dapp would like to connect to. This field
-     * is optional as it can be provided a number of different ways. */
-    networkId?: string | number;
     /** app name of the dapp which will be announced to user on connect screen */
-    app?: string;
+    app: string;
     /** custom protocol for auth redirect (unity/unreal) */
     appProtocol?: string;
     /** origin hint of the dapp's host opening the wallet. This value will automatically
@@ -129,6 +127,12 @@ export interface ConnectOptions {
     /** Options to further customize the wallet experience. */
     settings?: Settings;
 }
+export interface NetworkedConnectOptions extends ConnectOptions {
+    /** chainId is the chainId to connect to. If not specified, the default chainId
+     * will be used. This does not define a default chain id, it is only used for the connect
+     * authorization signature. */
+    networkId?: string | number;
+}
 /** Options to further customize the wallet experience. */
 export interface Settings {
     /** Specify a wallet theme. `light` and `dark` are the main themes, to use other available
@@ -192,7 +196,7 @@ export interface ConnectDetails {
 export type PromptConnectDetails = Pick<ConnectDetails, 'chainId' | 'error' | 'connected' | 'proof' | 'email'>;
 export type OpenWalletIntent = {
     type: 'connect';
-    options?: ConnectOptions;
+    options?: NetworkedConnectOptions;
 } | {
     type: 'openWithOptions';
     options?: ConnectOptions;
@@ -211,9 +215,6 @@ export interface WalletSession {
     walletContext?: commons.context.VersionedContext;
     accountAddress?: string;
     networks?: NetworkConfig[];
-    providerCache?: {
-        [key: string]: any;
-    };
 }
 export declare class ProviderError extends Error {
     constructor(message?: string);
@@ -234,4 +235,19 @@ export interface TypedEventEmitter<Events> {
     listenerCount<E extends keyof Events>(event: E): number;
 }
 type Arguments<T> = [T] extends [(...args: infer U) => any] ? U : [T] extends [void] ? [] : [T];
+export type OptionalChainIdLike = {
+    chainId?: ChainIdLike;
+} | undefined;
+export type OptionalChainId = {
+    chainId?: number;
+} | undefined;
+export type OptionalEIP6492 = {
+    eip6492?: boolean;
+} | undefined;
+export interface EIP1193Provider {
+    request: (request: {
+        method: string;
+        params?: Array<any>;
+    }) => Promise<any>;
+}
 export {};

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

@@ -1,14 +1,17 @@
 import { BytesLike, TypedDataDomain, TypedDataField } from 'ethers';
 import { ChainIdLike } from '@0xsequence/network';
 import { TypedData } from '@0xsequence/utils';
-import { Wallet } from "../wallet.js";
+import { SequenceSigner } from "../signer.js";
+/**
+ *  This class is redundant with the SequenceSigner class, but it is here for now to
+ *  maintain compatibility with the old wallet API. Eventually we should move these
+ *  methods to the SequenceSigner class and deprecate this class.
+ */
 export declare class WalletUtils {
-    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>;
+    signer: SequenceSigner;
+    constructor(signer: SequenceSigner);
+    signMessage(message: BytesLike, chainId?: ChainIdLike, eip6492?: boolean): Promise<string>;
+    signTypedData(domain: TypedDataDomain, types: Record<string, Array<TypedDataField>>, message: Record<string, any>, chainId?: ChainIdLike, eip6492?: boolean): Promise<string>;
     isValidSignature(address: string, digest: Uint8Array, signature: string, chainId: number): Promise<boolean>;
     isValidMessageSignature(address: string, message: string | Uint8Array, signature: string, chainId: number): Promise<boolean>;
     isValidTypedDataSignature(address: string, typedData: TypedData, signature: string, chainId: number): Promise<boolean>;

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

@@ -11,21 +11,27 @@ export declare const isBrowserExtension: () => boolean;
 export declare const isUnityPlugin: () => boolean;
 export declare const isWalletUpToDate: (status: AccountStatus) => boolean;
 export interface ItemStore {
-    getItem(key: string): Promise<string | null>;
-    setItem(key: string, value: string): Promise<void>;
-    removeItem(key: string): Promise<void>;
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+    onItemChange(key: string, cb: (value: string | null) => void): () => void;
 }
-export declare class LocalStorage {
-    private static _instance;
-    private constructor();
-    static getInstance(): ItemStore;
-    static use(instance: ItemStore): void;
+export declare class MemoryItemStore implements ItemStore {
+    private callbacks;
+    private store;
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+    onItemChange(key: string, cb: (value: string | null) => void): () => void;
 }
-export declare class LocalStore<T extends Object = string> {
-    def?: T | undefined;
-    readonly key: string;
-    constructor(key: string, def?: T | undefined);
-    get(): Promise<T | undefined>;
-    set(val: T | undefined): void;
-    del(): void;
+export declare class LocalStorage implements ItemStore {
+    private callbacks;
+    static isAvailable(): boolean;
+    constructor();
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+    onItemChange(key: string, cb: (value: string | null) => void): () => void;
 }
+export declare function useBestStore(): ItemStore;
+export declare function resolveArrayProperties<T>(object: Readonly<ethers.utils.Deferrable<T>> | Readonly<ethers.utils.Deferrable<T>>[]): Promise<T>;