@0xsequence/provider 0.0.0-2021823181734

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

@@ -0,0 +1,99 @@
+import { NetworkConfig, WalletContext, ChainIdLike } from '@0xsequence/network';
+import { WalletConfig, WalletState } from '@0xsequence/config';
+import { Web3Provider, Web3Signer } from './provider';
+import { ProxyMessageChannelPort } from './transports';
+import { WalletSession, ProviderEventTypes, ConnectOptions, OpenWalletIntent, ConnectDetails } from './types';
+import { WalletCommands } from './commands';
+import { Runtime } from 'webextension-polyfill-ts';
+export interface WalletProvider {
+    connect(options?: ConnectOptions): Promise<ConnectDetails>;
+    disconnect(): void;
+    isOpened(): boolean;
+    isConnected(): boolean;
+    getSession(): WalletSession | undefined;
+    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;
+    getSigner(chainId?: ChainIdLike): Web3Signer;
+    getWalletContext(): Promise<WalletContext>;
+    getWalletConfig(chainId?: ChainIdLike): Promise<WalletConfig[]>;
+    getWalletState(chainId?: ChainIdLike): Promise<WalletState[]>;
+    isDeployed(chainId?: ChainIdLike): Promise<boolean>;
+    getProviderConfig(): ProviderConfig;
+    on<K extends keyof ProviderEventTypes>(event: K, fn: ProviderEventTypes[K]): void;
+    once<K extends keyof ProviderEventTypes>(event: K, fn: ProviderEventTypes[K]): void;
+    commands: WalletCommands;
+}
+export declare class Wallet implements WalletProvider {
+    commands: WalletCommands;
+    private config;
+    private session?;
+    private connectedSites;
+    private transport;
+    private networks;
+    private providers;
+    constructor(defaultNetworkId?: string | number, config?: Partial<ProviderConfig>);
+    private init;
+    connect: (options?: ConnectOptions | undefined) => Promise<ConnectDetails>;
+    addConnectedSite(origin: string | undefined): void;
+    removeConnectedSite(origin: string): void;
+    getConnectedSites(): string[] | undefined;
+    private isSiteConnected;
+    authorize: (options?: ConnectOptions | undefined) => Promise<ConnectDetails>;
+    disconnect(): void;
+    getProviderConfig(): ProviderConfig;
+    isOpened(): boolean;
+    isConnected(): boolean;
+    getSession: () => WalletSession | undefined;
+    getAddress: () => Promise<string>;
+    getNetworks: (chainId?: any) => Promise<NetworkConfig[]>;
+    getChainId: () => Promise<number>;
+    getAuthChainId: () => Promise<number>;
+    openWallet: (path?: string | undefined, intent?: OpenWalletIntent | undefined, networkId?: string | number | undefined) => 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>;
+    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;
+    private loadSession;
+    private saveSession;
+    private useSession;
+    private useAccountAddress;
+    private useNetworks;
+    private clearSession;
+}
+export interface ProviderConfig {
+    walletAppURL: string;
+    networks?: Partial<NetworkConfig>[];
+    networkRpcUrl?: string;
+    defaultNetworkId?: string | number;
+    transports?: {
+        windowTransport?: {
+            enabled: boolean;
+        };
+        proxyTransport?: {
+            enabled: boolean;
+            appPort?: ProxyMessageChannelPort;
+        };
+        extensionTransport?: {
+            enabled: boolean;
+            runtime: Runtime.Static;
+        };
+    };
+    walletContext?: WalletContext;
+}
+export declare const DefaultProviderConfig: ProviderConfig;

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@0xsequence/provider",
+  "version": "0.0.0-2021823181734",
+  "description": "provider sub-package for Sequence",
+  "repository": "https://github.com/0xsequence/sequence.js/tree/master/packages/provider",
+  "source": "src/index.ts",
+  "main": "dist/0xsequence-provider.cjs.js",
+  "module": "dist/0xsequence-provider.esm.js",
+  "author": "Horizon Blockchain Games",
+  "license": "Apache-2.0",
+  "scripts": {
+    "test": "echo",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@0xsequence/abi": "^0.28.0",
+    "@0xsequence/auth": "^0.0.0-2021823181734",
+    "@0xsequence/config": "^0.0.0-2021823181734",
+    "@0xsequence/network": "^0.0.0-2021823181734",
+    "@0xsequence/transactions": "^0.0.0-2021823181734",
+    "@0xsequence/utils": "^0.28.0",
+    "@0xsequence/wallet": "^0.0.0-2021823181734",
+    "@ethersproject/abstract-signer": "5.0.14",
+    "@ethersproject/hash": "^5.0.12",
+    "@ethersproject/providers": "^5.0.24",
+    "@ethersproject/web": "^5.0.14",
+    "ethers": "^5.0.32",
+    "eventemitter2": "^6.4.4",
+    "webextension-polyfill-ts": "^0.26.0"
+  },
+  "peerDependencies": {},
+  "devDependencies": {},
+  "files": [
+    "src",
+    "dist"
+  ]
+}

package/src/commands/index.ts

@@ -0,0 +1,146 @@
+import { BigNumberish, BytesLike } from 'ethers'
+import { TypedDataDomain, TypedDataField, TypedDataSigner } from '@ethersproject/abstract-signer'
+import { WalletContext, ChainIdLike } from '@0xsequence/network'
+import { encodeMessageDigest, TypedData, encodeTypedDataDigest } from '@0xsequence/utils'
+import { DecodedSignature, WalletConfig } from '@0xsequence/config'
+import { Wallet } from '../wallet'
+import { isValidSignature, recoverWalletConfig } from '../utils'
+
+export class WalletCommands {
+  private wallet: Wallet
+
+  constructor(walletProvider: Wallet) {
+    this.wallet = walletProvider
+  }
+
+  // Sign message on a specified chain, or DefaultChain by default
+  signMessage(message: BytesLike, chainId?: ChainIdLike, allSigners?: boolean): Promise<string> {
+    const signer = this.wallet.getSigner()
+    if (!signer) throw new Error('unable to get signer')
+    return signer.signMessage(message, chainId, allSigners)
+  }
+
+  // Sign message on the AuthChain
+  async signAuthMessage(message: BytesLike, allSigners?: boolean): Promise<string> {
+    const signer = await this.wallet.getAuthSigner()
+    if (!signer) throw new Error('unable to get AuthChain signer')
+    return signer.signMessage(message, await signer.getChainId(), allSigners)
+  }
+
+  // Sign EIP-712 TypedData on a specified chain, or DefaultChain by default
+  signTypedData(
+    domain: TypedDataDomain,
+    types: Record<string, Array<TypedDataField>>,
+    message: Record<string, any>,
+    chainId?: ChainIdLike,
+    allSigners?: boolean
+  ): Promise<string> {
+    const signer = this.wallet.getSigner()
+    if (!signer) throw new Error('unable to get signer')
+    return signer.signTypedData(domain, types, message, chainId, allSigners)
+  }
+
+  // Sign EIP-712 TypedData on the AuthChain
+  async signAuthTypedData(
+    domain: TypedDataDomain,
+    types: Record<string, Array<TypedDataField>>,
+    message: Record<string, any>,
+    allSigners?: boolean
+  ): Promise<string> {
+    const signer = await this.wallet.getAuthSigner()
+    if (!signer) throw new Error('unable to get AuthChain signer')
+    return signer.signTypedData(domain, types, message, await signer.getChainId(), allSigners)
+  }
+
+  // Verify signature of a digest, one of a message, typedData or other
+  async isValidSignature(
+    address: string,
+    digest: Uint8Array,
+    signature: string,
+    chainId: number,
+    walletContext?: WalletContext
+  ): Promise<boolean | undefined> {
+    const provider = this.wallet.getProvider(chainId)
+    if (!provider) throw new Error(`unable to get provider for chainId ${chainId}`)
+    return isValidSignature(address, digest, signature, provider, chainId, walletContext)
+  }
+
+  // Verify message signature
+  isValidMessageSignature(
+    address: string,
+    message: string | Uint8Array,
+    signature: string,
+    chainId: number,
+    walletContext?: WalletContext
+  ): Promise<boolean | undefined> {
+    return this.isValidSignature(address, encodeMessageDigest(message), signature, chainId, walletContext)
+  }
+
+  // Verify typedData signature
+  isValidTypedDataSignature(
+    address: string,
+    typedData: TypedData,
+    signature: string,
+    chainId: number,
+    walletContext?: WalletContext
+  ): Promise<boolean | undefined> {
+    return this.isValidSignature(address, encodeTypedDataDigest(typedData), signature, chainId, walletContext)
+  }
+
+  // Recover the WalletConfig from a signature + digest combo
+  recoverWalletConfig = async (
+    address: string,
+    digest: BytesLike,
+    signature: string | DecodedSignature,
+    chainId: BigNumberish,
+    walletContext?: WalletContext
+  ): Promise<WalletConfig> => {
+    walletContext = walletContext || (await this.wallet.getWalletContext())
+    return recoverWalletConfig(address, digest, signature, chainId, walletContext)
+  }
+
+  // Recover the WalletConfig from a signature of a message
+  recoverWalletConfigFromMessage = async (
+    address: string,
+    message: string | Uint8Array,
+    signature: string | DecodedSignature,
+    chainId: BigNumberish,
+    walletContext?: WalletContext
+  ): Promise<WalletConfig> => {
+    walletContext = walletContext || (await this.wallet.getWalletContext())
+    return recoverWalletConfig(address, encodeMessageDigest(message), signature, chainId, walletContext)
+  }
+
+  // Recover the WalletConfig from a signature of a typedData object
+  recoverWalletConfigFromTypedData = async (
+    address: string,
+    typedData: TypedData,
+    signature: string | DecodedSignature,
+    chainId: BigNumberish,
+    walletContext?: WalletContext
+  ): Promise<WalletConfig> => {
+    walletContext = walletContext || (await this.wallet.getWalletContext())
+    return recoverWalletConfig(address, encodeTypedDataDigest(typedData), signature, chainId, walletContext)
+  }
+
+  // sendTransaction()
+  // sendTransactions()
+
+  // sendETH()
+  // sendToken()
+  // sendCoin() -- sugar for sendToken()
+  // sendCollectible() -- sugar for sendToken()
+  // callContract()
+
+  // transactionHistory()
+  // getReceipt()
+  // getLogs()
+  // // ..
+
+  // isWalletDeployed()
+  // deployWallet()
+
+  // validateSignature()
+  // recoverWalletConfig()
+  // recoverAddress()
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from './transports'
+export * from './types'
+export * from './wallet'
+export * from './provider'
+export * from './utils'