@0xsequence/provider 2.3.17 → 2.3.19

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

@@ -1,13 +0,0 @@
-import { Databeat, Event as DatabeatEvent } from '@databeat/tracker';
-export declare enum AnalyticsEventType {
-    INIT = 0,
-    VIEW = 1,
-    SIGN_MESSAGE_REQUEST = 2,
-    SIGN_TYPED_DATA_REQUEST = 3,
-    SEND_TRANSACTION_REQUEST = 4
-}
-export type AnalyticsEventTypes = keyof typeof AnalyticsEventType;
-export type AnalyticsEvent = DatabeatEvent<AnalyticsEventTypes>;
-export declare class Analytics extends Databeat<AnalyticsEventTypes> {
-}
-export declare const setupAnalytics: (projectAccessKey: string, server?: string) => Analytics;

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

@@ -1,92 +0,0 @@
-import { 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 { Analytics } from "./analytics.js";
-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;
-}
-export type SequenceClientOptions = {
-    defaultChainId?: number;
-    defaultEIP6492?: boolean;
-    projectAccessKey?: string;
-    analytics?: boolean;
-};
-/**
- *  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.
- *s
- *  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;
-    readonly defaultEIP6492: boolean;
-    readonly projectAccessKey?: string;
-    readonly analytics?: Analytics;
-    constructor(transport: ProviderTransport | MuxTransportTemplate, store: ItemStore, options?: SequenceClientOptions);
-    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;
-    onChainChanged(callback: WalletEventTypes['chainChanged']): () => 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>;
-    request(request: {
-        method: string;
-        params?: any[];
-        chainId?: number;
-    }): Promise<any>;
-    getNetworks(pull?: boolean): Promise<NetworkConfig[]>;
-    private signMethod;
-    private signTypedDataMethod;
-    private mapSignMethod;
-    signMessage(message: ethers.BytesLike, options?: OptionalEIP6492 & OptionalChainId): Promise<string>;
-    signTypedData(typedData: TypedData, options?: OptionalEIP6492 & OptionalChainId): Promise<string>;
-    sendTransaction(tx: ethers.TransactionRequest[] | ethers.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,9 +0,0 @@
-export * from "./transactions.js";
-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";
-export * from "./analytics.js";

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

@@ -1,36 +0,0 @@
-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;
-    defaultEIP6492?: boolean;
-    networks?: Partial<NetworkConfig>[];
-    transports?: MuxTransportTemplate;
-    analytics?: boolean;
-}
-export declare const DefaultProviderConfig: {
-    transports: {
-        walletAppURL: string;
-        windowTransport: {
-            enabled: boolean;
-        };
-        proxyTransport: {
-            enabled: boolean;
-        };
-    };
-    defaultNetwork: number;
-    analytics: boolean;
-};
-/**
- * Initializes a wallet with the provided project access key and optional configuration.
- *
- * @param projectAccessKey - Access key for the project that can be obtained from Sequence Builder on sequence.build
- * @param partialConfig - Optional partial configuration for the wallet.
- * @returns The initialized wallet provider.
- * @throws Error if projectAccessKey is not provided, empty string or is not string.
- */
-export declare const initWallet: (projectAccessKey: string, partialConfig?: Partial<ProviderConfig>) => SequenceProvider;
-export declare const unregisterWallet: () => void;
-export declare const getWallet: () => SequenceProvider;

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

@@ -1,141 +0,0 @@
-import { ethers } from 'ethers';
-import { SequenceClient } from "./client.js";
-import { EIP1193Provider, ChainIdLike, NetworkConfig } from '@0xsequence/network';
-import { ConnectDetails, ConnectOptions, 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[]>;
-    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>;
-    utils: WalletUtils;
-}
-declare const EIP1193EventTypes: readonly ["connect", "disconnect", "chainChanged", "accountsChanged"];
-type EIP1193EventType = (typeof EIP1193EventTypes)[number];
-export declare class SequenceProvider extends ethers.AbstractProvider implements ISequenceProvider, EIP1193Provider {
-    readonly client: SequenceClient;
-    private readonly providerFor;
-    readonly networks: NetworkConfig[];
-    readonly options?: ethers.AbstractProviderOptions | undefined;
-    private readonly singleNetworkProviders;
-    readonly _isSequenceProvider = true;
-    readonly utils: WalletUtils;
-    readonly signer: SequenceSigner;
-    readonly eip1193EventListeners: Map<"connect" | "disconnect" | "accountsChanged" | "chainChanged", Set<ethers.Listener>>;
-    constructor(client: SequenceClient, providerFor: (networkId: number) => ethers.JsonRpcProvider, networks?: NetworkConfig[], options?: ethers.AbstractProviderOptions | undefined);
-    on(event: ethers.ProviderEvent | EIP1193EventType, listener: ethers.Listener): Promise<this>;
-    off(event: ethers.ProviderEvent | EIP1193EventType, listener?: ethers.Listener | undefined): Promise<this>;
-    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[]>;
-    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.JsonRpcProvider>;
-    _perform(req: ethers.PerformActionRequest): Promise<any>;
-    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.Network>;
-    detectNetwork(): Promise<ethers.Network>;
-    waitForTransaction(transactionHash: string, confirmations?: number, timeout?: number, optionals?: OptionalChainIdLike): Promise<ethers.TransactionReceipt | null>;
-    getBlockNumber(optionals?: OptionalChainIdLike): Promise<number>;
-    getFeeData(optionals?: OptionalChainIdLike): Promise<ethers.FeeData>;
-    getBalance(addressOrName: string | Promise<string>, blockTag?: ethers.BlockTag, optionals?: OptionalChainIdLike): Promise<bigint>;
-    getTransactionCount(addressOrName: string | Promise<string>, blockTag?: ethers.BlockTag, optionals?: OptionalChainIdLike): Promise<number>;
-    getCode(addressOrName: string | Promise<string>, blockTag?: ethers.BlockTag, optionals?: OptionalChainIdLike): Promise<string>;
-    getStorage(addressOrName: string | Promise<string>, position: ethers.BigNumberish, blockTag?: ethers.BlockTag, optionals?: OptionalChainIdLike): Promise<string>;
-    call(transaction: ethers.TransactionRequest, optionals?: OptionalChainIdLike): Promise<string>;
-    estimateGas(transaction: ethers.TransactionRequest, optionals?: OptionalChainIdLike): Promise<bigint>;
-    getBlock(blockHashOrBlockTag: ethers.BlockTag | string, prefetchTxs?: boolean, optionals?: OptionalChainIdLike): Promise<ethers.Block | null>;
-    getTransaction(transactionHash: string, optionals?: OptionalChainIdLike): Promise<ethers.TransactionResponse | null>;
-    getLogs(filter: ethers.Filter, optionals?: OptionalChainIdLike): Promise<ethers.Log[]>;
-    supportsENS(): Promise<boolean>;
-    getResolver(name: string): Promise<ethers.EnsResolver | null>;
-    resolveName(name: string): Promise<string | null>;
-    lookupAddress(address: 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.JsonRpcProvider, chainId: ChainIdLike, options?: ethers.AbstractProviderOptions);
-    private _useChainId;
-    protected useChainId(chainId?: ChainIdLike): Promise<number>;
-    getChainId(): number;
-    getNetwork(): Promise<ethers.Network>;
-    /**
-     *  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

@@ -1,88 +0,0 @@
-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 Omit<ethers.Signer, 'connect'> {
-    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[]>;
-    connect: (provider: SequenceProvider) => SequenceSigner;
-    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.TransactionRequest[] | ethers.TransactionRequest, options?: OptionalChainIdLike): Promise<commons.transaction.TransactionResponse>;
-    utils: WalletUtils;
-}
-export declare class SequenceSigner implements ISequenceSigner {
-    client: SequenceClient;
-    provider: SequenceProvider;
-    private readonly singleNetworkSigners;
-    readonly _isSequenceSigner: boolean;
-    get utils(): WalletUtils;
-    constructor(client: SequenceClient, provider: SequenceProvider);
-    getAddress(): Promise<string>;
-    connect(provider: ethers.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.TransactionRequest[] | ethers.TransactionRequest, options?: OptionalChainIdLike): Promise<ethers.TransactionResponse>;
-    getWalletConfig(chainId?: ChainIdLike | undefined): Promise<commons.config.Config>;
-    getNetworks(): Promise<NetworkConfig[]>;
-    getBalance(blockTag?: ethers.BlockTag | undefined, optionals?: OptionalChainIdLike): Promise<bigint>;
-    estimateGas(transaction: ethers.TransactionRequest, optionals?: OptionalChainIdLike): Promise<bigint>;
-    call(transaction: ethers.TransactionRequest, optionals?: OptionalChainIdLike): Promise<string>;
-    getChainId(): Promise<number>;
-    getFeeData(optionals?: OptionalChainIdLike): Promise<ethers.FeeData>;
-    resolveName(name: string): Promise<string>;
-    _checkProvider(_operation?: string | undefined): void;
-    getNonce(_blockTag?: ethers.BlockTag): Promise<number>;
-    populateCall(_transaction: ethers.TransactionRequest): Promise<ethers.TransactionLike<string>>;
-    populateTransaction(_transaction: ethers.TransactionRequest): Promise<ethers.TransactionLike<string>>;
-    checkTransaction(_transaction: ethers.TransactionRequest): ethers.TransactionRequest;
-    getTransactionCount(_blockTag?: ethers.BlockTag): Promise<number>;
-    signTransaction(_transaction: 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/transactions.d.ts

@@ -1,2 +0,0 @@
-import { commons } from '@0xsequence/core';
-export declare function validateTransactionRequest(wallet: string, transaction: commons.transaction.Transactionish): void;

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

@@ -1,49 +0,0 @@
-import { ProviderTransport, ProviderMessage, ProviderMessageRequest, ProviderEventTypes, ProviderMessageResponse, ProviderMessageResponseCallback, OpenState, OpenWalletIntent, ConnectDetails, WalletSession, ProviderRpcError, InitState, TypedEventEmitter } from "../types.js";
-import { NetworkConfig } from '@0xsequence/network';
-import { commons } from '@0xsequence/core';
-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: {
-        accounts: string[];
-        origin?: string;
-    } | undefined;
-    protected networksPayload: NetworkConfig[] | undefined;
-    protected walletContextPayload: commons.context.VersionedContext | undefined;
-    protected _sessionId?: string;
-    protected _init: InitState;
-    protected _registered: boolean;
-    readonly projectAccessKey?: string;
-    constructor(projectAccessKey?: string);
-    get registered(): boolean;
-    register(): void;
-    unregister(): void;
-    openWallet(path?: string, intent?: OpenWalletIntent, networkId?: string | number): void;
-    closeWallet(): void;
-    isOpened(): boolean;
-    isConnected(): boolean;
-    request(request: {
-        method: string;
-        params?: any[];
-        chainId?: number;
-    }): Promise<any>;
-    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

@@ -1,43 +0,0 @@
-import { WalletTransport, ProviderMessage, ProviderMessageRequest, ProviderMessageResponse, ProviderRpcError, InitState, ConnectDetails, WalletSession, TransportSession } from "../types.js";
-import { WalletRequestHandler } from "./wallet-request-handler.js";
-import { NetworkConfig } from '@0xsequence/network';
-import { commons } from '@0xsequence/core';
-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;
-    request(request: {
-        method: string;
-        params?: any[];
-        chainId?: number;
-    }): Promise<any>;
-    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, origin?: string): void;
-    notifyAccountsChanged(accounts: string[], origin?: string): void;
-    notifyChainChanged(chainIdHex: string, origin?: string): void;
-    notifyNetworks(networks: NetworkConfig[]): void;
-    notifyWalletContext(walletContext: commons.context.VersionedContext): void;
-    protected isValidInitAck(message: ProviderMessage<any>): boolean;
-    private init;
-    protected open: ({ sessionId, intent, networkId }: TransportSession) => Promise<boolean>;
-    private saveTransportSession;
-    protected getCachedTransportSession: () => Promise<TransportSession | null>;
-}

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

@@ -1,17 +0,0 @@
-import { EventEmitter2 as EventEmitter } from 'eventemitter2';
-import { ProviderMessageResponseCallback, ProviderMessageRequest, ProviderMessageResponse } from "../../types.js";
-export 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;
-}

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

@@ -1,12 +0,0 @@
-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 {
-    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

@@ -1,11 +0,0 @@
-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);
-    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

@@ -1,3 +0,0 @@
-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 +0,0 @@
-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 +0,0 @@
-export * from "./mux-message-provider.js";

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

@@ -1,47 +0,0 @@
-import { ProviderMessage, ProviderTransport, ProviderEventTypes, ProviderMessageRequest, ProviderMessageResponse, WalletSession, OpenWalletIntent, ConnectDetails } from "../../types.js";
-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, projectAccessKey?: string): MuxMessageProvider;
-    add(...messageProviders: ProviderTransport[]): void;
-    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;
-    request(request: {
-        method: string;
-        params?: any[];
-        chainId?: number;
-    }): Promise<any>;
-    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

@@ -1,3 +0,0 @@
-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,15 +0,0 @@
-import { ProviderMessage, ProviderMessageTransport, ProviderEventTypes, TypedEventEmitter } from "../../types.js";
-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 type ProxyEventTypes = Pick<ProviderEventTypes, 'open' | 'close' | 'connect' | 'disconnect'>;

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

@@ -1,12 +0,0 @@
-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);
-    register(): void;
-    restoreSession(): Promise<void>;
-    unregister(): void;
-    sendMessage(message: ProviderMessage<any>): void;
-}

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

@@ -1,12 +0,0 @@
-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);
-    register: () => void;
-    unregister: () => void;
-    openWallet: (path?: string, intent?: OpenWalletIntent, networkId?: string | number) => void;
-    closeWallet(): void;
-    sendMessage(message: ProviderMessage<any>): void;
-}

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

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