Add channelId argument to AssetTransferred event

packages/nitro-protocol/contracts/AssetHolder.sol

@@ -96,7 +96,7 @@ contract AssetHolder is IAssetHolder {
             }
             if (_isExternalDestination(allocation[m].destination)) {
                 _transferAsset(_bytes32ToAddress(allocation[m].destination), payoutAmount);
-                emit AssetTransferred(allocation[m].destination, payoutAmount);
+                emit AssetTransferred(channelId, allocation[m].destination, payoutAmount);
             } else {
                 holdings[allocation[m].destination] += payoutAmount;
             }
@@ -263,7 +263,7 @@ contract AssetHolder is IAssetHolder {
             if (payouts[j] > 0) {
                 if (_isExternalDestination(allocation[j].destination)) {
                     _transferAsset(_bytes32ToAddress(allocation[j].destination), payouts[j]);
-                    emit AssetTransferred(allocation[j].destination, payouts[j]);
+                    emit AssetTransferred(guarantorChannelId, allocation[j].destination, payouts[j]);
                 } else {
                     holdings[allocation[j].destination] += payouts[j];
                 }

packages/nitro-protocol/contracts/interfaces/IAssetHolder.sol

@@ -40,9 +40,10 @@ interface IAssetHolder {
 
     /**
     * @dev Indicates that `amount` assets have been transferred to the external destination denoted by `destination`.
+    * @param channelId The channelId of the funds being withdrawn.
     * @param destination An external destination, left-padded with zeros.
     * @param amount Number of assets transferred (wei or tokens).
     */
-    event AssetTransferred(bytes32 indexed destination, uint256 amount);
+    event AssetTransferred(bytes32 indexed channelId, bytes32 indexed destination, uint256 amount);
 
 }

packages/nitro-protocol/src/contract/asset-holder.ts

@@ -1,4 +1,5 @@
 import {BigNumber, bigNumberify, getAddress} from 'ethers/utils';
+import {parseEventResult} from '../ethers-utils';
 
 export interface DepositedEvent {
   destination: string;
@@ -7,32 +8,24 @@ export interface DepositedEvent {
 }
 
 export interface AssetTransferredEvent {
+  channelId: string;
   destination: string;
   amount: BigNumber;
 }
 
-export function getDepositedEvent({eventArgs}): DepositedEvent {
-  const [
-    {
-      args: {destination, amountDeposited, destinationHoldings},
-    },
-  ] = eventArgs.slice(-1);
-
+export function getDepositedEvent(eventResult: any[]): DepositedEvent {
+  const {destination, amountDeposited, destinationHoldings} = parseEventResult(eventResult);
   return {
     destination,
     amountDeposited: bigNumberify(amountDeposited),
     destinationHoldings: bigNumberify(destinationHoldings),
   };
 }
 
-export function getAssetTransferredEvent({eventArgs}): AssetTransferredEvent {
-  const [
-    {
-      args: {destination, amount},
-    },
-  ] = eventArgs.slice(-1);
-
+export function getAssetTransferredEvent(eventResult: any[]): AssetTransferredEvent {
+  const {channelId, destination, amount} = parseEventResult(eventResult);
   return {
+    channelId,
     destination,
     amount: bigNumberify(amount),
   };

packages/nitro-protocol/src/ethers-utils.ts

@@ -0,0 +1,5 @@
+// The last value in a result from an ethers event emission (i.e., Contract.on(<filter>, <result>))
+// is an object with keys as the names of the fields emitted by the event.
+export function parseEventResult(result: any[]): {[fieldName: string]: any} {
+  return result.slice(-1)[0].args;
+}

packages/nitro-protocol/test/contracts/AssetHolder/claimAll.test.ts

@@ -146,7 +146,11 @@ describe('claimAll', () => {
 
         // Add AssetTransferred events to expectations
         Object.keys(payouts).forEach(assetHolder => {
-          expectedEvents = assetTransferredEventsFromPayouts(payouts, AssetHolder.address);
+          expectedEvents = assetTransferredEventsFromPayouts(
+            guarantorId,
+            payouts,
+            AssetHolder.address
+          );
         });
 
         // Extract logs

packages/nitro-protocol/test/contracts/AssetHolder/transferAll.test.ts

@@ -102,7 +102,7 @@ describe('transferAll', () => {
           if (payouts[destination] && payouts[destination].gt(0)) {
             expectedEvents.push({
               event: 'AssetTransferred',
-              args: {destination, amount: payouts[destination]},
+              args: {channelId, destination, amount: payouts[destination]},
             });
           }
         });

packages/nitro-protocol/test/contracts/NitroAdjudicator/concludePushOutcomeAndTransferAll.test.ts

@@ -194,7 +194,7 @@ describe('concludePushOutcomeAndTransferAll', () => {
         // Add AssetTransferred events to expectations
         Object.keys(payouts).forEach(assetHolder => {
           expectedEvents = expectedEvents.concat(
-            assetTransferredEventsFromPayouts(payouts[assetHolder], assetHolder)
+            assetTransferredEventsFromPayouts(channelId, payouts[assetHolder], assetHolder)
           );
         });
 

packages/nitro-protocol/test/contracts/NitroAdjudicator/pushOutcomeAndTransferAll.test.ts

@@ -177,7 +177,7 @@ describe('pushOutcomeAndTransferAll', () => {
         // Add AssetTransferred events to expectations
         Object.keys(payouts).forEach(assetHolder => {
           expectedEvents = expectedEvents.concat(
-            assetTransferredEventsFromPayouts(payouts[assetHolder], assetHolder)
+            assetTransferredEventsFromPayouts(channelId, payouts[assetHolder], assetHolder)
           );
         });
 

packages/nitro-protocol/test/test-helpers.ts

@@ -346,6 +346,7 @@ export function computeOutcome(outcomeShortHand: OutcomeShortHand): AllocationAs
 }
 
 export function assetTransferredEventsFromPayouts(
+  channelId: string,
   singleAssetPayouts: AssetOutcomeShortHand,
   assetHolder: string
 ) {
@@ -355,7 +356,7 @@ export function assetTransferredEventsFromPayouts(
       assetTransferredEvents.push({
         contract: assetHolder,
         name: 'AssetTransferred',
-        values: {destination, amount: singleAssetPayouts[destination]},
+        values: {channelId, destination, amount: singleAssetPayouts[destination]},
       });
     }
   });

packages/wallet/src/contract-tests/eth-asset-holder-events.test.ts

@@ -8,7 +8,7 @@ import {
 import SagaTester from "redux-saga-tester";
 import {DepositedEvent} from "../redux/actions";
 import {adjudicatorWatcher} from "../redux/sagas/adjudicator-watcher";
-import {ETHAssetHolderWatcher} from "../redux/sagas/asset-holder-watcher";
+import {assetHoldersWatcher} from "../redux/sagas/asset-holder-watcher";
 import {depositIntoETHAssetHolder, createWatcherState, concludeGame, fiveFive} from "./test-utils";
 import {getGanacheProvider} from "@statechannels/devtools";
 import {bigNumberify} from "ethers/utils";
@@ -46,7 +46,7 @@ describe("ETHAssetHolder listener", () => {
     const processId = ethers.Wallet.createRandom().address;
 
     const sagaTester = new SagaTester({initialState: createWatcherState(processId, channelId)});
-    sagaTester.start(ETHAssetHolderWatcher, provider);
+    sagaTester.start(assetHoldersWatcher, provider);
 
     const depositAmount = bigNumberify("0x05");
     await depositIntoETHAssetHolder(provider, channelId, depositAmount.toHexString());
@@ -108,7 +108,7 @@ describe("ETHAssetHolder listener", () => {
     const allocation = getAllocationOutcome(outcome).allocation;
     const processId = ethers.Wallet.createRandom().address;
     const sagaTester = new SagaTester({initialState: createWatcherState(processId, channelId)});
-    sagaTester.start(ETHAssetHolderWatcher, provider);
+    sagaTester.start(assetHoldersWatcher, provider);
 
     await transferAll(channelId, encodeAllocation(allocation), provider);
 

packages/wallet/src/redux/actions.ts

@@ -56,9 +56,12 @@ export interface DisplayMessageSent {
 
 export interface AssetTransferredEvent {
   type: "WALLET.ASSET_HOLDER.ASSET_TRANSFERRED";
+  assetHolderAddress: string;
+  channelId: string;
 
   // This is either a `channelId` or an external destination (both bytes32).
   destination: string;
+
   amount: BigNumber;
 }
 

packages/wallet/src/redux/asset-holders-state/reducer.ts

@@ -1,26 +1,34 @@
-import {AssetHoldersState, recordDeposit} from "./state";
-import * as actions from "../actions";
+import {AssetHolderEventAction, DepositedEvent, AssetTransferredEvent} from "../actions";
 import {unreachable} from "../../utils/reducer-utils";
 
+import {AssetHoldersState, recordDeposit, recordAssetTransfer} from "./state";
+
 export const assetHolderStateReducer = (
   state: AssetHoldersState,
-  action: actions.AssetHolderEventAction
+  action: AssetHolderEventAction
 ): AssetHoldersState => {
   switch (action.type) {
     case "WALLET.ASSET_HOLDER.ASSET_TRANSFERRED":
-      throw Error("cant handle this");
+      return assetTransferredReducer(state, action);
     case "WALLET.ASSET_HOLDER.DEPOSITED":
       return depositedReducer(state, action);
     default:
       return unreachable(action);
   }
 };
 
-const depositedReducer = (state: AssetHoldersState, action: actions.DepositedEvent) => {
+const depositedReducer = (state: AssetHoldersState, action: DepositedEvent) => {
   return recordDeposit(
     state,
     action.assetHolderAddress,
     action.destination,
     action.destinationHoldings
   );
 };
+
+const assetTransferredReducer = (
+  state: AssetHoldersState,
+  {assetHolderAddress, channelId, destination, amount}: AssetTransferredEvent
+) => {
+  return recordAssetTransfer(state, assetHolderAddress, channelId, destination, amount);
+};

packages/wallet/src/redux/asset-holders-state/state.ts

@@ -1,5 +1,5 @@
 import {Zero} from "ethers/constants";
-import {BigNumber} from "ethers/utils";
+import {BigNumber, bigNumberify} from "ethers/utils";
 import {Uint256} from "@statechannels/nitro-protocol/src/contract/types";
 
 export interface AssetHoldersState {
@@ -82,3 +82,29 @@ export function recordDeposit(
     newAssetHolderChannelState
   );
 }
+
+export function recordAssetTransfer(
+  assetHoldersState: AssetHoldersState,
+  assetHolderAddress: string,
+  channelId: string,
+  // @ts-ignore
+  destination: string, // TODO: Should we take this into account?
+  amount: BigNumber
+): AssetHoldersState {
+  const assetHolderChannelState = getOrCreateAssetHolderChannelState(
+    assetHoldersState,
+    assetHolderAddress,
+    channelId
+  );
+  const newAssetHolderChannelState = {
+    ...assetHolderChannelState,
+    holdings: bigNumberify(assetHolderChannelState.holdings)
+      .sub(amount)
+      .toHexString()
+  };
+  return setAssetHolderChannelState(
+    assetHoldersState,
+    assetHolderAddress,
+    newAssetHolderChannelState
+  );
+}

packages/wallet/src/redux/sagas/asset-holder-watcher.ts

@@ -17,37 +17,46 @@ enum AssetHolderEventType {
 
 interface AssetHolderEvent {
   assetHolderAddress: string;
-  eventArgs: any;
+  eventResult: any[];
   eventType: AssetHolderEventType;
 }
 
-export function* ETHAssetHolderWatcher(provider: Web3Provider) {
-  const ETHAssetHolderEventChannel = yield call(createAssetHolderEventChannel, provider);
+export function* assetHoldersWatcher(provider: Web3Provider) {
+  const assetHolderEventChannel = yield call(createAssetHolderEventChannel, provider);
   while (true) {
-    const event: AssetHolderEvent = yield take(ETHAssetHolderEventChannel);
-    if (event.eventType === AssetHolderEventType.Deposited) {
-      const channelSubscribers: ChannelSubscriber[] = yield select(
-        getAssetHolderWatcherSubscribersForChannel,
-        getDepositedEvent(event).destination
-      );
-      for (const subscriber of channelSubscribers) {
-        yield dispatchProcessEventAction(event, subscriber.processId, subscriber.protocolLocator);
-      }
+    const event: AssetHolderEvent = yield take(assetHolderEventChannel);
+    const {eventType, eventResult} = event;
+
+    let channelId: string;
+
+    if (eventType === AssetHolderEventType.Deposited) {
+      channelId = getDepositedEvent(eventResult).destination;
+    } else if (eventType === AssetHolderEventType.AssetTransferred) {
+      channelId = getAssetTransferredEvent(eventResult).channelId;
+    } else {
+      continue;
+    }
+
+    const channelSubscribers: ChannelSubscriber[] = yield select(
+      getAssetHolderWatcherSubscribersForChannel,
+      channelId
+    );
+
+    for (const {processId, protocolLocator} of channelSubscribers) {
+      yield dispatchProcessEventAction(event, processId, protocolLocator);
     }
+
     yield dispatchEventAction(event);
   }
 }
 
-function* dispatchEventAction(event: AssetHolderEvent) {
-  const {eventType} = event;
+function* dispatchEventAction({eventResult, assetHolderAddress, eventType}: AssetHolderEvent) {
   switch (eventType) {
     case AssetHolderEventType.AssetTransferred:
-      // FIXME: We need some new kind of technique for dealing with AssetTransferred situations
-      const assetTransferredEvent = getAssetTransferredEvent(event);
       yield put(
         actions.assetTransferredEvent({
-          destination: assetTransferredEvent.destination,
-          amount: assetTransferredEvent.amount
+          assetHolderAddress,
+          ...getAssetTransferredEvent(eventResult)
         })
       );
       break;
@@ -63,29 +72,20 @@ function* dispatchEventAction(event: AssetHolderEvent) {
 }
 
 function* dispatchProcessEventAction(
-  event: AssetHolderEvent,
+  {eventResult, assetHolderAddress, eventType}: AssetHolderEvent,
   processId: string,
   protocolLocator: ProtocolLocator
 ) {
-  const {eventType, assetHolderAddress} = event;
   switch (eventType) {
     case AssetHolderEventType.AssetTransferred:
-      yield put(
-        actions.assetTransferredEvent({
-          ...getAssetTransferredEvent(event)
-        })
-      );
       break;
     case AssetHolderEventType.Deposited:
-      const {destination, amountDeposited, destinationHoldings} = getDepositedEvent(event);
       yield put(
         actions.depositedEvent({
           processId,
           protocolLocator,
           assetHolderAddress,
-          destination,
-          amountDeposited,
-          destinationHoldings
+          ...getDepositedEvent(eventResult)
         })
       );
       break;
@@ -108,35 +108,35 @@ function* createAssetHolderEventChannel(provider: Web3Provider) {
     const erc20AssetTransferredFilter = ERC20AssetHolder.filters.AssetTransferred();
     const erc20DepositedFilter = ERC20AssetHolder.filters.Deposited();
 
-    ETHAssetHolder.on(ethAssetTransferredFilter, (...eventArgs) =>
+    ETHAssetHolder.on(ethAssetTransferredFilter, (...eventResult) =>
       emitter({
         assetHolderAddress: ETHAssetHolder.address,
         eventType: AssetHolderEventType.AssetTransferred,
-        eventArgs
+        eventResult
       })
     );
 
-    ETHAssetHolder.on(ethDepositedFilter, (...eventArgs) =>
+    ETHAssetHolder.on(ethDepositedFilter, (...eventResult) =>
       emitter({
         assetHolderAddress: ETHAssetHolder.address,
         eventType: AssetHolderEventType.Deposited,
-        eventArgs
+        eventResult
       })
     );
 
-    ERC20AssetHolder.on(erc20AssetTransferredFilter, (...eventArgs) =>
+    ERC20AssetHolder.on(erc20AssetTransferredFilter, (...eventResult) =>
       emitter({
         assetHolderAddress: ERC20AssetHolder.address,
         eventType: AssetHolderEventType.AssetTransferred,
-        eventArgs
+        eventResult
       })
     );
 
-    ERC20AssetHolder.on(erc20DepositedFilter, (...eventArgs) =>
+    ERC20AssetHolder.on(erc20DepositedFilter, (...eventResult) =>
       emitter({
         assetHolderAddress: ERC20AssetHolder.address,
         eventType: AssetHolderEventType.Deposited,
-        eventArgs
+        eventResult
       })
     );