@0xsequence/provider 1.0.4 → 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';
-export * from './types';
-export * from './wallet';
-export * from './provider';
-export * from './utils';
+export * from "./transports/index.js";
+export * from "./types.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';
-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/base-provider-transport.d.ts

@@ -1,4 +1,4 @@
-import { ProviderTransport, ProviderMessage, ProviderMessageRequest, ProviderEventTypes, ProviderMessageResponse, ProviderMessageResponseCallback, OpenState, OpenWalletIntent, ConnectDetails, WalletSession, ProviderRpcError, InitState, TypedEventEmitter } from '../types';
+import { ProviderTransport, ProviderMessage, ProviderMessageRequest, ProviderEventTypes, ProviderMessageResponse, ProviderMessageResponseCallback, OpenState, OpenWalletIntent, ConnectDetails, WalletSession, ProviderRpcError, InitState, TypedEventEmitter } from "../types.js";
 import { NetworkConfig, JsonRpcRequest, JsonRpcResponseCallback } from '@0xsequence/network';
 import { commons } from '@0xsequence/core';
 export declare const PROVIDER_OPEN_TIMEOUT = 30000;

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

@@ -1,5 +1,5 @@
-import { WalletTransport, ProviderMessage, ProviderMessageRequest, ProviderMessageResponse, ProviderRpcError, InitState, ConnectDetails, WalletSession, TransportSession } from '../types';
-import { WalletRequestHandler } from './wallet-request-handler';
+import { WalletTransport, ProviderMessage, ProviderMessageRequest, ProviderMessageResponse, ProviderRpcError, InitState, ConnectDetails, WalletSession, TransportSession } from "../types.js";
+import { WalletRequestHandler } from "./wallet-request-handler.js";
 import { NetworkConfig, JsonRpcRequest, JsonRpcResponseCallback } from '@0xsequence/network';
 import { commons } from '@0xsequence/core';
 export declare abstract class BaseWalletTransport implements WalletTransport {

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

@@ -1,5 +1,5 @@
 import { EventEmitter2 as EventEmitter } from 'eventemitter2';
-import { ProviderMessageResponseCallback, ProviderMessageRequest, ProviderMessageResponse } from '../../types';
+import { ProviderMessageResponseCallback, ProviderMessageRequest, ProviderMessageResponse } from "../../types.js";
 export interface Stream {
     on(ev: string | symbol, fn: (...args: any[]) => void): void;
     writable: boolean;

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

@@ -1,6 +1,6 @@
-import { WalletRequestHandler } from '../wallet-request-handler';
-import { BaseWalletTransport } from '../base-wallet-transport';
-import { ProviderMessage } from '../../types';
+import { WalletRequestHandler } from "../wallet-request-handler.js";
+import { BaseWalletTransport } from "../base-wallet-transport.js";
+import { ProviderMessage } from "../../types.js";
 import { Runtime } from 'webextension-polyfill';
 export declare const CHANNEL_ID = "sequence-extension-message-handler";
 export declare class ExtensionMessageHandler extends BaseWalletTransport {

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

@@ -1,5 +1,5 @@
-import { OpenWalletIntent, ProviderMessage } from '../../types';
-import { BaseProviderTransport } from '../base-provider-transport';
+import { OpenWalletIntent, ProviderMessage } from "../../types.js";
+import { BaseProviderTransport } from "../base-provider-transport.js";
 import { Runtime } from 'webextension-polyfill';
 export declare class ExtensionMessageProvider extends BaseProviderTransport {
     constructor(runtime: Runtime.Static);

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

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

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

@@ -1,8 +1,8 @@
-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';
-export * from './unreal-transport';
+export * from "./base-provider-transport.js";
+export * from "./base-wallet-transport.js";
+export * from "./proxy-transport/index.js";
+export * from "./mux-transport/index.js";
+export * from "./window-transport/index.js";
+export * from "./wallet-request-handler.js";
+export * from "./extension-transport/index.js";
+export * from "./unreal-transport/index.js";

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

@@ -1 +1 @@
-export * from './mux-message-provider';
+export * from "./mux-message-provider.js";

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';
+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/proxy-transport/index.d.ts

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

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

@@ -1,4 +1,4 @@
-import { ProviderMessage, ProviderMessageTransport, ProviderEventTypes, TypedEventEmitter } from '../../types';
+import { ProviderMessage, ProviderMessageTransport, ProviderEventTypes, TypedEventEmitter } from "../../types.js";
 export declare class ProxyMessageChannel {
     app: ProxyMessageChannelPort;
     wallet: ProxyMessageChannelPort;

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

@@ -1,7 +1,7 @@
-import { BaseWalletTransport } from '../base-wallet-transport';
-import { WalletRequestHandler } from '../wallet-request-handler';
-import { ProviderMessage } from '../../types';
-import { ProxyMessageChannelPort } from './proxy-message-channel';
+import { BaseWalletTransport } from "../base-wallet-transport.js";
+import { WalletRequestHandler } from "../wallet-request-handler.js";
+import { ProviderMessage } from "../../types.js";
+import { ProxyMessageChannelPort } from "./proxy-message-channel.js";
 export declare class ProxyMessageHandler extends BaseWalletTransport {
     private port;
     constructor(walletRequestHandler: WalletRequestHandler, port: ProxyMessageChannelPort);

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

@@ -1,6 +1,6 @@
-import { BaseProviderTransport } from '../base-provider-transport';
-import { ProviderMessage, OpenWalletIntent } from '../../types';
-import { ProxyMessageChannelPort } from './proxy-message-channel';
+import { BaseProviderTransport } from "../base-provider-transport.js";
+import { ProviderMessage, OpenWalletIntent } from "../../types.js";
+import { ProxyMessageChannelPort } from "./proxy-message-channel.js";
 export declare class ProxyMessageProvider extends BaseProviderTransport {
     private port;
     constructor(port: ProxyMessageChannelPort);

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

@@ -1,2 +1,2 @@
-export * from './unreal-message-provider';
-export * from './unreal-message-handler';
+export * from "./unreal-message-provider.js";
+export * from "./unreal-message-handler.js";

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

@@ -1,6 +1,6 @@
-import { ProviderMessage } from '../../types';
-import { WalletRequestHandler } from '../wallet-request-handler';
-import { BaseWalletTransport } from '../base-wallet-transport';
+import { ProviderMessage } from "../../types.js";
+import { WalletRequestHandler } from "../wallet-request-handler.js";
+import { BaseWalletTransport } from "../base-wallet-transport.js";
 /**
  * Initialized on Wallet side
  */

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

@@ -1,5 +1,5 @@
-import { OpenWalletIntent, ProviderMessage } from '../../types';
-import { BaseProviderTransport } from '../base-provider-transport';
+import { OpenWalletIntent, ProviderMessage } from "../../types.js";
+import { BaseProviderTransport } from "../base-provider-transport.js";
 /**
  * Initialized on dApp side
  */

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

@@ -2,7 +2,7 @@ import { Account } from '@0xsequence/account';
 import { commons } from '@0xsequence/core';
 import { NetworkConfig, JsonRpcHandler, JsonRpcRequest, JsonRpcResponseCallback } from '@0xsequence/network';
 import { providers } from 'ethers';
-import { ProviderMessageRequest, ProviderMessageResponse, ProviderMessageRequestHandler, MessageToSign, ProviderRpcError, ConnectOptions, ConnectDetails, PromptConnectDetails, WalletSession, OpenWalletIntent, ProviderEventTypes } from '../types';
+import { ProviderMessageRequest, ProviderMessageResponse, ProviderMessageRequestHandler, MessageToSign, ProviderRpcError, ConnectOptions, ConnectDetails, PromptConnectDetails, WalletSession, OpenWalletIntent, ProviderEventTypes } from "../types.js";
 type ExternalProvider = providers.ExternalProvider;
 export interface WalletSignInOptions {
     connect?: boolean;
@@ -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/transports/window-transport/index.d.ts

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

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

@@ -1,6 +1,6 @@
-import { ProviderMessage } from '../../types';
-import { WalletRequestHandler } from '../wallet-request-handler';
-import { BaseWalletTransport } from '../base-wallet-transport';
+import { ProviderMessage } from "../../types.js";
+import { WalletRequestHandler } from "../wallet-request-handler.js";
+import { BaseWalletTransport } from "../base-wallet-transport.js";
 export declare class WindowMessageHandler extends BaseWalletTransport {
     protected parentWindow: Window;
     private _isPopup;