@0xsequence/provider 1.10.15 → 2.0.1

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

@@ -1,4 +1,4 @@
-import { JsonRpcRequest, NetworkConfig } from '@0xsequence/network';
+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';
@@ -75,14 +75,18 @@ export declare class SequenceClient {
     getAddress(): string;
     connect(options: ConnectOptions): Promise<ConnectDetails>;
     disconnect(): Promise<void>;
-    send(request: JsonRpcRequest, chainId?: number): Promise<any>;
+    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.providers.TransactionRequest[] | ethers.providers.TransactionRequest, options?: 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/provider.d.ts

@@ -1,7 +1,7 @@
 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 { 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";
@@ -29,15 +29,21 @@ export interface ISequenceProvider {
     getWalletConfig(chainId?: ChainIdLike): Promise<commons.config.Config>;
     utils: WalletUtils;
 }
-export declare class SequenceProvider extends ethers.providers.BaseProvider implements ISequenceProvider, EIP1193Provider {
+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;
-    constructor(client: SequenceClient, providerFor: (networkId: number) => ethers.providers.JsonRpcProvider, networks?: NetworkConfig[]);
+    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;
@@ -76,30 +82,32 @@ export declare class SequenceProvider extends ethers.providers.BaseProvider impl
      *  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>;
+    _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.providers.Network>;
-    waitForTransaction(transactionHash: string, confirmations?: number, timeout?: number, optionals?: OptionalChainIdLike): Promise<ethers.providers.TransactionReceipt>;
+    _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>;
-    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[]>;
+    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.providers.Resolver | null>;
-    resolveName(name: string | Promise<string>): Promise<string | null>;
-    lookupAddress(address: string | Promise<string>): Promise<string | null>;
+    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;
 }
@@ -115,11 +123,11 @@ export declare class SequenceProvider extends ethers.providers.BaseProvider impl
 export declare class SingleNetworkSequenceProvider extends SequenceProvider {
     readonly chainId: ChainIdLike;
     readonly _isSingleNetworkSequenceProvider = true;
-    constructor(client: SequenceClient, providerFor: (networkId: number) => ethers.providers.JsonRpcProvider, chainId: ChainIdLike);
+    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<NetworkConfig>;
+    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,
@@ -130,3 +138,4 @@ export declare class SingleNetworkSequenceProvider extends SequenceProvider {
     setDefaultChainId(_chainId: ChainIdLike): void;
     static is(cand: any): cand is SingleNetworkSequenceProvider;
 }
+export {};

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

@@ -5,7 +5,7 @@ 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 {
+export interface ISequenceSigner extends Omit<ethers.Signer, 'connect'> {
     getProvider(): SequenceProvider;
     getProvider(chainId: ChainIdLike): SingleNetworkSequenceProvider;
     getProvider(chainId?: ChainIdLike): SequenceProvider | SingleNetworkSequenceProvider;
@@ -14,21 +14,21 @@ export interface ISequenceSigner extends ethers.Signer {
     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.utils.Deferrable<ethers.providers.TransactionRequest>[] | ethers.utils.Deferrable<ethers.providers.TransactionRequest>, options?: OptionalChainIdLike): Promise<commons.transaction.TransactionResponse>;
+    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 _isSigner: boolean;
     readonly _isSequenceSigner: boolean;
     get utils(): WalletUtils;
     constructor(client: SequenceClient, provider: SequenceProvider);
     getAddress(): Promise<string>;
-    connect(provider: ethers.providers.Provider): SequenceSigner;
+    connect(provider: ethers.Provider): SequenceSigner;
     getSigner(): SequenceSigner;
     getSigner(chainId: ChainIdLike): SingleNetworkSequenceSigner;
     getSigner(chainId?: ChainIdLike): SingleNetworkSequenceSigner | SequenceSigner;
@@ -43,21 +43,22 @@ export declare class SequenceSigner implements ISequenceSigner {
     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>;
+    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.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>;
+    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>;
-    getGasPrice(optionals?: OptionalChainIdLike): Promise<ethers.BigNumber>;
-    getFeeData(optionals?: OptionalChainIdLike): Promise<ethers.providers.FeeData>;
+    getFeeData(optionals?: OptionalChainIdLike): Promise<ethers.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>;
+    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;
 }
 /**

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

@@ -1,5 +1,5 @@
 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 { NetworkConfig } from '@0xsequence/network';
 import { commons } from '@0xsequence/core';
 export declare const PROVIDER_OPEN_TIMEOUT = 30000;
 export declare const nextMessageIdx: () => number;
@@ -31,7 +31,11 @@ export declare abstract class BaseProviderTransport implements ProviderTransport
     closeWallet(): void;
     isOpened(): boolean;
     isConnected(): boolean;
-    sendAsync: (request: JsonRpcRequest, callback: JsonRpcResponseCallback, chainId?: number) => Promise<void>;
+    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;

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

@@ -1,6 +1,6 @@
 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 { NetworkConfig } from '@0xsequence/network';
 import { commons } from '@0xsequence/core';
 export declare abstract class BaseWalletTransport implements WalletTransport {
     protected walletRequestHandler: WalletRequestHandler;
@@ -14,7 +14,11 @@ export declare abstract class BaseWalletTransport implements WalletTransport {
     get registered(): boolean;
     register(): void;
     unregister(): void;
-    sendAsync: (request: JsonRpcRequest, callback: JsonRpcResponseCallback, chainId?: number) => Promise<never>;
+    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;

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

@@ -1,5 +1,4 @@
 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 = {
@@ -35,7 +34,11 @@ export declare class MuxMessageProvider implements ProviderTransport {
     on<K extends keyof ProviderEventTypes>(event: K, fn: ProviderEventTypes[K]): void;
     once<K extends keyof ProviderEventTypes>(event: K, fn: ProviderEventTypes[K]): void;
     emit<K extends keyof ProviderEventTypes>(event: K, ...args: Parameters<ProviderEventTypes[K]>): boolean;
-    sendAsync: (request: JsonRpcRequest, callback: JsonRpcResponseCallback, chainId?: number) => Promise<void>;
+    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;

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

@@ -1,14 +1,12 @@
 import { Account } from '@0xsequence/account';
 import { commons } from '@0xsequence/core';
-import { ChainIdLike, JsonRpcHandler, JsonRpcRequest, JsonRpcResponseCallback, NetworkConfig } from '@0xsequence/network';
-import { providers } from 'ethers';
+import { ChainIdLike, NetworkConfig, EIP1193Provider } from '@0xsequence/network';
 import { ConnectDetails, ConnectOptions, MessageToSign, NetworkedConnectOptions, OpenWalletIntent, PromptConnectDetails, ProviderEventTypes, ProviderMessageRequest, ProviderMessageRequestHandler, ProviderMessageResponse, ProviderRpcError, WalletSession } from "../types.js";
-type ExternalProvider = providers.ExternalProvider;
 export interface WalletSignInOptions {
     connect?: boolean;
     defaultNetworkId?: number;
 }
-export declare class WalletRequestHandler implements ExternalProvider, JsonRpcHandler, ProviderMessageRequestHandler {
+export declare class WalletRequestHandler implements EIP1193Provider, ProviderMessageRequestHandler {
     private account;
     private signerReadyCallbacks;
     private prompter;
@@ -26,7 +24,11 @@ export declare class WalletRequestHandler implements ExternalProvider, JsonRpcHa
     connect(options?: NetworkedConnectOptions): Promise<ConnectDetails>;
     promptConnect: (options?: NetworkedConnectOptions) => Promise<ConnectDetails>;
     sendMessageRequest(message: ProviderMessageRequest): Promise<ProviderMessageResponse>;
-    sendAsync: (request: JsonRpcRequest, callback: JsonRpcResponseCallback, chainId?: number) => Promise<void>;
+    request(request: {
+        method: string;
+        params?: any[];
+        chainId?: number;
+    }): Promise<any>;
     on<K extends keyof ProviderEventTypes>(event: K, fn: ProviderEventTypes[K]): void;
     once<K extends keyof ProviderEventTypes>(event: K, fn: ProviderEventTypes[K]): void;
     getAddress(): Promise<string>;
@@ -58,4 +60,3 @@ export interface WalletUserPrompter {
     promptConfirmWalletDeploy(chainId: number, options?: ConnectOptions): Promise<boolean>;
     promptChangeNetwork(chainId: number): Promise<boolean>;
 }
-export {};

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

@@ -1,8 +1,8 @@
 import { ETHAuthProof as AuthETHAuthProof } from '@0xsequence/auth';
 import { commons } from '@0xsequence/core';
-import { ChainIdLike, JsonRpcHandler, JsonRpcRequest, JsonRpcResponse, NetworkConfig, ProviderRpcError as NetworkProviderRpcError } from '@0xsequence/network';
+import { ChainIdLike, EIP1193Provider, JsonRpcRequest, JsonRpcResponse, NetworkConfig, JsonRpcErrorPayload } from '@0xsequence/network';
 import { TypedData } from '@0xsequence/utils';
-export interface ProviderTransport extends JsonRpcHandler, ProviderMessageTransport, ProviderMessageRequestHandler {
+export interface ProviderTransport extends EIP1193Provider, ProviderMessageTransport, ProviderMessageRequestHandler {
     register(): void;
     unregister(): void;
     openWallet(path?: string, intent?: OpenWalletIntent, networkId?: string | number): void;
@@ -16,7 +16,7 @@ export interface ProviderTransport extends JsonRpcHandler, ProviderMessageTransp
     waitUntilConnected(): Promise<ConnectDetails>;
 }
 export declare function isProviderTransport(transport: any): transport is ProviderTransport;
-export interface WalletTransport extends JsonRpcHandler, ProviderMessageTransport, ProviderMessageRequestHandler {
+export interface WalletTransport extends EIP1193Provider, ProviderMessageTransport, ProviderMessageRequestHandler {
     register(): void;
     unregister(): void;
     notifyOpen(openInfo: {
@@ -37,11 +37,12 @@ export interface ProviderMessage<T> {
     data: T;
     chainId?: number;
     origin?: string;
+    clientVersion: string;
 }
 export type ProviderMessageRequest = ProviderMessage<JsonRpcRequest>;
-export type ProviderMessageResponse = ProviderMessage<JsonRpcResponse>;
+export type ProviderMessageResponse = ProviderMessage<JsonRpcResponse | any>;
 export type ProviderMessageResponseCallback = (error?: ProviderRpcError, response?: ProviderMessageResponse) => void;
-export type ProviderRpcError = NetworkProviderRpcError;
+export type ProviderRpcError = JsonRpcErrorPayload;
 export interface ProviderMessageRequestHandler {
     sendMessageRequest(message: ProviderMessageRequest): Promise<ProviderMessageResponse>;
 }
@@ -257,10 +258,4 @@ export type OptionalChainId = {
 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,4 +1,4 @@
-import { BytesLike, TypedDataDomain, TypedDataField } from 'ethers';
+import { ethers } from 'ethers';
 import { ChainIdLike } from '@0xsequence/network';
 import { TypedData } from '@0xsequence/utils';
 import { SequenceSigner } from "../signer.js";
@@ -10,8 +10,8 @@ import { SequenceSigner } from "../signer.js";
 export declare class WalletUtils {
     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>;
+    signMessage(message: ethers.BytesLike, chainId?: ChainIdLike, eip6492?: boolean): Promise<string>;
+    signTypedData(domain: ethers.TypedDataDomain, types: Record<string, Array<ethers.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

@@ -1,12 +1,12 @@
-import { ethers, BytesLike } from 'ethers';
+import { ethers } from 'ethers';
 import { AccountStatus } from '@0xsequence/account';
 import { TypedData } from '@0xsequence/utils';
-export declare const messageToBytes: (message: BytesLike) => Uint8Array;
-export declare const prefixEIP191Message: (message: BytesLike) => Uint8Array;
+export declare const messageToBytes: (message: ethers.BytesLike) => Uint8Array;
+export declare const prefixEIP191Message: (message: ethers.BytesLike) => Uint8Array;
 export declare const trimEIP191Prefix: (prefixedMessage: Uint8Array) => Uint8Array;
-export declare const isValidSignature: (address: string, digest: Uint8Array, sig: string, provider: ethers.providers.Provider) => Promise<boolean>;
-export declare const isValidMessageSignature: (address: string, message: string | Uint8Array, signature: string, provider: ethers.providers.Provider) => Promise<boolean>;
-export declare const isValidTypedDataSignature: (address: string, typedData: TypedData, signature: string, provider: ethers.providers.Provider) => Promise<boolean>;
+export declare const isValidSignature: (address: string, digest: Uint8Array, sig: string, provider: ethers.Provider) => Promise<boolean>;
+export declare const isValidMessageSignature: (address: string, message: string | Uint8Array, signature: string, provider: ethers.Provider) => Promise<boolean>;
+export declare const isValidTypedDataSignature: (address: string, typedData: TypedData, signature: string, provider: ethers.Provider) => Promise<boolean>;
 export declare const isBrowserExtension: () => boolean;
 export declare const isUnityPlugin: () => boolean;
 export declare const isWalletUpToDate: (status: AccountStatus) => boolean;
@@ -34,4 +34,4 @@ export declare class LocalStorage implements ItemStore {
     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>;
+export declare function resolveArrayProperties<T>(object: Readonly<T> | Readonly<T>[]): Promise<T>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xsequence/provider",
-  "version": "1.10.15",
+  "version": "2.0.1",
   "description": "provider sub-package for Sequence",
   "repository": "https://github.com/0xsequence/sequence.js/tree/master/packages/provider",
   "source": "src/index.ts",
@@ -12,22 +12,22 @@
     "@databeat/tracker": "^0.9.1",
     "eventemitter2": "^6.4.5",
     "webextension-polyfill": "^0.10.0",
-    "@0xsequence/abi": "1.10.15",
-    "@0xsequence/account": "1.10.15",
-    "@0xsequence/auth": "1.10.15",
-    "@0xsequence/core": "1.10.15",
-    "@0xsequence/migration": "1.10.15",
-    "@0xsequence/network": "1.10.15",
-    "@0xsequence/relayer": "1.10.15",
-    "@0xsequence/utils": "1.10.15",
-    "@0xsequence/wallet": "1.10.15"
+    "@0xsequence/abi": "2.0.1",
+    "@0xsequence/account": "2.0.1",
+    "@0xsequence/auth": "2.0.1",
+    "@0xsequence/core": "2.0.1",
+    "@0xsequence/migration": "2.0.1",
+    "@0xsequence/network": "2.0.1",
+    "@0xsequence/relayer": "2.0.1",
+    "@0xsequence/utils": "2.0.1",
+    "@0xsequence/wallet": "2.0.1"
   },
   "peerDependencies": {
-    "ethers": ">=5.5 < 6"
+    "ethers": ">=6"
   },
   "devDependencies": {
     "@types/webextension-polyfill": "^0.10.0",
-    "ethers": "^5.7.2",
+    "ethers": "^6.13.0",
     "hardhat": "^2.20.1"
   },
   "files": [

package/src/client.ts

@@ -1,4 +1,4 @@
-import { JsonRpcRequest, JsonRpcResponse, NetworkConfig } from '@0xsequence/network'
+import { NetworkConfig } from '@0xsequence/network'
 import {
   ConnectDetails,
   ConnectOptions,
@@ -15,14 +15,12 @@ import {
   isProviderTransport,
   messageToBytes
 } from '.'
-import { commons } from '@0xsequence/core'
+import { commons, VERSION } from '@0xsequence/core'
 import { TypedData } from '@0xsequence/utils'
 import { toExtended } from './extended'
 import { Analytics, setupAnalytics } from './analytics'
 import { ethers } from 'ethers'
 
-import packageJson from '../package.json'
-
 /**
  *  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)
@@ -166,7 +164,7 @@ export class SequenceClient {
     })
 
     this.transport.on('connect', (response: ConnectDetails) => {
-      const chainIdHex = ethers.utils.hexValue(this.getChainId())
+      const chainIdHex = ethers.toQuantity(this.getChainId())
       this.callbacks.connect?.forEach(cb =>
         cb({
           ...response,
@@ -204,7 +202,7 @@ export class SequenceClient {
     // We don't listen for the transport chainChanged event
     // instead we handle it locally, so we listen for changes in the store
     this.defaultChainId.onDefaultChainIdChanged((chainId: number) => {
-      const chainIdHex = ethers.utils.hexValue(chainId)
+      const chainIdHex = ethers.toQuantity(chainId)
       this.callbacks.chainChanged?.forEach(cb => cb(chainIdHex))
     })
 
@@ -337,7 +335,7 @@ export class SequenceClient {
 
     await this.openWallet(undefined, {
       type: 'connect',
-      options: { ...options, networkId: this.getChainId(), clientVersion: packageJson.version }
+      options: { ...options, networkId: this.getChainId(), clientVersion: VERSION }
     })
 
     const connectDetails = await this.transport.waitUntilConnected().catch((error): ConnectDetails => {
@@ -351,7 +349,7 @@ export class SequenceClient {
     // Normalize chainId into a decimal string
     // TODO: Remove this once wallet-webapp returns chainId as a string
     if (connectDetails.chainId) {
-      connectDetails.chainId = ethers.BigNumber.from(connectDetails.chainId).toString()
+      connectDetails.chainId = BigInt(connectDetails.chainId).toString()
     }
 
     if (connectDetails.connected) {
@@ -381,40 +379,23 @@ export class SequenceClient {
 
   // Higher level API
 
-  // Working with sendAsync is less idiomatic
-  // but transport uses it instead of send, so we wrap it
-  send(request: JsonRpcRequest, chainId?: number): Promise<any> {
+  async request(request: { method: string; params?: any[]; chainId?: number }): Promise<any> {
     // Internally when sending requests we use `legacy_sign`
     // to avoid the default EIP6492 behavior overriding an explicit
     // "legacy sign" request, so we map the method here.
     request.method = this.mapSignMethod(request.method)
 
-    return new Promise((resolve, reject) => {
-      this.transport.sendAsync(
-        request,
-        (error, response) => {
-          if (error) {
-            reject(error)
-          } else if (response === undefined) {
-            reject(new Error(`Got undefined response for request: ${request}`))
-          } else if (typeof response === 'object' && response.error) {
-            reject(response.error)
-          } else if (typeof response === 'object' && response.result) {
-            resolve(response.result)
-          } else {
-            reject(new Error(`Got invalid response for request: ${request}`))
-          }
-        },
-        chainId || this.getChainId()
-      )
-    })
+    const result = await this.transport.request(request)
+
+    // We may need to unwrap the response if it's a JSON-RPC response. ie. older universal wallet versions
+    return unwrapJsonRpcResponse(result)
   }
 
   async getNetworks(pull?: boolean): Promise<NetworkConfig[]> {
     const connectedSession = this.session.connectedSession()
 
     if (pull) {
-      connectedSession.networks = await this.send({ method: 'sequence_getNetworks' })
+      connectedSession.networks = await this.request({ method: 'sequence_getNetworks' })
       this.session.setSession(connectedSession)
     }
 
@@ -474,11 +455,14 @@ export class SequenceClient {
 
     this.analytics?.track({ event: 'SIGN_MESSAGE_REQUEST', props: { chainId: `${options?.chainId || this.getChainId()}` } })
 
-    // Serialize a BytesLike or string message into a hex string before sending
-    message = ethers.utils.hexlify(messageToBytes(message))
+    message = ethers.hexlify(messageToBytes(message))
 
     // Address is ignored by the wallet webapp
-    return this.send({ method, params: [message, this.getAddress()] }, options?.chainId)
+    return this.request({
+      method,
+      params: [message, this.getAddress()],
+      chainId: options?.chainId
+    })
   }
 
   async signTypedData(typedData: TypedData, options?: OptionalEIP6492 & OptionalChainId): Promise<string> {
@@ -486,7 +470,7 @@ export class SequenceClient {
 
     // TODO: Stop using ethers for this, this is the only place where we use it
     // and it makes the client depend on ethers.
-    const encoded = ethers.utils._TypedDataEncoder.getPayload(typedData.domain, typedData.types, typedData.message)
+    const encoded = ethers.TypedDataEncoder.getPayload(typedData.domain, typedData.types, typedData.message)
 
     // The sign typed data will use one of the following chainIds, in order:
     // - The one provided in the options
@@ -495,36 +479,33 @@ export class SequenceClient {
 
     this.analytics?.track({ event: 'SIGN_TYPED_DATA_REQUEST', props: { chainId: `${options?.chainId || this.getChainId()}` } })
 
-    return this.send(
-      { method, params: [this.getAddress(), encoded] },
-      options?.chainId ||
-        (typedData.domain.chainId && ethers.BigNumber.from(typedData.domain.chainId).toNumber()) ||
-        this.getChainId()
-    )
+    return this.request({
+      method,
+      params: [this.getAddress(), encoded],
+      chainId: options?.chainId || (typedData.domain.chainId && Number(typedData.domain.chainId)) || this.getChainId()
+    })
   }
 
-  async sendTransaction(
-    tx: ethers.providers.TransactionRequest[] | ethers.providers.TransactionRequest,
-    options?: OptionalChainId
-  ): Promise<string> {
+  async sendTransaction(tx: ethers.TransactionRequest[] | ethers.TransactionRequest, options?: OptionalChainId): Promise<string> {
     const sequenceTxs = Array.isArray(tx) ? tx : [tx]
     const extendedTxs = toExtended(sequenceTxs)
 
     this.analytics?.track({ event: 'SEND_TRANSACTION_REQUEST', props: { chainId: `${options?.chainId || this.getChainId()}` } })
 
-    return this.send({ method: 'eth_sendTransaction', params: [extendedTxs] }, options?.chainId)
+    return this.request({ method: 'eth_sendTransaction', params: [extendedTxs], chainId: options?.chainId })
   }
 
   async getWalletContext(): Promise<commons.context.VersionedContext> {
-    return this.send({ method: 'sequence_getWalletContext' })
+    return this.request({ method: 'sequence_getWalletContext' })
   }
 
   async getOnchainWalletConfig(options?: OptionalChainId): Promise<commons.config.Config> {
     // NOTICE: sequence_getWalletConfig sends the chainId as a param
-    const res = await this.send(
-      { method: 'sequence_getWalletConfig', params: [options?.chainId || this.getChainId()] },
-      options?.chainId
-    )
+    const res = await this.request({
+      method: 'sequence_getWalletConfig',
+      params: [options?.chainId || this.getChainId()],
+      chainId: options?.chainId
+    })
     return Array.isArray(res) ? res[0] : res
   }
 
@@ -533,3 +514,12 @@ export class SequenceClient {
   // wallet-webapp does implement them, but this client is meant to be
   // exclusively used for Sequence specific methods
 }
+
+// Unwrap a JsonRpcResponse result
+const unwrapJsonRpcResponse = (response: any): any => {
+  if (response && typeof response === 'object' && 'jsonrpc' in response && 'result' in response) {
+    return response.result
+  }
+
+  return response
+}