diff --git a/src/handshake-xx-fallback.ts b/src/handshake-xx-fallback.ts
index d25a7cf..17810e3 100644
--- a/src/handshake-xx-fallback.ts
+++ b/src/handshake-xx-fallback.ts
@@ -44,11 +44,10 @@ export class Handshake extends XXHandshake {
     } else {
       logger("XX Fallback Stage 0 - Responder waiting to receive first message...");
       const receivedMessageBuffer = decode0(this.initialMsg);
-      console.log("receivedMessageBuffer: ", receivedMessageBuffer)
       this.xx.recvMessage(this.session, {
         ne: receivedMessageBuffer.ne,
-        ns: Buffer.alloc(32),
-        ciphertext: Buffer.alloc(32),
+        ns: Buffer.alloc(0),
+        ciphertext: Buffer.alloc(0),
       });
       logger("XX Fallback Stage 0 - Responder received first message.");
     }
@@ -58,17 +57,19 @@ export class Handshake extends XXHandshake {
   public async exchange(): Promise<void> {
     if (this.isInitiator) {
       logger('XX Fallback Stage 1 - Initiator waiting to receive first message from responder...');
-      const receivedMessageBuffer = decode1(this.initialMsg);
+      const receivedMessageBuffer = decode1((await this.connection.readLP()).slice());
+      // const receivedMessageBuffer = decode1(this.initialMsg);
+      logger("Initiator receivedMessageBuffer in stage 1", receivedMessageBuffer);
       const plaintext = this.xx.recvMessage(this.session, receivedMessageBuffer);
       logger('XX Fallback Stage 1 - Initiator received the message. Got remote\'s static key.');
 
-      // logger("Initiator going to check remote's signature...");
-      // try {
-      //   await verifySignedPayload(receivedMessageBuffer.ns, plaintext, this.remotePeer.id);
-      // } catch (e) {
-      //   throw new Error(`Error occurred while verifying signed payload: ${e.message}`);
-      // }
-      // logger("All good with the signature!");
+      logger("Initiator going to check remote's signature...");
+      try {
+        await verifySignedPayload(receivedMessageBuffer.ns, plaintext, this.remotePeer.id);
+      } catch (e) {
+        throw new Error(`Error occurred while verifying signed payload: ${e.message}`);
+      }
+      logger("All good with the signature!");
     } else {
       logger('Stage 1 - Responder sending out first message with signed payload and static key.');
       const signedPayload = signPayload(this.libp2pPrivateKey, getHandshakePayload(this.staticKeys.publicKey));
diff --git a/test/xx-fallback-handshake.test.ts b/test/xx-fallback-handshake.test.ts
index 8c742ce..7902e4a 100644
--- a/test/xx-fallback-handshake.test.ts
+++ b/test/xx-fallback-handshake.test.ts
@@ -13,7 +13,7 @@ import {generateEd25519Keys, getKeyPairFromPeerId} from "./utils";
 import {Handshake} from "../src/handshake-xx-fallback";
 import {createPeerIdsFromFixtures} from "./fixtures/peer";
 import {assert} from "chai";
-import {encode0} from "../src/encoder";
+import {encode0, encode1} from "../src/encoder";
 
 describe("XX Fallback Handshake", () => {
   let peerA, peerB, fakePeer;
@@ -31,29 +31,28 @@ describe("XX Fallback Handshake", () => {
       const prologue = Buffer.from('/noise');
       const staticKeysInitiator = generateKeypair();
       const staticKeysResponder = generateKeypair();
+      const ephemeralKeys = generateKeypair();
 
       const {privateKey: initiatorPrivKey, publicKey: initiatorPubKey} = getKeyPairFromPeerId(peerA);
       const {privateKey: responderPrivKey, publicKey: responderPubKey} = getKeyPairFromPeerId(peerB);
 
       const signedPayload = signPayload(initiatorPrivKey, getHandshakePayload(staticKeysInitiator.publicKey));
-      const signedEarlyDataPayload = signEarlyDataPayload(initiatorPrivKey, Buffer.alloc(0));
       const handshakePayload = await createHandshakePayload(
         initiatorPubKey,
         initiatorPrivKey,
         signedPayload,
-        signedEarlyDataPayload,
       );
       const initialMsg = encode0({
-        ne: staticKeysInitiator.publicKey,
-        ns: Buffer.alloc(32),
+        ne: ephemeralKeys.publicKey,
+        ns: Buffer.alloc(0),
         ciphertext: handshakePayload,
       });
 
       const handshakeInit =
-        new Handshake(true, initiatorPrivKey, initiatorPubKey, prologue, staticKeysInitiator, connectionFrom, peerB, staticKeysInitiator, initialMsg);
+        new Handshake(true, initiatorPrivKey, initiatorPubKey, prologue, staticKeysInitiator, connectionFrom, peerB, ephemeralKeys, initialMsg);
 
       const handshakeResp =
-        new Handshake(false, responderPrivKey, responderPubKey, prologue, staticKeysResponder, connectionTo, peerA, staticKeysInitiator, initialMsg);
+        new Handshake(false, responderPrivKey, responderPubKey, prologue, staticKeysResponder, connectionTo, peerA, ephemeralKeys, initialMsg);
 
 
       await handshakeInit.propose();