message provider multiplexer

packages/0xsequence/tests/browser/mock-wallet/mock-wallet.test.ts

@@ -77,22 +77,13 @@ const main = async () => {
     context: deployedWalletContext
   }, owner)
 
-
-  // const txn = await relayer.deployWallet(wallet.config, sequenceContext)
-  // console.log('...', txn)
-
-
   // the json-rpc signer via the wallet
-  // const mockUserPrompter = new MockWalletUserPrompter(true)
   const walletRequestHandler = new WalletRequestHandler(account, null, networks)
 
-
   // setup and register window message transport
   const windowHandler = new WindowMessageHandler(walletRequestHandler)
   windowHandler.register()
 
-  // TODO: register the ProxyMessageHandler() + register()
-
 }
 
 main()

packages/0xsequence/tests/browser/mux-transport/mux.test.ts

@@ -0,0 +1,154 @@
+import {
+  ProxyMessageProvider, ProviderMessageTransport, ProviderMessage, WalletRequestHandler,
+  ProxyMessageChannel, ProxyMessageHandler, Wallet, DefaultProviderConfig, Web3Provider,
+  WindowMessageHandler
+} from '@0xsequence/provider'
+import { ethers, Wallet as EOAWallet } from 'ethers'
+import { JsonRpcProvider } from '@ethersproject/providers'
+import { test, assert } from '../../utils/assert'
+import { Networks, WalletContext } from '@0xsequence/network'
+import { Wallet as SequenceWallet, Account as SequenceAccount, isValidSignature, packMessageData, recoverConfig } from '@0xsequence/wallet'
+import { addressOf } from '@0xsequence/config'
+import { LocalRelayer } from '@0xsequence/relayer'
+import { testAccounts, getEOAWallet, testWalletContext } from '../testutils'
+
+
+// Tests simulates a multi-message provider environment by having a wallet available via the
+// proxy channel and wallet window.
+export const tests = async () => {
+
+  //
+  // Providers
+  //
+  const provider1 = new JsonRpcProvider('http://localhost:8545')
+  const provider2 = new JsonRpcProvider('http://localhost:9545')
+
+
+  //
+  // Deploy Sequence WalletContext (deterministic). We skip deployment
+  // as we rely on mock-wallet to deploy it.
+  //
+  const deployedWalletContext = testWalletContext
+  console.log('walletContext:', deployedWalletContext)
+
+
+  //
+  // Proxy Channel (normally would be out-of-band)
+  //
+  const ch = new ProxyMessageChannel()
+
+
+  //
+  // Wallet Handler (local mock wallet, same a mock-wallet tests)
+  //
+
+  // owner account address: 0x4e37E14f5d5AAC4DF1151C6E8DF78B7541680853
+  const owner = getEOAWallet(testAccounts[0].privateKey)
+
+
+  // relayers, account address: 0x3631d4d374c3710c3456d6b1de1ee8745fbff8ba
+  // const relayerAccount = getEOAWallet(testAccounts[5].privateKey)
+  const relayer1 = new LocalRelayer(getEOAWallet(testAccounts[5].privateKey))
+  const relayer2 = new LocalRelayer(getEOAWallet(testAccounts[5].privateKey, provider2))
+
+
+  // wallet account address: 0x24E78922FE5eCD765101276A422B8431d7151259 based on the chainId
+  const swallet = (await SequenceWallet.singleOwner(owner, deployedWalletContext)).connect(provider1, relayer1)
+
+  // Network available list
+  const networks: Networks = [
+    {
+      name: 'hardhat',
+      chainId: 31337,
+      rpcUrl: provider1.connection.url,
+      provider: provider1,
+      relayer: relayer1,
+      isDefaultChain: true,
+      // isAuthChain: true
+    },
+    {
+      name: 'hardhat2',
+      chainId: 31338,
+      rpcUrl: provider2.connection.url,
+      provider: provider2,
+      relayer: relayer2,
+      isAuthChain: true
+    }
+  ]
+
+  // Account for managing multi-network wallets
+  const saccount = new SequenceAccount({
+    initialConfig: swallet.config,
+    networks,
+    context: deployedWalletContext
+  }, owner)
+
+  // the rpc signer via the wallet
+  const walletRequestHandler = new WalletRequestHandler(saccount, null, networks)
+
+  // register wallet message handler, in this case using the ProxyMessage transport.
+  const proxyHandler = new ProxyMessageHandler(walletRequestHandler, ch.wallet)
+  proxyHandler.register()
+
+  // register window message transport
+  const windowHandler = new WindowMessageHandler(walletRequestHandler)
+  windowHandler.register()
+
+
+  //
+  // Dapp, wallet provider and dapp tests
+  //
+
+  // wallet provider with multiple message provider transports enabled
+  const wallet = new Wallet('hardhat', {
+    walletAppURL: 'http://localhost:9999/mock-wallet/mock-wallet.test.html',
+    transports: {
+      windowTransport: { enabled: true },
+      proxyTransport: { enabled: true, appPort: ch.app }
+    }
+  })
+
+  // provider + signer, by default if a chainId is not specified it will direct
+  // requests to the defaultChain
+  // const provider = wallet.getProvider()
+  // const signer = wallet.getSigner()
+
+  // clear it in case we're testing in browser session
+  wallet.logout()
+
+  await test('is logged out', async () => {
+    assert.false(wallet.isLoggedIn(), 'is logged out')
+  })
+
+  await test('is disconnected', async () => {
+    assert.false(wallet.isConnected(), 'is disconnnected')
+  })
+
+  await test('login', async () => {
+    const loggedIn = await wallet.login()
+    assert.true(loggedIn, 'is logged in')
+  })
+
+  await test('isConnected', async () => {
+    assert.true(wallet.isConnected(), 'is connected')
+  })
+
+  let walletContext: WalletContext
+  await test('getWalletContext', async () => {
+    walletContext = await wallet.getWalletContext()
+    assert.equal(walletContext.factory, deployedWalletContext.factory, 'wallet context factory')
+    assert.equal(walletContext.guestModule, deployedWalletContext.guestModule, 'wallet context guestModule')
+  })
+
+  await test('getChainId', async () => {
+    const chainId = await wallet.getChainId()
+    assert.equal(chainId, 31337, 'chainId is correct')
+  })
+
+  await test('getChainId for other chain', async () => {
+    const p = wallet.getProvider(31338)
+    assert.equal(await p.getChainId(), 31338, 'chainId of other chain is 31338')
+  })
+
+}
+

packages/0xsequence/tests/browser/proxy-transport/channel.test.ts

@@ -1,6 +1,6 @@
-import { ProxyMessageProvider, ProviderMessageTransport, ProviderMessage, WalletRequestHandler, ProxyMessageChannel, ProxyMessageHandler } from '@0xsequence/provider'
+import { Web3Provider, ProxyMessageProvider, ProviderMessageTransport, ProviderMessage, WalletRequestHandler, ProxyMessageChannel, ProxyMessageHandler } from '@0xsequence/provider'
 import { ethers, Wallet as EOAWallet } from 'ethers'
-import { Web3Provider, JsonRpcProvider } from '@ethersproject/providers'
+import { JsonRpcProvider } from '@ethersproject/providers'
 import { test, assert } from '../../utils/assert'
 import { sequenceContext, testnetNetworks } from '@0xsequence/network'
 import { Wallet, isValidSignature, packMessageData, recoverConfig } from '@0xsequence/wallet'
@@ -17,13 +17,15 @@ export const tests = async () => {
   // `ch.app` (port) will be injected into the app, and `ch.wallet` (port) will be injected into the wallet.
   //
   // Sending messages to the app port will go through channel and get received by the wallet.
-  // Sending message to the wallet port will go through channel and get received by the app.
+  // Sending messages to the wallet port will go through channel and get received by the app.
   const ch = new ProxyMessageChannel()
 
-  //
-  // App Provider
-  //
-  const walletProvider = new ProxyMessageProvider(ch.app)
+  ch.app.on('connect', () => {
+    console.log('wallet connected.')
+  })
+  ch.app.on('disconnect', () => {
+    console.log('wallet disconnected.')
+  })
 
   //
   // Wallet Handler
@@ -39,24 +41,30 @@ export const tests = async () => {
   const rpcProvider = new JsonRpcProvider('http://localhost:8545')
   const wallet = (await Wallet.singleOwner(owner)).connect(rpcProvider, relayer)
 
-
-
   // the rpc signer via the wallet
   const walletRequestHandler = new WalletRequestHandler(wallet, null, [])
 
+  // register wallet message handler, in this case using the ProxyMessage transport.
   const proxyHandler = new ProxyMessageHandler(walletRequestHandler, ch.wallet)
   proxyHandler.register()
 
-  //--
 
-  // TODO: switch to Sequence Web3Provider ........
+  //
+  // App Provider
+  //
+  const walletProvider = new ProxyMessageProvider(ch.app)
+  walletProvider.register()
+
+  walletProvider.openWallet()
+  await walletProvider.waitUntilConnected()
+
+  // setup web3 provider
   const provider = new Web3Provider(walletProvider)
   const signer = provider.getSigner()
-
   const address = await signer.getAddress()
 
   await test('verifying getAddress result', async () => {
-    assert.equal(address, '0x24E78922FE5eCD765101276A422B8431d7151259', 'wallet address')
+    assert.equal(address.toLowerCase(), '0x24E78922FE5eCD765101276A422B8431d7151259'.toLowerCase(), 'wallet address')
   })
 
   await test('sending a json-rpc request', async () => {
@@ -81,9 +89,6 @@ export const tests = async () => {
   await test('sign a message and validate/recover', async () => {
     const message = ethers.utils.toUtf8Bytes('hihi')
 
-    // TODO: signer should be a Sequence signer, and should be able to specify the chainId
-    // however, for a single wallet, it can check the chainId and throw if doesnt match, for multi-wallet it will select
-
     //
     // Sign the message
     //
@@ -121,7 +126,6 @@ export const tests = async () => {
     assert.true(singleSignerAddress.toLowerCase() === walletConfig.signers[0].address.toLowerCase(), 'owner address check')
   })
 
-  // TODO: we need to test wallet notifications from wallet to app..
-  // TODO: perhaps we can trigger a network change there..? and notifyNetwork..?
+  walletProvider.closeWallet()
 
 }

packages/0xsequence/tests/browser/wallet-provider/dapp.test.ts

@@ -114,8 +114,6 @@ export const tests = async () => {
     assert.equal(allWalletStates.length, 2, '2 wallet states (one for each chain)')
 
     // we expect network order to be [defaultChain, authChain, ..], so chain 31337 will be at index 0
-    // hmm.. TODO: WalletProvider defaultNetwork should specify the "defaultNetwork", which will
-    // become our *defaultChain* ..
     const state1 = allWalletStates[0]
     assert.true(state1.chainId === 31337, 'state1, chainId is 31337')
     assert.true(state1.config.threshold === 1, 'state1, threshold')

packages/0xsequence/tests/mux-transport.spec.ts

@@ -0,0 +1,3 @@
+import { runBrowserTests } from './utils/browser-test-runner'
+
+runBrowserTests('mux-transport', 'mux-transport/mux.test.html')

packages/config/src/config.ts

@@ -25,7 +25,7 @@ export interface WalletState {
 
   deployed: boolean
   imageHash: string
-  currentImageHash?: string // TODO: rename to deployedImageHash
+  currentImageHash?: string
 
   published?: boolean
 }

packages/provider/src/index.ts

@@ -1,5 +1,4 @@
 export * from './transports'
 export * from './types'
 export * from './wallet'
-export * from './wallet-request-handler'
 export * from './provider'

packages/provider/src/provider.ts

@@ -8,7 +8,7 @@ import { WalletConfig, WalletState } from '@0xsequence/config'
 import { Relayer } from '@0xsequence/relayer'
 import { Deferrable, shallowCopy, resolveProperties } from '@0xsequence/utils'
 import { TransactionRequest, TransactionResponse, Transactionish, SignedTransactions } from '@0xsequence/transactions'
-import { WalletRequestHandler } from './wallet-request-handler'
+import { WalletRequestHandler } from './transports/wallet-request-handler'
 
 // naming..?
 // Web3Provider, Web3Signer, Web3Relayer, Web3Indexer