@0xsequence/provider 0.43.34 → 1.0.1

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

@@ -0,0 +1,6 @@
+import { ethers } from "ethers";
+export type ExtendedTransactionRequest = ethers.providers.TransactionRequest & {
+    auxiliary?: ethers.providers.TransactionRequest[];
+};
+export declare function toExtended(transactions: ethers.providers.TransactionRequest[]): ExtendedTransactionRequest;
+export declare function fromExtended(transaction: ExtendedTransactionRequest): ethers.providers.TransactionRequest[];

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

@@ -1,10 +1,11 @@
 import { ethers, BytesLike, Bytes, providers, TypedDataDomain, TypedDataField } from 'ethers';
-import { NetworkConfig, WalletContext, ChainIdLike, JsonRpcHandler, JsonRpcFetchFunc, JsonRpcRequest, JsonRpcResponseCallback, JsonRpcSender } from '@0xsequence/network';
+import { NetworkConfig, ChainIdLike, JsonRpcHandler, JsonRpcFetchFunc, JsonRpcRequest, JsonRpcResponseCallback, JsonRpcSender } from '@0xsequence/network';
 import { Signer } from '@0xsequence/wallet';
-import { WalletConfig, WalletState } from '@0xsequence/config';
 import { Relayer } from '@0xsequence/relayer';
-import { Deferrable, Forbid } from '@0xsequence/utils';
-import { TransactionRequest, TransactionResponse, SignedTransactions } from '@0xsequence/transactions';
+import { Deferrable } from '@0xsequence/utils';
+import { commons } from '@0xsequence/core';
+import { Account, AccountStatus } from '@0xsequence/account';
+import { ExtendedTransactionRequest } from './extended';
 export declare class Web3Provider extends providers.Web3Provider implements JsonRpcHandler {
     static isSequenceProvider(cand: any): cand is Web3Provider;
     readonly _sender: JsonRpcSender;
@@ -20,10 +21,11 @@ export declare class Web3Provider extends providers.Web3Provider implements Json
     }): Promise<any>;
     getSigner(): Web3Signer;
     getChainId(): Promise<number>;
+    getNetworks(): Promise<NetworkConfig[]>;
 }
 export declare function isSequenceProvider(provider: any): provider is Web3Provider;
 export declare class LocalWeb3Provider extends Web3Provider {
-    constructor(signer: Signer, networks?: NetworkConfig[]);
+    constructor(account: Account, networks?: NetworkConfig[]);
 }
 interface TypedDataSigner {
     _signTypedData(domain: TypedDataDomain, types: Record<string, Array<TypedDataField>>, value: Record<string, any>): Promise<string>;
@@ -34,32 +36,32 @@ export declare class Web3Signer extends Signer implements TypedDataSigner {
     constructor(provider: Web3Provider, defaultChainId?: number);
     _address: string;
     _index: number;
-    _context: WalletContext;
+    _context: commons.context.VersionedContext;
     _networks: NetworkConfig[];
     private _providers;
     getAddress(): Promise<string>;
-    signTransaction(transaction: Deferrable<TransactionRequest>): Promise<string>;
+    signTransaction(transaction: Deferrable<ethers.providers.TransactionRequest>): Promise<string>;
     connect(provider: ethers.providers.Provider): ethers.providers.JsonRpcSigner;
     getProvider(chainId?: number): Promise<Web3Provider | undefined>;
     getSender(chainId?: number): Promise<Web3Provider | undefined>;
     getRelayer(chainId?: number): Promise<Relayer | undefined>;
-    getWalletContext(): Promise<WalletContext>;
-    getWalletConfig(chainId?: ChainIdLike): Promise<WalletConfig[]>;
-    getWalletState(chainId?: ChainIdLike): Promise<WalletState[]>;
+    getWalletContext(): Promise<commons.context.VersionedContext>;
+    getWalletConfig(chainId?: ChainIdLike): Promise<commons.config.Config>;
+    getWalletState(chainId?: ChainIdLike): Promise<AccountStatus>;
     getNetworks(): Promise<NetworkConfig[]>;
     getSigners(): Promise<string[]>;
-    signMessage(message: BytesLike, chainId?: ChainIdLike, allSigners?: boolean): Promise<string>;
-    signTypedData(domain: TypedDataDomain, types: Record<string, Array<TypedDataField>>, message: Record<string, any>, chainId?: ChainIdLike, allSigners?: boolean): Promise<string>;
-    sendTransaction(transaction: Deferrable<TransactionRequest>, chainId?: ChainIdLike, allSigners?: boolean): Promise<TransactionResponse>;
-    sendTransactionBatch(transactions: Deferrable<Forbid<TransactionRequest, 'wait'>[]>, chainId?: ChainIdLike, allSigners?: boolean): Promise<TransactionResponse>;
-    signTransactions(transaction: Deferrable<TransactionRequest>, chainId?: ChainIdLike, allSigners?: boolean): Promise<SignedTransactions>;
-    sendSignedTransactions(signedTxs: SignedTransactions, chainId?: ChainIdLike): Promise<TransactionResponse>;
-    updateConfig(newConfig?: WalletConfig): Promise<[WalletConfig, TransactionResponse | undefined]>;
-    publishConfig(): Promise<TransactionResponse | undefined>;
+    signMessage(message: BytesLike, chainId?: ChainIdLike, sequenceVerified?: boolean): Promise<string>;
+    signTypedData(domain: TypedDataDomain, types: Record<string, Array<TypedDataField>>, message: Record<string, any>, chainId?: ChainIdLike, sequenceVerified?: boolean): Promise<string>;
+    sendTransaction(transaction: Deferrable<ExtendedTransactionRequest>, chainId?: ChainIdLike): Promise<commons.transaction.TransactionResponse>;
+    sendTransactionBatch(transactions: Deferrable<ethers.providers.TransactionRequest[]>, chainId?: ChainIdLike): Promise<ethers.providers.TransactionResponse>;
+    signTransactions(transaction: Deferrable<ethers.providers.TransactionRequest>, chainId?: ChainIdLike): Promise<commons.transaction.SignedTransactionBundle>;
+    sendSignedTransactions(signedTxs: commons.transaction.SignedTransactionBundle, chainId?: ChainIdLike): Promise<ethers.providers.TransactionResponse>;
+    updateConfig(newConfig?: commons.config.Config): Promise<[commons.config.Config, ethers.providers.TransactionResponse | undefined]>;
+    publishConfig(): Promise<ethers.providers.TransactionResponse | undefined>;
     isDeployed(chainId?: ChainIdLike): Promise<boolean>;
-    _legacySignMessage(message: Bytes | string, chainId?: ChainIdLike, allSigners?: boolean): Promise<string>;
-    _signTypedData(domain: TypedDataDomain, types: Record<string, Array<TypedDataField>>, message: Record<string, any>, chainId?: ChainIdLike, allSigners?: boolean): Promise<string>;
-    sendUncheckedTransaction(transaction: Deferrable<TransactionRequest>, chainId?: ChainIdLike): Promise<string>;
+    _legacySignMessage(message: Bytes | string, chainId?: ChainIdLike): Promise<string>;
+    _signTypedData(domain: TypedDataDomain, types: Record<string, Array<TypedDataField>>, message: Record<string, any>, chainId?: ChainIdLike): Promise<string>;
+    sendUncheckedTransaction(transaction: Deferrable<ExtendedTransactionRequest>, chainId?: ChainIdLike): Promise<string>;
     connectUnchecked(): ethers.providers.JsonRpcSigner;
     unlock(password: string): Promise<boolean>;
 }

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

@@ -1,5 +1,6 @@
 import { ProviderTransport, ProviderMessage, ProviderMessageRequest, ProviderEventTypes, ProviderMessageResponse, ProviderMessageResponseCallback, OpenState, OpenWalletIntent, ConnectDetails, WalletSession, ProviderRpcError, InitState, TypedEventEmitter } from '../types';
-import { NetworkConfig, WalletContext, JsonRpcRequest, JsonRpcResponseCallback } from '@0xsequence/network';
+import { NetworkConfig, JsonRpcRequest, JsonRpcResponseCallback } 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 {
@@ -18,7 +19,7 @@ export declare abstract class BaseProviderTransport implements ProviderTransport
         origin?: string;
     } | undefined;
     protected networksPayload: NetworkConfig[] | undefined;
-    protected walletContextPayload: WalletContext | undefined;
+    protected walletContextPayload: commons.context.VersionedContext | undefined;
     protected _sessionId?: string;
     protected _init: InitState;
     protected _registered: boolean;

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

@@ -1,6 +1,7 @@
 import { WalletTransport, ProviderMessage, ProviderMessageRequest, ProviderMessageResponse, ProviderRpcError, InitState, ConnectDetails, WalletSession, TransportSession } from '../types';
 import { WalletRequestHandler } from './wallet-request-handler';
-import { NetworkConfig, WalletContext, JsonRpcRequest, JsonRpcResponseCallback } from '@0xsequence/network';
+import { NetworkConfig, JsonRpcRequest, JsonRpcResponseCallback } from '@0xsequence/network';
+import { commons } from '@0xsequence/core';
 export declare abstract class BaseWalletTransport implements WalletTransport {
     protected walletRequestHandler: WalletRequestHandler;
     protected _sessionId: string;
@@ -29,7 +30,7 @@ export declare abstract class BaseWalletTransport implements WalletTransport {
     notifyAccountsChanged(accounts: string[], origin?: string): void;
     notifyChainChanged(chainIdHex: string): void;
     notifyNetworks(networks: NetworkConfig[]): void;
-    notifyWalletContext(walletContext: WalletContext): void;
+    notifyWalletContext(walletContext: commons.context.VersionedContext): void;
     protected isValidInitAck(message: ProviderMessage<any>): boolean;
     private init;
     protected open: ({ sessionId, intent, networkId }: TransportSession) => Promise<boolean>;

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

@@ -1,29 +1,26 @@
-import { ProviderMessageRequest, ProviderMessageResponse, ProviderMessageRequestHandler, MessageToSign, ProviderRpcError, ConnectOptions, ConnectDetails, PromptConnectDetails, WalletSession, OpenWalletIntent, ProviderEventTypes } from '../types';
-import { providers } from 'ethers';
+import { Account } from '@0xsequence/account';
+import { commons } from '@0xsequence/core';
 import { NetworkConfig, JsonRpcHandler, JsonRpcRequest, JsonRpcResponseCallback } from '@0xsequence/network';
-import { Signer } from '@0xsequence/wallet';
-import { TransactionRequest } from '@0xsequence/transactions';
+import { providers } from 'ethers';
+import { ProviderMessageRequest, ProviderMessageResponse, ProviderMessageRequestHandler, MessageToSign, ProviderRpcError, ConnectOptions, ConnectDetails, PromptConnectDetails, WalletSession, OpenWalletIntent, ProviderEventTypes } from '../types';
 type ExternalProvider = providers.ExternalProvider;
 export interface WalletSignInOptions {
     connect?: boolean;
-    mainnetNetworks?: NetworkConfig[];
-    testnetNetworks?: NetworkConfig[];
-    defaultNetworkId?: string | number;
+    defaultNetworkId?: number;
 }
 export declare class WalletRequestHandler implements ExternalProvider, JsonRpcHandler, ProviderMessageRequestHandler {
-    private signer;
+    private account;
     private signerReadyCallbacks;
     private prompter;
-    private mainnetNetworks;
-    private testnetNetworks;
+    private networks;
     private _openIntent?;
     private _connectOptions?;
-    private _defaultNetworkId?;
-    private _chainId?;
     private events;
     onConnectOptionsChange: ((connectOptions: ConnectOptions | undefined) => void) | undefined;
-    constructor(signer: Signer | null | undefined, prompter: WalletUserPrompter | null, mainnetNetworks: NetworkConfig[], testnetNetworks?: NetworkConfig[]);
-    signIn(signer: Signer | null, options?: WalletSignInOptions): Promise<void>;
+    constructor(account: Account | null | undefined, prompter: WalletUserPrompter | null, networks: NetworkConfig[]);
+    defaultChainId(): number;
+    private findNetworkID;
+    signIn(account: Account | null, options?: WalletSignInOptions): Promise<void>;
     signOut(): void;
     signerReset(): void;
     signerReady(timeout?: number): Promise<void>;
@@ -34,31 +31,31 @@ export declare class WalletRequestHandler implements ExternalProvider, JsonRpcHa
     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>;
-    getChainId(): Promise<number>;
     get openIntent(): OpenWalletIntent | undefined;
     setOpenIntent(intent: OpenWalletIntent | undefined): void;
     get connectOptions(): ConnectOptions | undefined;
     setConnectOptions(options: ConnectOptions | undefined): void;
-    get defaultNetworkId(): string | number | undefined;
-    setDefaultNetwork(chainId: string | number, notifyNetworks?: boolean): Promise<number | undefined>;
+    setDefaultChainId(chainId: number): Promise<number>;
     getNetworks(jsonRpcResponse?: boolean): Promise<NetworkConfig[]>;
-    walletSession(): Promise<WalletSession | undefined>;
+    walletSession(): WalletSession | undefined;
     notifyConnect(connectDetails: ConnectDetails, origin?: string): void;
     notifyDisconnect(origin?: string): void;
     notifyNetworks(networks?: NetworkConfig[]): Promise<void>;
     notifyWalletContext(): Promise<void>;
     notifyClose(error?: ProviderRpcError): void;
     isSignedIn: () => Promise<boolean>;
-    getSigner: () => Promise<Signer | null>;
-    setSigner(signer: Signer | null | undefined): void;
+    getAccount: () => Promise<Account | null>;
+    setAccount(account: Account | null | undefined): void;
     private handleConfirmWalletDeployPrompt;
 }
 export interface WalletUserPrompter {
+    getDefaultChainId(): number;
     promptConnect(options?: ConnectOptions): Promise<PromptConnectDetails>;
     promptSignInConnect(options?: ConnectOptions): Promise<PromptConnectDetails>;
     promptSignMessage(message: MessageToSign, options?: ConnectOptions): Promise<string>;
-    promptSignTransaction(txn: TransactionRequest, chaindId?: number, options?: ConnectOptions): Promise<string>;
-    promptSendTransaction(txn: TransactionRequest, chaindId?: number, options?: ConnectOptions): Promise<string>;
+    promptSignTransaction(txn: commons.transaction.Transactionish, chainId?: number, options?: ConnectOptions): Promise<string>;
+    promptSendTransaction(txn: commons.transaction.Transactionish, chainId?: number, options?: ConnectOptions): Promise<string>;
     promptConfirmWalletDeploy(chainId: number, options?: ConnectOptions): Promise<boolean>;
+    promptChangeNetwork(chainId: number): Promise<boolean>;
 }
 export {};

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

@@ -1,4 +1,6 @@
-import { NetworkConfig, WalletContext, JsonRpcRequest, JsonRpcResponse, JsonRpcHandler } from '@0xsequence/network';
+import { ETHAuthProof as AuthETHAuthProof } from '@0xsequence/auth';
+import { commons } from '@0xsequence/core';
+import { JsonRpcHandler, JsonRpcRequest, JsonRpcResponse, NetworkConfig, ProviderRpcError as NetworkProviderRpcError } from '@0xsequence/network';
 import { TypedData } from '@0xsequence/utils';
 export interface ProviderTransport extends JsonRpcHandler, ProviderMessageTransport, ProviderMessageRequestHandler {
     register(): void;
@@ -38,13 +40,7 @@ export interface ProviderMessage<T> {
 export type ProviderMessageRequest = ProviderMessage<JsonRpcRequest>;
 export type ProviderMessageResponse = ProviderMessage<JsonRpcResponse>;
 export type ProviderMessageResponseCallback = (error?: ProviderRpcError, response?: ProviderMessageResponse) => void;
-export interface ProviderRpcError extends Error {
-    message: string;
-    code?: number;
-    data?: {
-        [key: string]: any;
-    };
-}
+export type ProviderRpcError = NetworkProviderRpcError;
 export interface ProviderMessageRequestHandler {
     sendMessageRequest(message: ProviderMessageRequest): Promise<ProviderMessageResponse>;
 }
@@ -91,7 +87,7 @@ export interface WalletEventTypes {
     accountsChanged: (accounts: string[], origin?: string) => void;
     chainChanged: (chainIdHex: string) => void;
     networks: (networks: NetworkConfig[]) => void;
-    walletContext: (walletContext: WalletContext) => void;
+    walletContext: (walletContext: commons.context.VersionedContext) => void;
 }
 export interface ProviderEventTypes extends WalletEventTypes {
     message: (message: ProviderMessageResponse) => void;
@@ -121,6 +117,8 @@ export interface ConnectOptions {
     expiry?: number;
     /** authorize will perform an ETHAuth eip712 signing and return the proof to the dapp. */
     authorize?: boolean;
+    /** 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) */
@@ -206,13 +204,11 @@ export interface MessageToSign {
     message?: Uint8Array;
     typedData?: TypedData;
     chainId?: number;
+    eip6492?: boolean;
 }
-export interface ETHAuthProof {
-    typedData: TypedData;
-    proofString: string;
-}
+export type ETHAuthProof = AuthETHAuthProof;
 export interface WalletSession {
-    walletContext?: WalletContext;
+    walletContext?: commons.context.VersionedContext;
     accountAddress?: string;
     networks?: NetworkConfig[];
     providerCache?: {

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

@@ -1,7 +1,6 @@
-import { BigNumberish, BytesLike, TypedDataDomain, TypedDataField } from 'ethers';
-import { WalletContext, ChainIdLike } from '@0xsequence/network';
+import { BytesLike, TypedDataDomain, TypedDataField } from 'ethers';
+import { ChainIdLike } from '@0xsequence/network';
 import { TypedData } from '@0xsequence/utils';
-import { DecodedSignature, WalletConfig } from '@0xsequence/config';
 import { Wallet } from '../wallet';
 export declare class WalletUtils {
     private wallet;
@@ -10,10 +9,7 @@ export declare class WalletUtils {
     signAuthMessage(message: BytesLike, allSigners?: boolean): Promise<string>;
     signTypedData(domain: TypedDataDomain, types: Record<string, Array<TypedDataField>>, message: Record<string, any>, chainId?: ChainIdLike, allSigners?: boolean): Promise<string>;
     signAuthTypedData(domain: TypedDataDomain, types: Record<string, Array<TypedDataField>>, message: Record<string, any>, allSigners?: boolean): Promise<string>;
-    isValidSignature(address: string, digest: Uint8Array, signature: string, chainId: number, walletContext?: WalletContext): Promise<boolean>;
-    isValidMessageSignature(address: string, message: string | Uint8Array, signature: string, chainId: number, walletContext?: WalletContext): Promise<boolean>;
-    isValidTypedDataSignature(address: string, typedData: TypedData, signature: string, chainId: number, walletContext?: WalletContext): Promise<boolean>;
-    recoverWalletConfig: (address: string, digest: BytesLike, signature: string | DecodedSignature, chainId: BigNumberish, walletContext?: WalletContext) => Promise<WalletConfig>;
-    recoverWalletConfigFromMessage: (address: string, message: string | Uint8Array, signature: string | DecodedSignature, chainId: BigNumberish, walletContext?: WalletContext) => Promise<WalletConfig>;
-    recoverWalletConfigFromTypedData: (address: string, typedData: TypedData, signature: string | DecodedSignature, chainId: BigNumberish, walletContext?: WalletContext) => Promise<WalletConfig>;
+    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,25 +1,17 @@
-import { ethers, BigNumberish, BytesLike } from 'ethers';
-import { WalletContext } from '@0xsequence/network';
-import { WalletConfig, DecodedSignature } from '@0xsequence/config';
-import { TypedData } from '@0xsequence/utils';
+
+import { ethers, BytesLike } from 'ethers';
 import { Web3Provider } from './provider';
-import { Signer } from '@0xsequence/wallet';
+import { AccountStatus } from '@0xsequence/account';
+import { commons } from '@0xsequence/core';
 export declare const messageToBytes: (message: BytesLike) => Uint8Array;
 export declare const prefixEIP191Message: (message: BytesLike) => Uint8Array;
-export declare const isValidSignature: (address: string, digest: Uint8Array, sig: string, provider: Web3Provider | ethers.providers.Web3Provider | ethers.providers.Provider, chainId?: number, walletContext?: WalletContext) => Promise<boolean>;
-export declare const isValidMessageSignature: (address: string, message: string | Uint8Array, signature: string, provider: Web3Provider | ethers.providers.Web3Provider | ethers.providers.Provider, chainId?: number, walletContext?: WalletContext) => Promise<boolean>;
-export declare const isValidTypedDataSignature: (address: string, typedData: TypedData, signature: string, provider: Web3Provider | ethers.providers.Web3Provider | ethers.providers.Provider, chainId?: number, walletContext?: WalletContext) => Promise<boolean>;
-export declare const recoverWalletConfig: (address: string, digest: BytesLike, signature: string | DecodedSignature, chainId: BigNumberish, walletContext?: WalletContext) => Promise<WalletConfig>;
+export declare const trimEIP191Prefix: (prefixedMessage: Uint8Array) => Uint8Array;
+export declare const isValidSignature: (address: string, digest: Uint8Array, sig: string, provider: Web3Provider | ethers.providers.Web3Provider, contexts: {
+    [key: number]: commons.context.WalletContext;
+}) => Promise<boolean>;
 export declare const isBrowserExtension: () => boolean;
 export declare const isUnityPlugin: () => boolean;
-/**
- * Returns the status of a signer's wallet on given chain by checking wallet deployment and config status
- *
- * @param {Signer} signer
- * @param {number} chainId
- * @return {Promise<boolean>} Promise that returns true if the wallet is up to date, false otherwise
- */
-export declare const isWalletUpToDate: (signer: Signer, chainId: number) => Promise<boolean>;
+export declare const isWalletUpToDate: (status: AccountStatus) => boolean;
 export interface ItemStore {
     getItem(key: string): Promise<string | null>;
     setItem(key: string, value: string): Promise<void>;

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

@@ -1,11 +1,13 @@
-import { NetworkConfig, WalletContext, ChainIdLike } from '@0xsequence/network';
-import { WalletConfig, WalletState } from '@0xsequence/config';
+import { NetworkConfig, ChainIdLike } from '@0xsequence/network';
 import { Web3Provider, Web3Signer } from './provider';
 import { ProxyMessageChannelPort } from './transports';
 import { WalletSession, ProviderEventTypes, ConnectOptions, OpenWalletIntent, ConnectDetails } from './types';
 import { ItemStore } from './utils';
 import { WalletUtils } from './utils/index';
 import { Runtime } from 'webextension-polyfill';
+import { commons } from '@0xsequence/core';
+import { AccountStatus } from '@0xsequence/account';
+export declare const SESSION_LOCALSTORE_KEY = "@sequence.session";
 export interface WalletProvider {
     connect(options?: ConnectOptions): Promise<ConnectDetails>;
     disconnect(): void;
@@ -14,15 +16,14 @@ export interface WalletProvider {
     getAddress(): Promise<string>;
     getNetworks(chainId?: ChainIdLike): Promise<NetworkConfig[]>;
     getChainId(): Promise<number>;
-    getAuthChainId(): Promise<number>;
     isOpened(): boolean;
     openWallet(path?: string, intent?: OpenWalletIntent, networkId?: string | number): Promise<boolean>;
     closeWallet(): void;
     getProvider(chainId?: ChainIdLike): Web3Provider | undefined;
     getSigner(chainId?: ChainIdLike): Web3Signer;
-    getWalletContext(): Promise<WalletContext>;
-    getWalletConfig(chainId?: ChainIdLike): Promise<WalletConfig[]>;
-    getWalletState(chainId?: ChainIdLike): Promise<WalletState[]>;
+    getWalletContext(): Promise<commons.context.VersionedContext>;
+    getWalletConfig(chainId?: ChainIdLike): Promise<commons.config.Config>;
+    getWalletState(chainId?: ChainIdLike): Promise<AccountStatus>;
     isDeployed(chainId?: ChainIdLike): Promise<boolean>;
     getProviderConfig(): ProviderConfig;
     on<K extends keyof ProviderEventTypes>(event: K, fn: ProviderEventTypes[K]): void;
@@ -46,7 +47,7 @@ export declare class Wallet implements WalletProvider {
     getConnectedSites(): Promise<string[] | undefined>;
     isSiteConnected(origin: string | undefined): Promise<boolean>;
     authorize: (options?: ConnectOptions) => Promise<ConnectDetails>;
-    disconnect(): void;
+    disconnect(): Promise<void>;
     getProviderConfig(): ProviderConfig;
     isOpened(): boolean;
     isConnected(): boolean;
@@ -54,20 +55,16 @@ export declare class Wallet implements WalletProvider {
     getAddress: () => Promise<string>;
     getNetworks: (chainId?: ChainIdLike) => Promise<NetworkConfig[]>;
     getChainId: () => Promise<number>;
-    getAuthChainId: () => Promise<number>;
     openWallet: (path?: string, intent?: OpenWalletIntent, networkId?: string | number) => Promise<boolean>;
     closeWallet: () => void;
     getProvider(chainId?: ChainIdLike): Web3Provider | undefined;
-    getAuthProvider(): Promise<Web3Provider>;
-    getAuthNetwork(): Promise<NetworkConfig>;
     getAllProviders(): {
         [chainId: number]: Web3Provider;
     };
     getSigner(chainId?: ChainIdLike): Web3Signer;
-    getAuthSigner(): Promise<Web3Signer>;
-    getWalletConfig(chainId?: ChainIdLike): Promise<WalletConfig[]>;
-    getWalletState(chainId?: ChainIdLike): Promise<WalletState[]>;
-    getWalletContext(): Promise<WalletContext>;
+    getWalletConfig(chainId?: ChainIdLike): Promise<commons.config.Config>;
+    getWalletState(chainId?: ChainIdLike): Promise<AccountStatus>;
+    getWalletContext(): Promise<commons.context.VersionedContext>;
     isDeployed(chainId?: ChainIdLike): Promise<boolean>;
     on<K extends keyof ProviderEventTypes>(event: K, fn: ProviderEventTypes[K]): void;
     once<K extends keyof ProviderEventTypes>(event: K, fn: ProviderEventTypes[K]): void;
@@ -100,7 +97,7 @@ export interface ProviderConfig {
             enabled: boolean;
         };
     };
-    walletContext?: WalletContext;
+    walletContext?: commons.context.VersionedContext;
 }
 export declare const DefaultProviderConfig: ProviderConfig;
 export declare const initWallet: (network?: string | number, config?: Partial<ProviderConfig>) => Promise<Wallet>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xsequence/provider",
-  "version": "0.43.34",
+  "version": "1.0.1",
   "description": "provider sub-package for Sequence",
   "repository": "https://github.com/0xsequence/sequence.js/tree/master/packages/provider",
   "source": "src/index.ts",
@@ -9,16 +9,17 @@
   "author": "Horizon Blockchain Games",
   "license": "Apache-2.0",
   "dependencies": {
-    "@0xsequence/abi": "^0.43.34",
-    "@0xsequence/auth": "^0.43.34",
-    "@0xsequence/config": "^0.43.34",
-    "@0xsequence/network": "^0.43.34",
-    "@0xsequence/relayer": "^0.43.34",
-    "@0xsequence/transactions": "^0.43.34",
-    "@0xsequence/utils": "^0.43.34",
-    "@0xsequence/wallet": "^0.43.34",
     "eventemitter2": "^6.4.5",
-    "webextension-polyfill": "^0.10.0"
+    "webextension-polyfill": "^0.10.0",
+    "@0xsequence/abi": "1.0.1",
+    "@0xsequence/account": "1.0.1",
+    "@0xsequence/auth": "1.0.1",
+    "@0xsequence/core": "1.0.1",
+    "@0xsequence/migration": "1.0.1",
+    "@0xsequence/network": "1.0.1",
+    "@0xsequence/relayer": "1.0.1",
+    "@0xsequence/utils": "1.0.1",
+    "@0xsequence/wallet": "1.0.1"
   },
   "peerDependencies": {
     "ethers": ">=5.5 < 6"

package/src/extended.ts

@@ -0,0 +1,23 @@
+
+import { ethers } from "ethers"
+
+export type ExtendedTransactionRequest = ethers.providers.TransactionRequest & {
+  auxiliary?: ethers.providers.TransactionRequest[]
+}
+
+export function toExtended(transactions: ethers.providers.TransactionRequest[]): ExtendedTransactionRequest {
+  if (transactions.length === 0) {
+    throw new Error("No transaction provided")
+  }
+
+  const [first, ...rest] = transactions
+
+  return {
+    ...first,
+    auxiliary: rest,
+  }
+}
+
+export function fromExtended(transaction: ExtendedTransactionRequest): ethers.providers.TransactionRequest[] {
+  return [transaction, ...(transaction.auxiliary || [])]
+}