diff --git a/subgraph/src/clear.ts b/subgraph/src/clear.ts
index cf4f1a723..1aafdc176 100644
--- a/subgraph/src/clear.ts
+++ b/subgraph/src/clear.ts
@@ -13,14 +13,21 @@ import {
   store,
 } from "@graphprotocol/graph-ts";
 
-export function makeClearV2Id(event: ethereum.Event): Bytes {
+export function makeClearEventId(event: ethereum.Event): Bytes {
   return Bytes.fromByteArray(
     crypto.keccak256(event.address.concat(event.transaction.hash))
   );
 }
 
-export function getOrderHash(value: ethereum.Value): Bytes {
-  return Bytes.fromByteArray(crypto.keccak256(ethereum.encode(value)!));
+export function getOrdersHash(event: ClearV2): Bytes[] {
+  return [
+    Bytes.fromByteArray(
+      crypto.keccak256(ethereum.encode(event.parameters[1].value)!)
+    ),
+    Bytes.fromByteArray(
+      crypto.keccak256(ethereum.encode(event.parameters[2].value)!)
+    ),
+  ];
 }
 
 export function makeClearBountyId(
@@ -195,10 +202,11 @@ export function handleClearBounty(
 }
 
 export function handleClear(event: ClearV2): void {
-  let clearTemporaryData = new ClearTemporaryData(makeClearV2Id(event));
+  let clearTemporaryData = new ClearTemporaryData(makeClearEventId(event));
 
-  let aliceOrderHash = getOrderHash(event.parameters[1].value);
-  let bobOrderHash = getOrderHash(event.parameters[2].value);
+  let hashes = getOrdersHash(event);
+  let aliceOrderHash = hashes[0];
+  let bobOrderHash = hashes[1];
 
   let aliceInput =
     event.params.alice.validInputs[
@@ -240,7 +248,7 @@ export function handleClear(event: ClearV2): void {
 }
 
 export function handleAfterClear(event: AfterClear): void {
-  let clearTemporaryData = ClearTemporaryData.load(makeClearV2Id(event));
+  let clearTemporaryData = ClearTemporaryData.load(makeClearEventId(event));
   if (clearTemporaryData) {
     // alice
     createTrade(
diff --git a/subgraph/tests/event-mocks.test.ts b/subgraph/tests/event-mocks.test.ts
index 2f24fe2bc..ef98150b9 100644
--- a/subgraph/tests/event-mocks.test.ts
+++ b/subgraph/tests/event-mocks.test.ts
@@ -127,7 +127,7 @@ export class Evaluable {
   }
 }
 
-function createOrder(
+export function createOrder(
   owner: Address,
   evaluable: Evaluable,
   validInputs: Array<IO>,
@@ -328,58 +328,17 @@ export function createMetaEvent(
   return metaEvent;
 }
 
-export class ClearV2Struct {
-  owner: Address;
-  evaluable: Evaluable;
-  validInputs: Array<IO>;
-  validOutputs: Array<IO>;
-  nonce: Bytes;
-
-  constructor(
-    owner: Address,
-    evaluable: Evaluable,
-    validInputs: Array<IO>,
-    validOutputs: Array<IO>,
-    nonce: Bytes
-  ) {
-    this.owner = owner;
-    this.evaluable = evaluable;
-    this.validInputs = validInputs;
-    this.validOutputs = validOutputs;
-    this.nonce = nonce;
-  }
-}
-
-export class ClearV2ClearConfigStruct {
-  aliceInputIOIndex: BigInt;
-  aliceOutputIOIndex: BigInt;
-  bobInputIOIndex: BigInt;
-  bobOutputIOIndex: BigInt;
-  aliceBountyVaultId: BigInt;
-  bobBountyVaultId: BigInt;
-
-  constructor(
-    aliceInputIOIndex: BigInt,
-    aliceOutputIOIndex: BigInt,
-    bobInputIOIndex: BigInt,
-    bobOutputIOIndex: BigInt,
-    aliceBountyVaultId: BigInt,
-    bobBountyVaultId: BigInt
-  ) {
-    this.aliceInputIOIndex = aliceInputIOIndex;
-    this.aliceOutputIOIndex = aliceOutputIOIndex;
-    this.bobInputIOIndex = bobInputIOIndex;
-    this.bobOutputIOIndex = bobOutputIOIndex;
-    this.aliceBountyVaultId = aliceBountyVaultId;
-    this.bobBountyVaultId = bobBountyVaultId;
-  }
-}
-
+// event ClearV2(address,(address,(address,address,bytes),(address,uint8,uint256)[],(address,uint8,uint256)[],bytes32),(address,(address,address,bytes),(address,uint8,uint256)[],(address,uint8,uint256)[],bytes32),(uint256,uint256,uint256,uint256,uint256,uint256))
 export function createClearEvent(
   sender: Address,
-  alice: ClearV2Struct,
-  bob: ClearV2Struct,
-  clearConfig: ClearV2ClearConfigStruct
+  aliceOrder: ethereum.Tuple,
+  bobOrder: ethereum.Tuple,
+  aliceInputIOIndex: BigInt,
+  aliceOutputIOIndex: BigInt,
+  bobInputIOIndex: BigInt,
+  bobOutputIOIndex: BigInt,
+  aliceBountyVaultId: BigInt,
+  bobBountyVaultId: BigInt
 ): ClearV2 {
   let mockEvent = newMockEvent();
   let clearEvent = new ClearV2(
@@ -397,48 +356,20 @@ export function createClearEvent(
   clearEvent.parameters.push(
     new ethereum.EventParam("sender", ethereum.Value.fromAddress(sender))
   );
-
-  let _alice = createOrder(
-    alice.owner,
-    alice.evaluable,
-    alice.validInputs,
-    alice.validOutputs,
-    alice.nonce
-  );
   clearEvent.parameters.push(
-    new ethereum.EventParam("alice", ethereum.Value.fromTuple(_alice))
-  );
-
-  let _bob = createOrder(
-    bob.owner,
-    bob.evaluable,
-    bob.validInputs,
-    bob.validOutputs,
-    bob.nonce
+    new ethereum.EventParam("alice", ethereum.Value.fromTuple(aliceOrder))
   );
   clearEvent.parameters.push(
-    new ethereum.EventParam("bob", ethereum.Value.fromTuple(_bob))
+    new ethereum.EventParam("bob", ethereum.Value.fromTuple(bobOrder))
   );
 
   let _clearConfig = new ethereum.Tuple();
-  _clearConfig.push(
-    ethereum.Value.fromUnsignedBigInt(clearConfig.aliceInputIOIndex)
-  );
-  _clearConfig.push(
-    ethereum.Value.fromUnsignedBigInt(clearConfig.aliceOutputIOIndex)
-  );
-  _clearConfig.push(
-    ethereum.Value.fromUnsignedBigInt(clearConfig.bobInputIOIndex)
-  );
-  _clearConfig.push(
-    ethereum.Value.fromI32(clearConfig.bobOutputIOIndex.toI32())
-  );
-  _clearConfig.push(
-    ethereum.Value.fromUnsignedBigInt(clearConfig.aliceBountyVaultId)
-  );
-  _clearConfig.push(
-    ethereum.Value.fromUnsignedBigInt(clearConfig.bobBountyVaultId)
-  );
+  _clearConfig.push(ethereum.Value.fromUnsignedBigInt(aliceInputIOIndex));
+  _clearConfig.push(ethereum.Value.fromUnsignedBigInt(aliceOutputIOIndex));
+  _clearConfig.push(ethereum.Value.fromUnsignedBigInt(bobInputIOIndex));
+  _clearConfig.push(ethereum.Value.fromUnsignedBigInt(bobOutputIOIndex));
+  _clearConfig.push(ethereum.Value.fromUnsignedBigInt(aliceBountyVaultId));
+  _clearConfig.push(ethereum.Value.fromUnsignedBigInt(bobBountyVaultId));
   clearEvent.parameters.push(
     new ethereum.EventParam(
       "clearConfig",
@@ -449,28 +380,13 @@ export function createClearEvent(
   return clearEvent;
 }
 
-export class AfterClearClearStateChangeStruct {
-  aliceOutput: BigInt;
-  bobOutput: BigInt;
-  aliceInput: BigInt;
-  bobInput: BigInt;
-
-  constructor(
-    aliceOutput: BigInt,
-    bobOutput: BigInt,
-    aliceInput: BigInt,
-    bobInput: BigInt
-  ) {
-    this.aliceOutput = aliceOutput;
-    this.bobOutput = bobOutput;
-    this.aliceInput = aliceInput;
-    this.bobInput = bobInput;
-  }
-}
-
+// event AfterClear(address,(uint256,uint256,uint256,uint256))
 export function createAfterClearEvent(
   sender: Address,
-  clearStateChange: AfterClearClearStateChangeStruct
+  aliceOutput: BigInt,
+  bobOutput: BigInt,
+  aliceInput: BigInt,
+  bobInput: BigInt
 ): AfterClear {
   let mockEvent = newMockEvent();
   let afterClearEvent = new AfterClear(
@@ -488,18 +404,10 @@ export function createAfterClearEvent(
     new ethereum.EventParam("sender", ethereum.Value.fromAddress(sender))
   );
   let _clearStateChange = new ethereum.Tuple();
-  _clearStateChange.push(
-    ethereum.Value.fromUnsignedBigInt(clearStateChange.aliceOutput)
-  );
-  _clearStateChange.push(
-    ethereum.Value.fromUnsignedBigInt(clearStateChange.bobOutput)
-  );
-  _clearStateChange.push(
-    ethereum.Value.fromUnsignedBigInt(clearStateChange.aliceInput)
-  );
-  _clearStateChange.push(
-    ethereum.Value.fromUnsignedBigInt(clearStateChange.bobInput)
-  );
+  _clearStateChange.push(ethereum.Value.fromUnsignedBigInt(aliceOutput));
+  _clearStateChange.push(ethereum.Value.fromUnsignedBigInt(bobOutput));
+  _clearStateChange.push(ethereum.Value.fromUnsignedBigInt(aliceInput));
+  _clearStateChange.push(ethereum.Value.fromUnsignedBigInt(bobInput));
   afterClearEvent.parameters.push(
     new ethereum.EventParam(
       "clearStateChange",
diff --git a/subgraph/tests/handlers/handle-afterclear.test.ts b/subgraph/tests/handlers/handle-afterclear.test.ts
new file mode 100644
index 000000000..f6d3e2f9b
--- /dev/null
+++ b/subgraph/tests/handlers/handle-afterclear.test.ts
@@ -0,0 +1,321 @@
+import { makeTradeId } from "../../src/trade";
+import { makeOrderId } from "../../src/order";
+import { Clear } from "../../generated/schema";
+import { vaultEntityId } from "../../src/vault";
+import { eventId } from "../../src/interfaces/event";
+import { createMockERC20Functions } from "../erc20.test";
+import { Bytes, BigInt, Address } from "@graphprotocol/graph-ts";
+import { tradeVaultBalanceChangeId } from "../../src/tradevaultbalancechange";
+import {
+  handleAfterClear,
+  handleClear,
+  getOrdersHash,
+  makeClearBountyId,
+} from "../../src/clear";
+import {
+  IO,
+  Evaluable,
+  createOrder,
+  createClearEvent,
+  createAfterClearEvent,
+} from "../event-mocks.test";
+import {
+  test,
+  assert,
+  clearStore,
+  describe,
+  afterEach,
+  clearInBlockStore,
+} from "matchstick-as";
+
+const alice = Address.fromString("0x850c40aBf6e325231ba2DeD1356d1f2c267e63Ce");
+const bob = Address.fromString("0x813aef302Ebad333EDdef619C6f8eD7FeF51BA7c");
+
+const aliceVaultId = BigInt.fromString("1");
+const bobVaultId = BigInt.fromString("2");
+const aliceBountyVaultId = BigInt.fromString("8");
+const bobBountyVaultId = BigInt.fromString("9");
+
+const token1 = Address.fromString("0x12e605bc104e93B45e1aD99F9e555f659051c2BB");
+const token2 = Address.fromString("0x12e605bc104e93B45e1aD99F9e555f659051c2Bc");
+const token3 = Address.fromString("0x12e605bc104e93B45e1aD99F9e555f659051c2Ba");
+
+describe("Handle AfterClear", () => {
+  afterEach(() => {
+    clearStore();
+    clearInBlockStore();
+  });
+
+  test("handleAfterClear()", () => {
+    createMockERC20Functions(token1);
+    createMockERC20Functions(token2);
+    createMockERC20Functions(token3);
+
+    let aliceOutputAmount = BigInt.fromString("10");
+    let bobOutputAmount = BigInt.fromString("20");
+    let aliceInputAmount = BigInt.fromString("15");
+    let bobInputAmount = BigInt.fromString("10");
+
+    let evaluable = new Evaluable(
+      Address.fromString("0x5fB33D710F8B58DE4c9fDEC703B5c2487a5219d6"),
+      Address.fromString("0x84c6e7F5A1e5dD89594Cc25BEf4722A1b8871aE6"),
+      Bytes.fromHexString("0x1234567890123456789012345678901234567890")
+    );
+    let nonce = Bytes.fromHexString(
+      "0xbce73059f54ada335f7283df99f81d42a3f2d09527eade865627e26cd756b748"
+    );
+
+    let clearEvent = createClearEvent(
+      alice,
+      createOrder(
+        alice,
+        evaluable,
+        [new IO(token1, BigInt.fromString("18"), aliceVaultId)],
+        [new IO(token2, BigInt.fromString("18"), aliceVaultId)],
+        nonce
+      ),
+      createOrder(
+        bob,
+        evaluable,
+        [new IO(token2, BigInt.fromString("18"), bobVaultId)],
+        [
+          new IO(token3, BigInt.fromString("18"), bobVaultId),
+          new IO(token1, BigInt.fromString("18"), bobVaultId),
+        ],
+        nonce
+      ),
+      BigInt.fromString("0"),
+      BigInt.fromString("0"),
+      BigInt.fromString("0"),
+      BigInt.fromString("1"),
+      aliceBountyVaultId,
+      bobBountyVaultId
+    );
+
+    let afterClearEvent = createAfterClearEvent(
+      alice,
+      aliceOutputAmount,
+      bobOutputAmount,
+      aliceInputAmount,
+      bobInputAmount
+    );
+
+    let id = eventId(afterClearEvent).toHexString();
+    let orderHashes = getOrdersHash(clearEvent);
+
+    handleClear(clearEvent);
+    assert.entityCount("ClearTemporaryData", 1);
+    handleAfterClear(afterClearEvent);
+    assert.entityCount("ClearTemporaryData", 0); // should be deleted by now
+
+    // Clear entity
+    assert.entityCount("Clear", 1);
+    assert.fieldEquals("Clear", id, "sender", alice.toHexString()); // sender
+    // alice
+    assert.fieldEquals(
+      "Clear",
+      id,
+      "aliceInputAmount",
+      aliceInputAmount.toString()
+    );
+    assert.fieldEquals(
+      "Clear",
+      id,
+      "aliceOutputAmount",
+      aliceOutputAmount.toString()
+    );
+    assert.fieldEquals(
+      "Clear",
+      id,
+      "aliceBountyAmount",
+      aliceOutputAmount.minus(bobInputAmount).toString()
+    );
+    // bob
+    assert.fieldEquals(
+      "Clear",
+      id,
+      "bobInputAmount",
+      bobInputAmount.toString()
+    );
+    assert.fieldEquals(
+      "Clear",
+      id,
+      "bobOutputAmount",
+      bobOutputAmount.toString()
+    );
+    assert.fieldEquals(
+      "Clear",
+      id,
+      "bobBountyAmount",
+      bobOutputAmount.minus(aliceInputAmount).toString()
+    );
+
+    // bounty
+    let bountyVaultId = vaultEntityId(
+      afterClearEvent.address,
+      afterClearEvent.params.sender,
+      bobBountyVaultId,
+      token1
+    );
+    let clearBountyId = makeClearBountyId(
+      afterClearEvent,
+      bountyVaultId
+    ).toHexString();
+    // Clear entity should only have bob bounty and not alice
+    assert.assertTrue(
+      !Clear.load(Bytes.fromHexString(id))!.aliceBountyVaultBalanceChange
+    );
+    assert.fieldEquals(
+      "Clear",
+      id,
+      "bobBountyVaultBalanceChange",
+      clearBountyId
+    );
+
+    // ClearBounty entity
+    assert.entityCount("ClearBounty", 1); // should only have 1 bounty
+    assert.fieldEquals(
+      "ClearBounty",
+      clearBountyId,
+      "sender",
+      alice.toHexString()
+    );
+    assert.fieldEquals(
+      "ClearBounty",
+      clearBountyId,
+      "amount",
+      bobOutputAmount.minus(aliceInputAmount).toString()
+    );
+    assert.fieldEquals(
+      "ClearBounty",
+      clearBountyId,
+      "newVaultBalance",
+      bobOutputAmount.minus(aliceInputAmount).toString()
+    );
+    assert.fieldEquals(
+      "ClearBounty",
+      clearBountyId,
+      "oldVaultBalance",
+      BigInt.fromString("0").toString()
+    );
+    assert.fieldEquals(
+      "ClearBounty",
+      clearBountyId,
+      "vault",
+      bountyVaultId.toHexString()
+    );
+
+    // trades and trade vault balance changes
+    assert.entityCount("Trade", 2);
+    assert.entityCount("TradeVaultBalanceChange", 4);
+
+    // alice trade and balance change
+    let aliceInputVaultEntityId = vaultEntityId(
+      afterClearEvent.address,
+      alice,
+      aliceVaultId,
+      token1
+    );
+    let aliceOutputVaultEntityId = vaultEntityId(
+      afterClearEvent.address,
+      alice,
+      aliceVaultId,
+      token2
+    );
+    let aliceInputVaultBalanceChangeId = tradeVaultBalanceChangeId(
+      afterClearEvent,
+      aliceInputVaultEntityId
+    ).toHexString();
+    let aliceOutputVaultBalanceChangeId = tradeVaultBalanceChangeId(
+      afterClearEvent,
+      aliceOutputVaultEntityId
+    ).toHexString();
+    let aliceTradeId = makeTradeId(
+      afterClearEvent,
+      orderHashes[0]
+    ).toHexString();
+    assert.fieldEquals(
+      "Trade",
+      aliceTradeId,
+      "order",
+      makeOrderId(afterClearEvent.address, orderHashes[0]).toHexString()
+    );
+    assert.fieldEquals(
+      "Trade",
+      aliceTradeId,
+      "inputVaultBalanceChange",
+      aliceInputVaultBalanceChangeId
+    );
+    assert.fieldEquals(
+      "Trade",
+      aliceTradeId,
+      "outputVaultBalanceChange",
+      aliceOutputVaultBalanceChangeId
+    );
+    assert.fieldEquals(
+      "TradeVaultBalanceChange",
+      aliceInputVaultBalanceChangeId,
+      "amount",
+      aliceInputAmount.toString()
+    );
+    assert.fieldEquals(
+      "TradeVaultBalanceChange",
+      aliceOutputVaultBalanceChangeId,
+      "amount",
+      aliceOutputAmount.neg().toString()
+    );
+
+    // bob trade and balance change
+    let bobInputVaultEntityId = vaultEntityId(
+      afterClearEvent.address,
+      bob,
+      bobVaultId,
+      token2
+    );
+    let bobOutputVaultEntityId = vaultEntityId(
+      afterClearEvent.address,
+      bob,
+      bobVaultId,
+      token1
+    );
+    let bobInputVaultBalanceChangeId = tradeVaultBalanceChangeId(
+      afterClearEvent,
+      bobInputVaultEntityId
+    ).toHexString();
+    let bobOutputVaultBalanceChangeId = tradeVaultBalanceChangeId(
+      afterClearEvent,
+      bobOutputVaultEntityId
+    ).toHexString();
+    let bobTradeId = makeTradeId(afterClearEvent, orderHashes[1]).toHexString();
+    assert.fieldEquals(
+      "Trade",
+      bobTradeId,
+      "order",
+      makeOrderId(afterClearEvent.address, orderHashes[1]).toHexString()
+    );
+    assert.fieldEquals(
+      "Trade",
+      bobTradeId,
+      "inputVaultBalanceChange",
+      bobInputVaultBalanceChangeId
+    );
+    assert.fieldEquals(
+      "Trade",
+      bobTradeId,
+      "outputVaultBalanceChange",
+      bobOutputVaultBalanceChangeId
+    );
+    assert.fieldEquals(
+      "TradeVaultBalanceChange",
+      bobInputVaultBalanceChangeId,
+      "amount",
+      bobInputAmount.toString()
+    );
+    assert.fieldEquals(
+      "TradeVaultBalanceChange",
+      bobOutputVaultBalanceChangeId,
+      "amount",
+      bobOutputAmount.neg().toString()
+    );
+  });
+});
diff --git a/subgraph/tests/handlers/handle-clear.test.ts b/subgraph/tests/handlers/handle-clear.test.ts
index 890714a44..deb924049 100644
--- a/subgraph/tests/handlers/handle-clear.test.ts
+++ b/subgraph/tests/handlers/handle-clear.test.ts
@@ -1,161 +1,173 @@
+import { Bytes, BigInt, Address } from "@graphprotocol/graph-ts";
+import { makeClearEventId, handleClear, getOrdersHash } from "../../src/clear";
+import {
+  IO,
+  Evaluable,
+  createOrder,
+  createClearEvent,
+} from "../event-mocks.test";
 import {
   test,
   assert,
-  clearStore,
   describe,
   afterEach,
+  clearStore,
   clearInBlockStore,
 } from "matchstick-as";
-import { Bytes, BigInt, Address, log } from "@graphprotocol/graph-ts";
-import { makeClearV2Id, handleAfterClear, handleClear } from "../../src/clear";
-import {
-  AfterClearClearStateChangeStruct,
-  ClearV2ClearConfigStruct,
-  ClearV2Struct,
-  createAfterClearEvent,
-  createClearEvent,
-  Evaluable,
-  IO,
-} from "../event-mocks.test";
-import { createMockERC20Functions } from "../erc20.test";
 
-describe("Clear", () => {
+const alice = Address.fromString("0x850c40aBf6e325231ba2DeD1356d1f2c267e63Ce");
+const bob = Address.fromString("0x813aef302Ebad333EDdef619C6f8eD7FeF51BA7c");
+
+const aliceVaultId = BigInt.fromI32(1);
+const bobVaultId = BigInt.fromI32(2);
+const aliceBountyVaultId = BigInt.fromI32(8);
+const bobBountyVaultId = BigInt.fromI32(9);
+
+const token1 = Address.fromString("0x12e605bc104e93B45e1aD99F9e555f659051c2BB");
+const token2 = Address.fromString("0x12e605bc104e93B45e1aD99F9e555f659051c2Bc");
+const token3 = Address.fromString("0x12e605bc104e93B45e1aD99F9e555f659051c2Ba");
+
+describe("Handle Clear", () => {
   afterEach(() => {
     clearStore();
     clearInBlockStore();
   });
 
-  test("clearEvent and afterClearEvent", () => {
+  test("handleClear()", () => {
+    let evaluable = new Evaluable(
+      Address.fromString("0x5fB33D710F8B58DE4c9fDEC703B5c2487a5219d6"),
+      Address.fromString("0x84c6e7F5A1e5dD89594Cc25BEf4722A1b8871aE6"),
+      Bytes.fromHexString("0x1234567890123456789012345678901234567890")
+    );
+    let nonce = Bytes.fromHexString(
+      "0xbce73059f54ada335f7283df99f81d42a3f2d09527eade865627e26cd756b748"
+    );
+
     let event = createClearEvent(
-      Address.fromString("0x850c40aBf6e325231ba2DeD1356d1f2c267e63Ce"),
-      new ClearV2Struct(
-        Address.fromString("0x850c40aBf6e325231ba2DeD1356d1f2c267e63Ce"),
-        new Evaluable(
-          Address.fromString("0x5fB33D710F8B58DE4c9fDEC703B5c2487a5219d6"),
-          Address.fromString("0x84c6e7F5A1e5dD89594Cc25BEf4722A1b8871aE6"),
-          Bytes.fromHexString("0x1234567890123456789012345678901234567890")
-        ),
-        [
-          new IO(
-            Address.fromString("0x12e605bc104e93B45e1aD99F9e555f659051c2BB"),
-            BigInt.fromI32(18),
-            BigInt.fromI32(1)
-          ),
-        ],
-        [
-          new IO(
-            Address.fromString("0x12e605bc104e93B45e1aD99F9e555f659051c2Bc"),
-            BigInt.fromI32(18),
-            BigInt.fromI32(1)
-          ),
-        ],
-        Bytes.fromHexString(
-          "0xbce73059f54ada335f7283df99f81d42a3f2d09527eade865627e26cd756b748"
-        )
+      alice,
+      createOrder(
+        alice,
+        evaluable,
+        [new IO(token1, BigInt.fromI32(18), aliceVaultId)],
+        [new IO(token2, BigInt.fromI32(18), aliceVaultId)],
+        nonce
       ),
-      new ClearV2Struct(
-        Address.fromString("0x813aef302Ebad333EDdef619C6f8eD7FeF51BA7c"),
-        new Evaluable(
-          Address.fromString("0x5fB33D710F8B58DE4c9fDEC703B5c2487a5219d6"),
-          Address.fromString("0x84c6e7F5A1e5dD89594Cc25BEf4722A1b8871aE6"),
-          Bytes.fromHexString("0x1234567890123456789012345678901234567890")
-        ),
+      createOrder(
+        bob,
+        evaluable,
+        [new IO(token2, BigInt.fromI32(18), bobVaultId)],
         [
-          new IO(
-            Address.fromString("0x12e605bc104e93B45e1aD99F9e555f659051c2Bc"),
-            BigInt.fromI32(18),
-            BigInt.fromI32(2)
-          ),
+          new IO(token3, BigInt.fromI32(18), bobVaultId),
+          new IO(token1, BigInt.fromI32(18), bobVaultId),
         ],
-        [
-          new IO(
-            Address.fromString("0x12e605bc104e93B45e1aD99F9e555f659051c2Ba"),
-            BigInt.fromI32(18),
-            BigInt.fromI32(2)
-          ),
-          new IO(
-            Address.fromString("0x12e605bc104e93B45e1aD99F9e555f659051c2BB"),
-            BigInt.fromI32(18),
-            BigInt.fromI32(2)
-          ),
-        ],
-        Bytes.fromHexString(
-          "0x9c8176f8e6e02b5f02eee226ff7066d2474bdc50f89bd15dca539240e0cb1788"
-        )
+        nonce
       ),
-      new ClearV2ClearConfigStruct(
-        BigInt.fromI32(0),
-        BigInt.fromI32(0),
-        BigInt.fromI32(0),
-        BigInt.fromI32(1),
-        BigInt.fromI32(1),
-        BigInt.fromI32(1)
-      )
+      BigInt.fromI32(0),
+      BigInt.fromI32(0),
+      BigInt.fromI32(0),
+      BigInt.fromI32(1),
+      aliceBountyVaultId,
+      bobBountyVaultId
     );
 
-    let aliceInput = event.params.alice.validInputs[0];
-    assert.addressEquals(
-      aliceInput.token,
-      Address.fromString("0x12e605bc104e93B45e1aD99F9e555f659051c2BB")
+    let id = makeClearEventId(event).toHexString();
+    let orderHashes = getOrdersHash(event);
+    handleClear(event);
+
+    assert.entityCount("ClearTemporaryData", 1);
+
+    // alice
+    assert.fieldEquals(
+      "ClearTemporaryData",
+      id,
+      "aliceAddress",
+      alice.toHexString()
     );
-    let aliceOutput = event.params.alice.validOutputs[0];
-    assert.addressEquals(
-      aliceOutput.token,
-      Address.fromString("0x12e605bc104e93B45e1aD99F9e555f659051c2Bc")
+    assert.fieldEquals(
+      "ClearTemporaryData",
+      id,
+      "aliceOrderHash",
+      orderHashes[0].toHexString()
     );
-
-    let bobInput = event.params.bob.validInputs[0];
-    assert.addressEquals(
-      bobInput.token,
-      Address.fromString("0x12e605bc104e93B45e1aD99F9e555f659051c2Bc")
+    assert.fieldEquals(
+      "ClearTemporaryData",
+      id,
+      "aliceInputToken",
+      token1.toHexString()
     );
-    let bobOutput = event.params.bob.validOutputs[1];
-    assert.addressEquals(
-      bobOutput.token,
-      Address.fromString("0x12e605bc104e93B45e1aD99F9e555f659051c2BB")
+    assert.fieldEquals(
+      "ClearTemporaryData",
+      id,
+      "aliceOutputToken",
+      token2.toHexString()
+    );
+    assert.fieldEquals(
+      "ClearTemporaryData",
+      id,
+      "aliceInputVaultId",
+      aliceVaultId.toString()
+    );
+    assert.fieldEquals(
+      "ClearTemporaryData",
+      id,
+      "aliceOutputVaultId",
+      aliceVaultId.toString()
+    );
+    assert.fieldEquals(
+      "ClearTemporaryData",
+      id,
+      "aliceBounty",
+      aliceBountyVaultId.toString()
     );
 
-    let id = makeClearV2Id(event);
-    handleClear(event);
-
-    assert.entityCount("ClearTemporaryData", 1);
+    // bob
     assert.fieldEquals(
       "ClearTemporaryData",
-      id.toHexString(),
-      "aliceAddress",
-      "0x850c40abf6e325231ba2ded1356d1f2c267e63ce"
+      id,
+      "bobAddress",
+      bob.toHexString()
     );
     assert.fieldEquals(
       "ClearTemporaryData",
-      id.toHexString(),
+      id,
       "bobAddress",
-      "0x813aef302ebad333eddef619c6f8ed7fef51ba7c"
+      bob.toHexString()
     );
-
-    createMockERC20Functions(
-      Address.fromString("0x12e605bc104e93B45e1aD99F9e555f659051c2BB")
+    assert.fieldEquals(
+      "ClearTemporaryData",
+      id,
+      "bobOrderHash",
+      orderHashes[1].toHexString()
     );
-    createMockERC20Functions(
-      Address.fromString("0x12e605bc104e93B45e1aD99F9e555f659051c2Bc")
+    assert.fieldEquals(
+      "ClearTemporaryData",
+      id,
+      "bobInputToken",
+      token2.toHexString()
     );
-    createMockERC20Functions(
-      Address.fromString("0x12e605bc104e93B45e1aD99F9e555f659051c2Ba")
+    assert.fieldEquals(
+      "ClearTemporaryData",
+      id,
+      "bobOutputToken",
+      token1.toHexString()
     );
-
-    let afterClearEvent = createAfterClearEvent(
-      Address.fromString("0x850c40aBf6e325231ba2DeD1356d1f2c267e63Ce"),
-      new AfterClearClearStateChangeStruct(
-        BigInt.fromString("10000000000000000000"),
-        BigInt.fromString("12476769284020210880"),
-        BigInt.fromString("11308584431993808000"),
-        BigInt.fromString("10000000000000000000")
-      )
+    assert.fieldEquals(
+      "ClearTemporaryData",
+      id,
+      "bobInputVaultId",
+      bobVaultId.toString()
+    );
+    assert.fieldEquals(
+      "ClearTemporaryData",
+      id,
+      "bobOutputVaultId",
+      bobVaultId.toString()
+    );
+    assert.fieldEquals(
+      "ClearTemporaryData",
+      id,
+      "bobBounty",
+      bobBountyVaultId.toString()
     );
-
-    id = makeClearV2Id(afterClearEvent);
-    handleAfterClear(afterClearEvent);
-
-    assert.entityCount("ClearTemporaryData", 0);
-    assert.entityCount("Trade", 2);
   });
 });