@0xsequence/provider 2.3.19 → 2.3.20

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

@@ -0,0 +1,14 @@
+import { ProviderMessage } from "../../types.js";
+import { WalletRequestHandler } from "../wallet-request-handler.js";
+import { BaseWalletTransport } from "../base-wallet-transport.js";
+/**
+ * Initialized on Wallet side
+ */
+export declare class UnrealMessageHandler extends BaseWalletTransport {
+    constructor(walletRequestHandler: WalletRequestHandler);
+    register(windowHref?: string | URL): Promise<void>;
+    unregister(): void;
+    private onMessageFromUnreal;
+    sendMessage(message: ProviderMessage<any>): void;
+    private getUnrealTransportSession;
+}

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

@@ -0,0 +1,15 @@
+import { OpenWalletIntent, ProviderMessage } from "../../types.js";
+import { BaseProviderTransport } from "../base-provider-transport.js";
+/**
+ * Initialized on dApp side
+ */
+export declare class UnrealMessageProvider extends BaseProviderTransport {
+    private walletURL;
+    constructor(walletAppURL: string);
+    register: () => void;
+    unregister: () => void;
+    openWallet: (path?: string, intent?: OpenWalletIntent, networkId?: string | number) => void;
+    closeWallet(): void;
+    private onUnrealCallback;
+    sendMessage(message: ProviderMessage<unknown>): void;
+}

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

@@ -0,0 +1,64 @@
+import { Account } from '@0xsequence/account';
+import { commons } from '@0xsequence/core';
+import { ChainIdLike, NetworkConfig, EIP1193Provider } from '@0xsequence/network';
+import { ConnectDetails, ConnectOptions, MessageToSign, NetworkedConnectOptions, OpenWalletIntent, PromptConnectDetails, ProviderEventTypes, ProviderMessageRequest, ProviderMessageRequestHandler, ProviderMessageResponse, ProviderRpcError, WalletSession } from "../types.js";
+export interface WalletSignInOptions {
+    connect?: boolean;
+    defaultNetworkId?: number;
+}
+export declare class WalletRequestHandler implements EIP1193Provider, ProviderMessageRequestHandler {
+    private account;
+    private signerReadyCallbacks;
+    private prompter;
+    private networks;
+    private _openIntent?;
+    private _connectOptions?;
+    private events;
+    onConnectOptionsChange: ((connectOptions: ConnectOptions | undefined) => void) | undefined;
+    constructor(account: Account | null | undefined, prompter: WalletUserPrompter | null, networks: NetworkConfig[]);
+    defaultChainId(): number;
+    signIn(account: Account | null, options?: WalletSignInOptions): Promise<void>;
+    signOut(): void;
+    signerReset(): void;
+    signerReady(timeout?: number): Promise<void>;
+    connect(options?: NetworkedConnectOptions): Promise<ConnectDetails>;
+    promptConnect: (options?: NetworkedConnectOptions) => Promise<ConnectDetails>;
+    sendMessageRequest(message: ProviderMessageRequest): Promise<ProviderMessageResponse>;
+    request(request: {
+        method: string;
+        params?: any[];
+        chainId?: number;
+        origin?: string;
+        projectAccessKey?: string;
+    }): 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>;
+    get openIntent(): OpenWalletIntent | undefined;
+    setOpenIntent(intent: OpenWalletIntent | undefined): void;
+    get connectOptions(): ConnectOptions | undefined;
+    setConnectOptions(options: ConnectOptions | undefined): void;
+    setDefaultChainId(chainId: number): Promise<number>;
+    getNetworks(jsonRpcResponse?: boolean): Promise<NetworkConfig[]>;
+    walletSession(networkId?: ChainIdLike): WalletSession | undefined;
+    notifyConnect(connectDetails: ConnectDetails, origin?: string): void;
+    notifyDisconnect(origin?: string): void;
+    notifyChainChanged(chainId: number, origin?: string): void;
+    notifyNetworks(networks?: NetworkConfig[]): Promise<void>;
+    notifyWalletContext(): Promise<void>;
+    notifyClose(error?: ProviderRpcError): void;
+    isSignedIn: () => Promise<boolean>;
+    getAccount: () => Promise<Account | null>;
+    setAccount(account: Account | null | undefined): void;
+    private handleConfirmWalletDeployPrompt;
+}
+export interface WalletUserPrompter {
+    getDefaultChainId(): number;
+    promptConnect(connectOptions?: ConnectOptions): Promise<PromptConnectDetails>;
+    promptSignInConnect(connectOptions?: ConnectOptions): Promise<PromptConnectDetails>;
+    promptSignMessage(message: MessageToSign, origin?: string, projectAccessKey?: string): Promise<string>;
+    promptSignTransaction(txn: commons.transaction.Transactionish, chainId?: number, origin?: string, projectAccessKey?: string): Promise<string>;
+    promptSendTransaction(txn: commons.transaction.Transactionish, chainId?: number, origin?: string, projectAccessKey?: string): Promise<string>;
+    promptConfirmWalletDeploy(chainId: number, origin?: string): Promise<boolean>;
+    promptChangeNetwork(chainId: number): Promise<boolean>;
+}

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

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

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

@@ -0,0 +1,15 @@
+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;
+    constructor(walletRequestHandler: WalletRequestHandler);
+    register(windowHref?: any): Promise<void>;
+    unregister(): void;
+    private onWindowEvent;
+    sendMessage(message: ProviderMessage<any>): void;
+    get isPopup(): boolean;
+    private postMessage;
+    private getWindowTransportSession;
+}

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

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

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

@@ -0,0 +1,262 @@
+import { ETHAuthProof as AuthETHAuthProof } from '@0xsequence/auth';
+import { commons } from '@0xsequence/core';
+import { ChainIdLike, EIP1193Provider, JsonRpcRequest, JsonRpcResponse, NetworkConfig, JsonRpcErrorPayload } from '@0xsequence/network';
+import { TypedData } from '@0xsequence/utils';
+export interface ProviderTransport extends EIP1193Provider, ProviderMessageTransport, ProviderMessageRequestHandler {
+    register(): void;
+    unregister(): void;
+    openWallet(path?: string, intent?: OpenWalletIntent, networkId?: string | number): void;
+    closeWallet(): void;
+    isOpened(): boolean;
+    isConnected(): boolean;
+    on<K extends keyof ProviderEventTypes>(event: K, fn: ProviderEventTypes[K]): void;
+    once<K extends keyof ProviderEventTypes>(event: K, fn: ProviderEventTypes[K]): void;
+    emit<K extends keyof ProviderEventTypes>(event: K, ...args: Parameters<ProviderEventTypes[K]>): boolean;
+    waitUntilOpened(): Promise<WalletSession | undefined>;
+    waitUntilConnected(): Promise<ConnectDetails>;
+}
+export declare function isProviderTransport(transport: any): transport is ProviderTransport;
+export interface WalletTransport extends EIP1193Provider, ProviderMessageTransport, ProviderMessageRequestHandler {
+    register(): void;
+    unregister(): void;
+    notifyOpen(openInfo: {
+        chainId?: string;
+        sessionId?: string;
+        session?: WalletSession;
+        error?: string;
+    }): void;
+    notifyClose(error?: ProviderRpcError): void;
+    notifyConnect(connectDetails: ConnectDetails): void;
+    notifyAccountsChanged(accounts: string[]): void;
+    notifyChainChanged(chainIdHex: string): void;
+    notifyNetworks(networks: NetworkConfig[]): void;
+}
+export interface ProviderMessage<T> {
+    idx: number;
+    type: string;
+    data: T;
+    chainId?: number;
+    origin?: string;
+    clientVersion: string;
+    projectAccessKey?: string;
+}
+export type ProviderMessageRequest = ProviderMessage<JsonRpcRequest>;
+export type ProviderMessageResponse = ProviderMessage<JsonRpcResponse | any>;
+export type ProviderMessageResponseCallback = (error?: ProviderRpcError, response?: ProviderMessageResponse) => void;
+export type ProviderRpcError = JsonRpcErrorPayload;
+export interface ProviderMessageRequestHandler {
+    sendMessageRequest(message: ProviderMessageRequest): Promise<ProviderMessageResponse>;
+}
+export interface ProviderMessageTransport {
+    handleMessage(message: ProviderMessage<any>): void;
+    sendMessage(message: ProviderMessage<any>): void;
+}
+export type WindowSessionParam = 'sid' | 'net' | 'intent';
+export interface WindowSessionParams extends URLSearchParams {
+    get(name: WindowSessionParam): string | null;
+    set(name: WindowSessionParam, value: string): void;
+}
+export declare class WindowSessionParams extends URLSearchParams {
+    static new(init?: Record<WindowSessionParam, string> | string): WindowSessionParams;
+}
+export interface TransportSession {
+    sessionId?: string | null;
+    networkId?: string | number | null;
+    intent?: OpenWalletIntent;
+}
+export declare enum EventType {
+    OPEN = "open",
+    CLOSE = "close",
+    MESSAGE = "message",
+    CONNECT = "connect",
+    DISCONNECT = "disconnect",
+    ACCOUNTS_CHANGED = "accountsChanged",
+    CHAIN_CHANGED = "chainChanged",
+    NETWORKS = "networks",
+    WALLET_CONTEXT = "walletContext",
+    INIT = "init",
+    DEBUG = "_debug"
+}
+export interface WalletEventTypes {
+    open: (openInfo: {
+        chainId?: string;
+        sessionId?: string;
+        session?: WalletSession;
+        error?: string;
+    }) => void;
+    close: (error?: ProviderRpcError) => void;
+    connect: (connectDetails: ConnectDetails) => void;
+    disconnect: (error?: ProviderRpcError, origin?: string) => void;
+    accountsChanged: (accounts: string[], origin?: string) => void;
+    chainChanged: (chainIdHex: string, origin?: string) => void;
+    networks: (networks: NetworkConfig[]) => void;
+    walletContext: (walletContext: commons.context.VersionedContext) => void;
+}
+export interface ProviderEventTypes extends WalletEventTypes {
+    message: (message: ProviderMessageResponse) => void;
+}
+export declare enum OpenState {
+    CLOSED = 0,
+    OPENING = 1,
+    OPENED = 2
+}
+export declare enum InitState {
+    NIL = 0,
+    SENT_NONCE = 1,
+    OK = 2
+}
+export interface ConnectOptions {
+    /** app name of the dapp which will be announced to user on connect screen */
+    app: string;
+    /** custom protocol for auth redirect (unity/unreal) */
+    appProtocol?: string;
+    /** origin hint of the dapp's host opening the wallet. This value will automatically
+     * be determined and verified for integrity, and can be omitted. */
+    origin?: string;
+    /** access key for the project that can be obtained from Sequence Builder on sequence.build.
+     * This value will be automatically populated using the key passed in initWallet. */
+    projectAccessKey?: string;
+    /** expiry number (in seconds) that is used for ETHAuth proof. Default is 1 week in seconds. */
+    expiry?: number;
+    /** authorize will perform an ETHAuth eip712 signing and return the proof to the dapp. */
+    authorize?: boolean;
+    /** authorizeNonce is an optional number to be passed as ETHAuth's nonce claim for replay protection. **/
+    authorizeNonce?: number;
+    /** authorizeVersion is the version of the SDK that will validate the ETHAuth proof. */
+    authorizeVersion?: number;
+    /** askForEmail will prompt to give permission to the dapp to access email address */
+    askForEmail?: boolean;
+    /** refresh flag will force a full re-connect (ie. disconnect then connect again) */
+    refresh?: boolean;
+    /** keepWalletOpened will keep the wallet window opened after connecting. The default
+     * is to automatically close the wallet after connecting. */
+    keepWalletOpened?: boolean;
+    /** clientVersion is the sequence.js version of the dapp client. */
+    clientVersion?: string;
+    /** Options to further customize the wallet experience. */
+    settings?: Settings;
+}
+export interface NetworkedConnectOptions extends ConnectOptions {
+    /** chainId is the chainId to connect to. If not specified, the default chainId
+     * will be used. This does not define a default chain id, it is only used for the connect
+     * authorization signature. */
+    networkId?: string | number;
+}
+/** Options to further customize the wallet experience. */
+export interface Settings {
+    /** Specify a wallet theme. `light` and `dark` are the main themes, to use other available
+     * themes, you can use the camel case version of the theme names in the wallet settings.
+     * For example: "Blue Dark" on wallet UI can be passed as "blueDark".
+     * Note that this setting will not be persisted, use wallet.open with 'openWithOptions' intent
+     * to set when you open the wallet for user. */
+    theme?: ThemeOption;
+    /** Specify a banner image. This image, if provided, will be displayed on the wallet during
+     * the connect/authorize process */
+    bannerUrl?: string;
+    bannerSize?: BannerSize;
+    /** Specify payment providers to use. If not specified,
+     * all available payment providers will be enabled.
+     * Note that this setting will not be persisted, use wallet.open with 'openWithOptions' intent
+     * to set when you open the wallet for user. */
+    includedPaymentProviders?: PaymentProviderOption[];
+    /** Specify a default currency to use with payment providers.
+     * If not specified, the default is USDC.
+     * Note that this setting will not be persisted, use wallet.open with 'openWithOptions' intent
+     * to set when you open the wallet for user. */
+    defaultFundingCurrency?: CurrencyOption;
+    /** Specify default purchase amount as an integer, for prefilling the funding amount.
+     * If not specified, the default is 100.
+     * Note that this setting will not be persisted, use wallet.open with 'openWithOptions' intent
+     * to set when you open the wallet for user. */
+    defaultPurchaseAmount?: number;
+    /** If true, lockFundingCurrencyToDefault disables picking any currency provided by payment
+     * providers other than the defaultFundingCurrency.
+     * If false, it allows picking any currency provided by payment providers.
+     * The default is true.
+     * Note that this setting will not be persisted, use wallet.open with 'openWithOptions' intent
+     * to set when you open the wallet for user. */
+    lockFundingCurrencyToDefault?: boolean;
+    /** Specify an auth provider to allow dapp to specify ahead of time which auth method to redirect to.
+     * Will be ignored if user is already signed in.
+     */
+    signInWith?: SignInOption;
+    /** Specify an email address to allow user automatically sign in with the email option.
+     * Will be ignored if user is already signed in.
+     */
+    signInWithEmail?: string;
+    /** Specify which sign in options are allowed.
+     * Will be ignored if user is already signed in.
+     */
+    signInOptions?: SignInOption[];
+    /** Specify auxiliary data
+     */
+    aux?: any;
+}
+/** light and dark are the main themes, to use other themes in wallet settings,
+ * you can use the camel case version of the name in the wallet settings.
+ * For example: "Blue Dark" on wallet UI can be passed as "blueDark" */
+export type ThemeOption = 'light' | 'dark' | string;
+export type PaymentProviderOption = 'ramp' | 'moonpay' | 'transak' | 'onmeta' | 'paytrie' | 'sardine';
+export type CurrencyOption = 'usdc' | 'eth' | 'matic';
+export type SignInOption = 'email' | 'google' | 'apple' | 'facebook' | 'discord' | 'twitch';
+export type BannerSize = 'small' | 'medium';
+export interface ConnectDetails {
+    chainId?: string;
+    error?: string;
+    connected: boolean;
+    session?: WalletSession;
+    proof?: ETHAuthProof;
+    email?: string;
+}
+export type PromptConnectDetails = Pick<ConnectDetails, 'chainId' | 'error' | 'connected' | 'proof' | 'email'>;
+export type OpenWalletIntent = {
+    type: 'connect';
+    options?: NetworkedConnectOptions;
+} | {
+    type: 'openWithOptions';
+    options?: ConnectOptions;
+} | {
+    type: 'jsonRpcRequest';
+    method: string;
+};
+export interface MessageToSign {
+    message?: Uint8Array;
+    typedData?: TypedData;
+    chainId?: number;
+    eip6492?: boolean;
+}
+export type ETHAuthProof = AuthETHAuthProof;
+export interface WalletSession {
+    walletContext?: commons.context.VersionedContext;
+    accountAddress?: string;
+    networks?: NetworkConfig[];
+}
+export declare class ProviderError extends Error {
+    constructor(message?: string);
+}
+export declare const ErrSignedInRequired: ProviderError;
+export interface TypedEventEmitter<Events> {
+    addListener<E extends keyof Events>(event: E, listener: Events[E]): this;
+    on<E extends keyof Events>(event: E, listener: Events[E]): this;
+    once<E extends keyof Events>(event: E, listener: Events[E]): this;
+    prependListener<E extends keyof Events>(event: E, listener: Events[E]): this;
+    prependOnceListener<E extends keyof Events>(event: E, listener: Events[E]): this;
+    off<E extends keyof Events>(event: E, listener: Events[E]): this;
+    removeAllListeners<E extends keyof Events>(event?: E): this;
+    removeListener<E extends keyof Events>(event: E, listener: Events[E]): this;
+    emit<E extends keyof Events>(event: E, ...args: Arguments<Events[E]>): boolean;
+    eventNames(): (keyof Events | string | symbol)[];
+    listeners<E extends keyof Events>(event: E): Function[];
+    listenerCount<E extends keyof Events>(event: E): number;
+}
+type Arguments<T> = [T] extends [(...args: infer U) => any] ? U : [T] extends [void] ? [] : [T];
+export type OptionalChainIdLike = {
+    chainId?: ChainIdLike;
+} | undefined;
+export type OptionalChainId = {
+    chainId?: number;
+} | undefined;
+export type OptionalEIP6492 = {
+    eip6492?: boolean;
+} | undefined;
+export {};

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

@@ -0,0 +1,18 @@
+import { ethers } from 'ethers';
+import { ChainIdLike } from '@0xsequence/network';
+import { TypedData } from '@0xsequence/utils';
+import { SequenceSigner } from "../signer.js";
+/**
+ *  This class is redundant with the SequenceSigner class, but it is here for now to
+ *  maintain compatibility with the old wallet API. Eventually we should move these
+ *  methods to the SequenceSigner class and deprecate this class.
+ */
+export declare class WalletUtils {
+    signer: SequenceSigner;
+    constructor(signer: SequenceSigner);
+    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

@@ -0,0 +1,37 @@
+import { ethers } from 'ethers';
+import { AccountStatus } from '@0xsequence/account';
+import { TypedData } from '@0xsequence/utils';
+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.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;
+export interface ItemStore {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+    onItemChange(key: string, cb: (value: string | null) => void): () => void;
+}
+export declare class MemoryItemStore implements ItemStore {
+    private callbacks;
+    private store;
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+    onItemChange(key: string, cb: (value: string | null) => void): () => void;
+}
+export declare class LocalStorage implements ItemStore {
+    private callbacks;
+    static isAvailable(): boolean;
+    constructor();
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+    onItemChange(key: string, cb: (value: string | null) => void): () => void;
+}
+export declare function useBestStore(): ItemStore;
+export declare function resolveArrayProperties<T>(object: Readonly<T> | Readonly<T>[]): Promise<T>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xsequence/provider",
-  "version": "2.3.19",
+  "version": "2.3.20",
   "description": "provider sub-package for Sequence",
   "repository": "https://github.com/0xsequence/sequence.js/tree/master/packages/provider",
   "source": "src/index.ts",
@@ -15,15 +15,15 @@
     "@databeat/tracker": "^0.9.3",
     "eventemitter2": "^6.4.5",
     "webextension-polyfill": "^0.10.0",
-    "@0xsequence/abi": "2.3.19",
-    "@0xsequence/account": "2.3.19",
-    "@0xsequence/auth": "2.3.19",
-    "@0xsequence/migration": "2.3.19",
-    "@0xsequence/relayer": "2.3.19",
-    "@0xsequence/core": "2.3.19",
-    "@0xsequence/utils": "2.3.19",
-    "@0xsequence/wallet": "2.3.19",
-    "@0xsequence/network": "2.3.19"
+    "@0xsequence/account": "2.3.20",
+    "@0xsequence/auth": "2.3.20",
+    "@0xsequence/core": "2.3.20",
+    "@0xsequence/network": "2.3.20",
+    "@0xsequence/utils": "2.3.20",
+    "@0xsequence/wallet": "2.3.20",
+    "@0xsequence/migration": "2.3.20",
+    "@0xsequence/abi": "2.3.20",
+    "@0xsequence/relayer": "2.3.20"
   },
   "devDependencies": {
     "@types/webextension-polyfill": "^0.10.0",