From b7da81f9ecfc9df48d2db64bcaeed1420d887372 Mon Sep 17 00:00:00 2001
From: Denis Davidyuk <denis_davidyuk@hotmail.com>
Date: Sun, 18 Jun 2023 17:49:00 +0600
Subject: [PATCH] feat(aepp,wallet): support signing typed data

---
 examples/browser/aepp/src/App.vue             |  10 +-
 examples/browser/aepp/src/TypedData.vue       | 170 +++++++++++++
 examples/browser/wallet-iframe/src/App.vue    |  14 +-
 .../wallet-web-extension/src/Popup.vue        |   2 -
 .../wallet-web-extension/src/background.js    |  26 +-
 src/AeSdkWallet.ts                            |  15 ++
 src/account/Rpc.ts                            |  19 +-
 src/aepp-wallet-communication/rpc/types.ts    |  10 +
 src/aepp-wallet-communication/schema.ts       |   1 +
 test/integration/rpc.ts                       | 229 +++++++++++-------
 10 files changed, 394 insertions(+), 102 deletions(-)
 create mode 100644 examples/browser/aepp/src/TypedData.vue

diff --git a/examples/browser/aepp/src/App.vue b/examples/browser/aepp/src/App.vue
index 4ae4c33121..32bfef5240 100644
--- a/examples/browser/aepp/src/App.vue
+++ b/examples/browser/aepp/src/App.vue
@@ -25,6 +25,13 @@
     >
       Pay for transaction
     </a>
+    <a
+      href="#"
+      :class="{ active: view === 'TypedData' }"
+      @click="view = 'TypedData'"
+    >
+      Typed data
+    </a>
   </div>
 
   <Component
@@ -39,10 +46,11 @@ import Connect from './Connect.vue';
 import Basic from './Basic.vue';
 import Contracts from './Contracts.vue';
 import PayForTx from './PayForTx.vue';
+import TypedData from './TypedData.vue';
 
 export default {
   components: {
-    Connect, Basic, Contracts, PayForTx,
+    Connect, Basic, Contracts, PayForTx, TypedData,
   },
   data: () => ({ view: '' }),
   computed: mapState(['aeSdk']),
diff --git a/examples/browser/aepp/src/TypedData.vue b/examples/browser/aepp/src/TypedData.vue
new file mode 100644
index 0000000000..8307293bd6
--- /dev/null
+++ b/examples/browser/aepp/src/TypedData.vue
@@ -0,0 +1,170 @@
+<template>
+  <h2>Domain</h2>
+  <div class="group">
+    <div>
+      <div>Name</div>
+      <div>
+        <input
+          :value="domain.name"
+          @input="domain.name = $event.target.value || null"
+        >
+      </div>
+    </div>
+    <div>
+      <div>Version</div>
+      <div>
+        <input
+          :value="domain.version"
+          @input="domain.version = $event.target.value || null"
+        >
+      </div>
+    </div>
+    <div>
+      <div>Network id</div>
+      <div>
+        <input
+          :value="domain.networkId"
+          @input="domain.networkId = $event.target.value || null"
+        >
+      </div>
+    </div>
+    <div>
+      <div>Contract address</div>
+      <div>
+        <input
+          :value="domain.contractAddress"
+          @input="domain.contractAddress = $event.target.value || null"
+        >
+      </div>
+    </div>
+  </div>
+
+  <h2>Data</h2>
+  <div class="group">
+    <div>
+      <div>Type</div>
+      <div>
+        <textarea
+          v-model="aci"
+          placeholder="Type as ACI JSON"
+        />
+      </div>
+    </div>
+    <div>
+      <div>Data</div>
+      <div>
+        <textarea v-model="data" />
+      </div>
+    </div>
+    <div>
+      <div>Encoded data</div>
+      <Value :value="toPromise(() => dataEncoded)" />
+    </div>
+    <div>
+      <div>Hash</div>
+      <Value :value="toPromise(() => hash.toString('base64'))" />
+    </div>
+  </div>
+
+  <h2>Sign</h2>
+  <div class="group">
+    <button @click="signPromise = signTypedData()">
+      Sign
+    </button>
+    <div v-if="signPromise">
+      <div>Signature</div>
+      <Value :value="signPromise" />
+    </div>
+  </div>
+
+  <h2>Verify</h2>
+  <div class="group">
+    <div>
+      <div>Signature</div>
+      <div>
+        <input
+          v-model="verifySignature"
+          placeholder="sg-encoded"
+        >
+      </div>
+    </div>
+    <div>
+      <div>Signer address</div>
+      <div>
+        <input
+          v-model="verifyAddress"
+          placeholder="ak_..."
+        >
+      </div>
+    </div>
+    <button @click="verifyPromise = verifyTypedData()">
+      Verify
+    </button>
+    <div v-if="verifyPromise">
+      <div>Is signature correct</div>
+      <Value :value="verifyPromise" />
+    </div>
+  </div>
+</template>
+
+<script>
+import { mapState } from 'vuex';
+import {
+  hashTypedData, encodeFateValue, verify, decode,
+} from '@aeternity/aepp-sdk';
+import Value from './components/Value.vue';
+
+export default {
+  components: {
+    Value,
+  },
+  data: () => ({
+    domain: {
+      name: 'Simple æpp',
+      version: 2,
+      networkId: 'ae_uat',
+      contractAddress: null,
+    },
+    aci: Value.methods.valueToString({
+      record: [
+        { name: 'operation', type: 'string' },
+        { name: 'parameter', type: 'int' },
+      ],
+    }),
+    data: Value.methods.valueToString({
+      operation: 'test',
+      parameter: 42,
+    }),
+    signPromise: null,
+    verifySignature: null,
+    verifyAddress: null,
+    verifyPromise: null,
+  }),
+  computed: {
+    ...mapState(['aeSdk']),
+    dataParsed() {
+      return JSON.parse(this.data);
+    },
+    aciParsed() {
+      return JSON.parse(this.aci);
+    },
+    dataEncoded() {
+      return encodeFateValue(this.dataParsed, this.aciParsed);
+    },
+    hash() {
+      return hashTypedData(this.dataEncoded, this.aciParsed, this.domain);
+    },
+  },
+  methods: {
+    async toPromise(getter) {
+      return getter();
+    },
+    signTypedData() {
+      return this.aeSdk.signTypedData(this.dataEncoded, this.aciParsed, this.domain);
+    },
+    async verifyTypedData() {
+      return verify(this.hash, decode(this.verifySignature), this.verifyAddress);
+    },
+  },
+};
+</script>
diff --git a/examples/browser/wallet-iframe/src/App.vue b/examples/browser/wallet-iframe/src/App.vue
index 49cc763e4d..b0aad366e0 100644
--- a/examples/browser/wallet-iframe/src/App.vue
+++ b/examples/browser/wallet-iframe/src/App.vue
@@ -31,7 +31,7 @@
 import {
   MemoryAccount, generateKeyPair, AeSdkWallet, Node, CompilerHttp,
   BrowserWindowMessageConnection, METHODS, WALLET_TYPE,
-  RpcConnectionDenyError, RpcRejectedByUserError,
+  RpcConnectionDenyError, RpcRejectedByUserError, unpackTx, decodeFateValue,
 } from '@aeternity/aepp-sdk';
 import Value from './Value.vue';
 
@@ -78,7 +78,7 @@ export default {
     const genConfirmCallback = (actionName) => (aeppId, parameters, origin) => {
       if (!confirm([
         `Client ${aeppInfo[aeppId].name} with id ${aeppId} at ${origin} want to ${actionName}`,
-        JSON.stringify(parameters, null, 2),
+        Value.methods.valueToString(parameters),
       ].join('\n'))) {
         throw new RpcRejectedByUserError();
       }
@@ -87,7 +87,7 @@ export default {
     class AccountMemoryProtected extends MemoryAccount {
       async signTransaction(tx, { aeppRpcClientId: id, aeppOrigin, ...options } = {}) {
         if (id != null) {
-          const opt = { ...options };
+          const opt = { ...options, unpackedTx: unpackTx(tx) };
           if (opt.onCompiler) opt.onCompiler = '<Compiler>';
           if (opt.onNode) opt.onNode = '<Node>';
           genConfirmCallback(`sign transaction ${tx}`)(id, opt, aeppOrigin);
@@ -102,6 +102,14 @@ export default {
         return super.signMessage(message, options);
       }
 
+      async signTypedData(data, aci, { aeppRpcClientId: id, aeppOrigin, ...options }) {
+        if (id != null) {
+          const opt = { ...options, aci, decodedData: decodeFateValue(data, aci) };
+          genConfirmCallback(`sign typed data ${data}`)(id, opt, aeppOrigin);
+        }
+        return super.signTypedData(data, aci, options);
+      }
+
       static generate() {
         // TODO: can inherit parent method after implementing https://github.com/aeternity/aepp-sdk-js/issues/1672
         return new AccountMemoryProtected(generateKeyPair().secretKey);
diff --git a/examples/browser/wallet-web-extension/src/Popup.vue b/examples/browser/wallet-web-extension/src/Popup.vue
index c105bf3001..aab4088f1a 100644
--- a/examples/browser/wallet-web-extension/src/Popup.vue
+++ b/examples/browser/wallet-web-extension/src/Popup.vue
@@ -23,7 +23,6 @@
 
 <script>
 import browser from 'webextension-polyfill';
-import { unpackTx } from '@aeternity/aepp-sdk';
 
 export default {
   data: () => ({
@@ -37,7 +36,6 @@ export default {
     const data = new URL(location).searchParams.get('data');
     if (data != null) {
       const { aeppOrigin, action, popupId, ...params } = JSON.parse(data);
-      if (params.transaction) params.unpackedTx = unpackTx(params.transaction);
       this.aeppOrigin = aeppOrigin;
       this.action = action;
       this.popupId = popupId;
diff --git a/examples/browser/wallet-web-extension/src/background.js b/examples/browser/wallet-web-extension/src/background.js
index d5dc92cd60..7f352ae2aa 100644
--- a/examples/browser/wallet-web-extension/src/background.js
+++ b/examples/browser/wallet-web-extension/src/background.js
@@ -1,15 +1,23 @@
 import browser from 'webextension-polyfill';
 import {
   AeSdkWallet, CompilerHttp, Node, MemoryAccount, generateKeyPair, BrowserRuntimeConnection,
-  WALLET_TYPE, RpcConnectionDenyError, RpcRejectedByUserError,
+  WALLET_TYPE, RpcConnectionDenyError, RpcRejectedByUserError, unpackTx, decodeFateValue,
 } from '@aeternity/aepp-sdk';
 
+function stringifyBigint(value) {
+  return JSON.stringify(
+    value,
+    (k, v) => (typeof v === 'bigint' ? `${v} (as BigInt)` : v),
+    2,
+  );
+}
+
 let popupCounter = 0;
 async function confirmInPopup(parameters) {
   const popupUrl = new URL(browser.runtime.getURL('./popup.html'));
   const popupId = popupCounter;
   popupCounter += 1;
-  popupUrl.searchParams.set('data', JSON.stringify({ ...parameters, popupId }));
+  popupUrl.searchParams.set('data', stringifyBigint({ ...parameters, popupId }));
   await browser.windows.create({
     url: popupUrl.toString(),
     type: 'popup',
@@ -42,10 +50,10 @@ const genConfirmCallback = (action) => async (aeppId, parameters, aeppOrigin) =>
 class AccountMemoryProtected extends MemoryAccount {
   async signTransaction(transaction, { aeppRpcClientId: id, aeppOrigin, ...options } = {}) {
     if (id != null) {
-      const opt = { ...options };
+      const opt = { ...options, transaction, unpackedTx: unpackTx(transaction) };
       if (opt.onCompiler) opt.onCompiler = '<Compiler>';
       if (opt.onNode) opt.onNode = '<Node>';
-      await genConfirmCallback('sign transaction')(id, { ...opt, transaction }, aeppOrigin);
+      await genConfirmCallback('sign transaction')(id, opt, aeppOrigin);
     }
     return super.signTransaction(transaction, options);
   }
@@ -57,6 +65,16 @@ class AccountMemoryProtected extends MemoryAccount {
     return super.signMessage(message, options);
   }
 
+  async signTypedData(data, aci, { aeppRpcClientId: id, aeppOrigin, ...options }) {
+    if (id != null) {
+      const opt = {
+        ...options, aci, data, decodedData: decodeFateValue(data, aci),
+      };
+      await genConfirmCallback('sign typed data')(id, opt, aeppOrigin);
+    }
+    return super.signTypedData(data, aci, options);
+  }
+
   static generate() {
     // TODO: can inherit parent method after implementing https://github.com/aeternity/aepp-sdk-js/issues/1672
     return new AccountMemoryProtected(generateKeyPair().secretKey);
diff --git a/src/AeSdkWallet.ts b/src/AeSdkWallet.ts
index cb1c2ab033..8a46aa61fc 100644
--- a/src/AeSdkWallet.ts
+++ b/src/AeSdkWallet.ts
@@ -280,6 +280,21 @@ export default class AeSdkWallet extends AeSdk {
               signature: Buffer.from(await this.signMessage(message, parameters)).toString('hex'),
             };
           },
+          [METHODS.signTypedData]: async ({
+            domain, aci, data, onAccount = this.address,
+          }, origin) => {
+            if (!this._isRpcClientConnected(id)) throw new RpcNotAuthorizeError();
+            if (!this.addresses().includes(onAccount)) {
+              throw new RpcPermissionDenyError(onAccount);
+            }
+
+            const parameters = {
+              ...domain, onAccount, aeppOrigin: origin, aeppRpcClientId: id,
+            };
+            return {
+              signature: await this.signTypedData(data, aci, parameters),
+            };
+          },
         },
       ),
     };
diff --git a/src/account/Rpc.ts b/src/account/Rpc.ts
index 196ac3fda0..7c7984e436 100644
--- a/src/account/Rpc.ts
+++ b/src/account/Rpc.ts
@@ -52,8 +52,21 @@ export default class AccountRpc extends AccountBase {
     return Buffer.from(signature, 'hex');
   }
 
-  // eslint-disable-next-line class-methods-use-this
-  override async signTypedData(): Promise<Encoded.Signature> {
-    throw new NotImplementedError('Typed data signing using wallet');
+  override async signTypedData(
+    data: Encoded.ContractBytearray,
+    aci: Parameters<AccountBase['signTypedData']>[1],
+    {
+      name, version, contractAddress, networkId,
+    }: Parameters<AccountBase['signTypedData']>[2] = {},
+  ): Promise<Encoded.Signature> {
+    const { signature } = await this._rpcClient.request(METHODS.signTypedData, {
+      onAccount: this.address,
+      domain: {
+        name, version, networkId, contractAddress,
+      },
+      aci,
+      data,
+    });
+    return signature;
   }
 }
diff --git a/src/aepp-wallet-communication/rpc/types.ts b/src/aepp-wallet-communication/rpc/types.ts
index c7f4ad7015..4554a57f67 100644
--- a/src/aepp-wallet-communication/rpc/types.ts
+++ b/src/aepp-wallet-communication/rpc/types.ts
@@ -1,4 +1,5 @@
 import { Encoded } from '../../utils/encoder';
+import { Domain, AciValue } from '../../utils/typed-data';
 import { METHODS, SUBSCRIPTION_TYPES, WALLET_TYPE } from '../schema';
 import { TransformNodeType } from '../../Node';
 import { SignedTx } from '../../apis/node';
@@ -72,6 +73,15 @@ export interface WalletApi {
   [METHODS.signMessage]: (
     p: { message: string; onAccount: Encoded.AccountAddress }
   ) => Promise<{ signature: string }>;
+
+  [METHODS.signTypedData]: (
+    p: {
+      domain: Domain;
+      aci: AciValue;
+      data: Encoded.ContractBytearray;
+      onAccount: Encoded.AccountAddress;
+    },
+  ) => Promise<{ signature: Encoded.Signature }>;
 }
 
 export interface AeppApi {
diff --git a/src/aepp-wallet-communication/schema.ts b/src/aepp-wallet-communication/schema.ts
index 4fd43e247c..e9fc4d89ae 100644
--- a/src/aepp-wallet-communication/schema.ts
+++ b/src/aepp-wallet-communication/schema.ts
@@ -36,6 +36,7 @@ export const enum METHODS {
   connect = 'connection.open',
   sign = 'transaction.sign',
   signMessage = 'message.sign',
+  signTypedData = 'typedData.sign',
   subscribeAddress = 'address.subscribe',
   updateNetwork = 'networkId.update',
   closeConnection = 'connection.close',
diff --git a/test/integration/rpc.ts b/test/integration/rpc.ts
index cc7ee8af36..74304f18dd 100644
--- a/test/integration/rpc.ts
+++ b/test/integration/rpc.ts
@@ -30,6 +30,7 @@ import {
   AccountBase,
   verifyMessage,
   buildTx,
+  hashTypedData,
 } from '../../src';
 import { getBufferToSign } from '../../src/account/Memory';
 import { ImplPostMessage } from '../../src/aepp-wallet-communication/connection/BrowserWindowMessage';
@@ -355,38 +356,84 @@ describe('Aepp<->Wallet', function aeppWallet() {
       res.blockHeight.should.be.a('number');
     });
 
-    it('Sign message: rejected', async () => {
-      let origin;
-      wallet._resolveAccount().signMessage = (message, { aeppOrigin } = {}) => {
-        origin = aeppOrigin;
-        throw new RpcRejectedByUserError();
-      };
-      await expect(aepp.signMessage('test')).to.be.eventually
-        .rejectedWith('Operation rejected by user').with.property('code', 4);
-      expect(origin).to.be.equal('http://origin.test');
-    });
+    describe('Sign message', () => {
+      it('rejected by wallet', async () => {
+        let origin;
+        wallet._resolveAccount().signMessage = (message, { aeppOrigin } = {}) => {
+          origin = aeppOrigin;
+          throw new RpcRejectedByUserError();
+        };
+        await expect(aepp.signMessage('test')).to.be.eventually
+          .rejectedWith('Operation rejected by user').with.property('code', 4);
+        expect(origin).to.be.equal('http://origin.test');
+      });
 
-    it('Sign message', async () => {
-      // @ts-expect-error removes object property to restore the original behavior
-      delete wallet._resolveAccount().signMessage;
-      const messageSig = await aepp.signMessage('test');
-      messageSig.should.be.instanceof(Buffer);
-      expect(verifyMessage('test', messageSig, aepp.address)).to.be.equal(true);
-    });
+      it('works', async () => {
+        // @ts-expect-error removes object property to restore the original behavior
+        delete wallet._resolveAccount().signMessage;
+        const messageSig = await aepp.signMessage('test');
+        messageSig.should.be.instanceof(Buffer);
+        expect(verifyMessage('test', messageSig, aepp.address)).to.be.equal(true);
+      });
 
-    it('Sign message fails with unknown error', async () => {
-      wallet._resolveAccount().signMessage = () => {
-        throw new Error('test');
-      };
-      await expect(aepp.signMessage('test', { onAccount: account.address }))
-        .to.be.rejectedWith('The peer failed to execute your request due to unknown error');
+      it('fails with unknown error', async () => {
+        wallet._resolveAccount().signMessage = () => {
+          throw new Error('test');
+        };
+        await expect(aepp.signMessage('test', { onAccount: account.address }))
+          .to.be.rejectedWith('The peer failed to execute your request due to unknown error');
+      });
+
+      it('signs using specific account', async () => {
+        const onAccount = wallet.addresses()[1];
+        const messageSig = await aepp.signMessage('test', { onAccount });
+        expect(verifyMessage('test', messageSig, onAccount)).to.be.equal(true);
+      });
     });
 
-    it('Sign message using specific account', async () => {
-      const onAccount = wallet.addresses()[1];
-      const messageSig = await aepp.signMessage('test', { onAccount });
-      messageSig.should.be.instanceof(Buffer);
-      expect(verifyMessage('test', messageSig, onAccount)).to.be.equal(true);
+    describe('Sign typed data', () => {
+      const recordAci = {
+        record: [
+          { name: 'operation', type: 'string' },
+          { name: 'parameter', type: 'int' },
+        ],
+      } as const;
+      const recordData = 'cb_KxF0ZXN0VANAuWU=';
+
+      it('rejected by wallet', async () => {
+        let origin;
+        wallet._resolveAccount().signTypedData = (data, aci, { aeppOrigin } = {}) => {
+          origin = aeppOrigin;
+          throw new RpcRejectedByUserError();
+        };
+        await expect(aepp.signTypedData(recordData, recordAci)).to.be.eventually
+          .rejectedWith('Operation rejected by user').with.property('code', 4);
+        expect(origin).to.be.equal('http://origin.test');
+      });
+
+      it('works', async () => {
+        // @ts-expect-error removes object property to restore the original behavior
+        delete wallet._resolveAccount().signTypedData;
+        const messageSig = await aepp.signTypedData(recordData, recordAci);
+        expect(messageSig).to.satisfy((s: string) => s.startsWith('sg_'));
+        const hash = hashTypedData(recordData, recordAci, {});
+        expect(verify(hash, decode(messageSig), aepp.address)).to.be.equal(true);
+      });
+
+      it('fails with unknown error', async () => {
+        wallet._resolveAccount().signTypedData = () => {
+          throw new Error('test');
+        };
+        await expect(aepp.signTypedData(recordData, recordAci, { onAccount: account.address }))
+          .to.be.rejectedWith('The peer failed to execute your request due to unknown error');
+      });
+
+      it('signs using specific account', async () => {
+        const onAccount = wallet.addresses()[1];
+        const messageSig = await aepp.signTypedData(recordData, recordAci, { onAccount });
+        const hash = hashTypedData(recordData, recordAci, {});
+        expect(verify(hash, decode(messageSig), onAccount)).to.be.equal(true);
+      });
     });
 
     it('Sign and broadcast invalid transaction', async () => {
@@ -405,37 +452,39 @@ describe('Aepp<->Wallet', function aeppWallet() {
         .rejectedWith('Transaction verification errors: TTL 1 is already expired, current height is');
     });
 
-    it('Add new account to wallet: receive notification for update accounts', async () => {
-      if (aepp._accounts == null) throw new UnexpectedTsError();
-      const connectedLength = Object.keys(aepp._accounts.connected).length;
-      const accountsPromise = new Promise<Accounts>((resolve) => {
-        aepp.onAddressChange = resolve;
+    describe('Subscriptions', () => {
+      it('Add new account to wallet: receive notification for update accounts', async () => {
+        if (aepp._accounts == null) throw new UnexpectedTsError();
+        const connectedLength = Object.keys(aepp._accounts.connected).length;
+        const accountsPromise = new Promise<Accounts>((resolve) => {
+          aepp.onAddressChange = resolve;
+        });
+        wallet.addAccount(MemoryAccount.generate());
+        expect(Object.keys((await accountsPromise).connected).length).to.equal(connectedLength + 1);
       });
-      wallet.addAccount(MemoryAccount.generate());
-      expect(Object.keys((await accountsPromise).connected).length).to.equal(connectedLength + 1);
-    });
 
-    it('Receive update for wallet select account', async () => {
-      if (aepp._accounts == null) throw new UnexpectedTsError();
-      const connectedAccount = Object
-        .keys(aepp._accounts.connected)[0] as Encoded.AccountAddress;
-      const accountsPromise = new Promise<Accounts>((resolve) => {
-        aepp.onAddressChange = resolve;
+      it('Receive update for wallet select account', async () => {
+        if (aepp._accounts == null) throw new UnexpectedTsError();
+        const connectedAccount = Object
+          .keys(aepp._accounts.connected)[0] as Encoded.AccountAddress;
+        const accountsPromise = new Promise<Accounts>((resolve) => {
+          aepp.onAddressChange = resolve;
+        });
+        wallet.selectAccount(connectedAccount);
+        const { connected, current } = await accountsPromise;
+        if (current == null || connected == null) throw new UnexpectedTsError();
+        expect(current[connectedAccount]).to.be.eql({});
+        expect(Object.keys(connected).includes(connectedAccount)).to.be.equal(false);
       });
-      wallet.selectAccount(connectedAccount);
-      const { connected, current } = await accountsPromise;
-      if (current == null || connected == null) throw new UnexpectedTsError();
-      expect(current[connectedAccount]).to.be.eql({});
-      expect(Object.keys(connected).includes(connectedAccount)).to.be.equal(false);
-    });
 
-    it('Aepp: receive notification for network update', async () => {
-      const message = await new Promise<Network>((resolve) => {
-        aepp.onNetworkChange = (msg: any) => resolve(msg);
-        wallet.addNode('second_node', node, true);
+      it('Aepp: receive notification for network update', async () => {
+        const message = await new Promise<Network>((resolve) => {
+          aepp.onNetworkChange = (msg: any) => resolve(msg);
+          wallet.addNode('second_node', node, true);
+        });
+        message.networkId.should.be.equal(networkId);
+        expect(wallet.selectedNodeName).to.be.equal('second_node');
       });
-      message.networkId.should.be.equal(networkId);
-      expect(wallet.selectedNodeName).to.be.equal('second_node');
     });
 
     it('Try to connect unsupported protocol', async () => {
@@ -443,44 +492,46 @@ describe('Aepp<->Wallet', function aeppWallet() {
       await expect(aepp.rpcClient.request(METHODS.connect, { name: 'test-aepp', version: 2 as 1, connectNode: false })).to.be.eventually.rejectedWith('Unsupported Protocol Version').with.property('code', 5);
     });
 
-    it('Disconnect from wallet', async () => {
-      const walletDisconnect: Promise<any> = new Promise((resolve) => {
-        wallet.onDisconnect = (...args: any) => resolve(args);
-      });
-      const aeppDisconnect: Promise<any> = new Promise((resolve) => {
-        aepp.onDisconnect = (...args: any) => resolve(args);
-      });
-      connectionFromWalletToAepp.sendMessage({
-        method: METHODS.closeConnection, params: { reason: 'bye' }, jsonrpc: '2.0',
-      });
-      const [aeppMessage] = await aeppDisconnect;
-      aeppMessage.reason.should.be.equal('bye');
-      connectionFromAeppToWallet.sendMessage({
-        method: METHODS.closeConnection, params: { reason: 'bye' }, jsonrpc: '2.0',
+    describe('Disconnect', () => {
+      it('Disconnect from wallet', async () => {
+        const walletDisconnect: Promise<any> = new Promise((resolve) => {
+          wallet.onDisconnect = (...args: any) => resolve(args);
+        });
+        const aeppDisconnect: Promise<any> = new Promise((resolve) => {
+          aepp.onDisconnect = (...args: any) => resolve(args);
+        });
+        connectionFromWalletToAepp.sendMessage({
+          method: METHODS.closeConnection, params: { reason: 'bye' }, jsonrpc: '2.0',
+        });
+        const [aeppMessage] = await aeppDisconnect;
+        aeppMessage.reason.should.be.equal('bye');
+        connectionFromAeppToWallet.sendMessage({
+          method: METHODS.closeConnection, params: { reason: 'bye' }, jsonrpc: '2.0',
+        });
+        const [, walletMessage] = await walletDisconnect;
+        walletMessage.reason.should.be.equal('bye');
       });
-      const [, walletMessage] = await walletDisconnect;
-      walletMessage.reason.should.be.equal('bye');
-    });
-
-    it('Remove rpc client', async () => {
-      wallet.onConnection = () => {};
-      const id = wallet.addRpcClient(new BrowserWindowMessageConnection({
-        self: connections.walletWindow,
-        target: connections.aeppWindow,
-      }));
-      await aepp.connectToWallet(
-        new BrowserWindowMessageConnection({
-          self: connections.aeppWindow,
-          target: connections.walletWindow,
-        }),
-      );
 
-      wallet.removeRpcClient(id);
-      Array.from(wallet._clients.keys()).length.should.be.equal(0);
-    });
+      it('Remove rpc client', async () => {
+        wallet.onConnection = () => {};
+        const id = wallet.addRpcClient(new BrowserWindowMessageConnection({
+          self: connections.walletWindow,
+          target: connections.aeppWindow,
+        }));
+        await aepp.connectToWallet(
+          new BrowserWindowMessageConnection({
+            self: connections.aeppWindow,
+            target: connections.walletWindow,
+          }),
+        );
+
+        wallet.removeRpcClient(id);
+        Array.from(wallet._clients.keys()).length.should.be.equal(0);
+      });
 
-    it('Remove rpc client: client not found', () => {
-      expect(() => wallet.removeRpcClient('a1')).to.throw(UnknownRpcClientError, 'RpcClient with id a1 do not exist');
+      it('Remove rpc client: client not found', () => {
+        expect(() => wallet.removeRpcClient('a1')).to.throw(UnknownRpcClientError, 'RpcClient with id a1 do not exist');
+      });
     });
   });