Update AdjudicatorWatcher to watch for ChallengeRegistered event from NitroAdjudicator

packages/wallet/src/redux/actions.ts

@@ -26,6 +26,9 @@ import { FundingStrategyNegotiationAction } from './protocols/funding-strategy-n
 import { LedgerFundingAction } from './protocols/ledger-funding';
 
 import { LOAD as LOAD_FROM_STORAGE } from 'redux-storage';
+import { Address } from 'fmg-core';
+import { FixedPart, VariablePart } from './sagas/adjudicator-watcher';
+import { BigNumber } from 'ethers/utils';
 export * from './protocols/transaction-submission/actions';
 export { CommitmentReceived, commitmentReceived };
 
@@ -78,11 +81,14 @@ export interface ChallengeExpirySetEvent {
   expiryTime;
 }
 
-export interface ChallengeCreatedEvent {
-  type: 'WALLET.ADJUDICATOR.CHALLENGE_CREATED_EVENT';
+export interface ChallengeRegisteredEvent {
+  type: 'WALLET.ADJUDICATOR.CHALLENGE_REGISTERED_EVENT';
   channelId: string;
-  commitment: Commitment;
-  finalizedAt: number;
+  finalizesAt: BigNumber;
+  challenger: Address;
+  isFinalCount: boolean;
+  fixedPart: FixedPart;
+  variableParts: VariablePart;
 }
 
 export interface ConcludedEvent {
@@ -168,9 +174,9 @@ export const challengeExpirySetEvent: ActionConstructor<ChallengeExpirySetEvent>
   type: 'WALLET.ADJUDICATOR.CHALLENGE_EXPIRY_TIME_SET',
 });
 
-export const challengeCreatedEvent: ActionConstructor<ChallengeCreatedEvent> = p => ({
+export const challengeRegisteredEvent: ActionConstructor<ChallengeRegisteredEvent> = p => ({
   ...p,
-  type: 'WALLET.ADJUDICATOR.CHALLENGE_CREATED_EVENT',
+  type: 'WALLET.ADJUDICATOR.CHALLENGE_REGISTERED_EVENT',
 });
 
 export const concludedEvent: ActionConstructor<ConcludedEvent> = p => ({

packages/wallet/src/redux/adjudicator-state/state.ts

@@ -1,4 +1,7 @@
+import { AddressZero } from 'ethers/constants';
+
 import { Commitment } from '../../domain';
+import { Address } from 'fmg-core';
 
 export interface AdjudicatorState {
   [channelId: string]: AdjudicatorChannelState;
@@ -8,6 +11,9 @@ export interface AdjudicatorChannelState {
   balance: string;
   finalized: boolean;
   challenge?: Challenge;
+  finalizedAt: string;
+  outcomeBytes: string;
+  challengerAddress: Address;
 }
 export interface Challenge {
   expiresAt: number;
@@ -20,7 +26,14 @@ function getOrCreateAdjudicatorChannelState(
 ): AdjudicatorChannelState {
   let channelState = getAdjudicatorChannelState(adjudicatorState, channelId);
   if (!channelState) {
-    channelState = { channelId, balance: '0x0', finalized: false };
+    channelState = {
+      channelId,
+      balance: '0x0',
+      finalized: false,
+      finalizedAt: '0',
+      outcomeBytes: '',
+      challengerAddress: AddressZero,
+    };
   }
   return channelState;
 }

packages/wallet/src/redux/sagas/adjudicator-watcher.ts

@@ -1,4 +1,4 @@
-import { getAdjudicatorContract } from '../../utils/contract-utils';
+import { getNitroAdjudicatorContract } from '../../utils/contract-utils';
 import { call, take, put, select } from 'redux-saga/effects';
 import { eventChannel } from 'redux-saga';
 import * as actions from '../actions';
@@ -7,9 +7,11 @@ import { fromParameters } from 'fmg-core/lib/commitment';
 import { getAdjudicatorWatcherSubscribersForChannel } from '../selectors';
 import { ChannelSubscriber } from '../state';
 import { ProtocolLocator } from '../../communication';
+import { BigNumber } from 'ethers/utils';
+import { Address } from 'fmg-core';
 
 enum AdjudicatorEventType {
-  ChallengeCreated,
+  ChallengeRegistered,
   Concluded,
   Refuted,
   RespondWithMove,
@@ -22,6 +24,29 @@ interface AdjudicatorEvent {
   eventType: AdjudicatorEventType;
 }
 
+export interface FixedPart {
+  chainId: BigNumber;
+  participants: Address[];
+  channelNonce: BigNumber;
+  appDefinition: Address;
+  challengeDuration: BigNumber;
+}
+
+export interface VariablePart {
+  outcome: string;
+  appData: string;
+}
+
+interface ChallengeRegisteredArgs {
+  channelId: string;
+  largestTurnNum: number;
+  finalizesAt: BigNumber;
+  challenger: Address;
+  isFinalCount: boolean;
+  fixedPart: FixedPart;
+  variablePart: VariablePart;
+}
+
 export function* adjudicatorWatcher(provider) {
   const adjudicatorEventChannel = yield call(createAdjudicatorEventChannel, provider);
   while (true) {
@@ -41,15 +66,18 @@ export function* adjudicatorWatcher(provider) {
 
 function* dispatchEventAction(event: AdjudicatorEvent) {
   switch (event.eventType) {
-    case AdjudicatorEventType.ChallengeCreated:
+    case AdjudicatorEventType.ChallengeRegistered:
       const { channelId } = event;
-      const { commitment, finalizedAt } = event.eventArgs;
-      const altFinalizedAt = finalizedAt * 1000;
+      const args: ChallengeRegisteredArgs = event.eventArgs;
+      const altFinalizedAt = args.finalizesAt.mul(1000);
       yield put(
-        actions.challengeCreatedEvent({
+        actions.challengeRegisteredEvent({
           channelId,
-          commitment: fromParameters(commitment),
-          finalizedAt: altFinalizedAt,
+          finalizesAt: altFinalizedAt,
+          challenger: args.challenger,
+          isFinalCount: args.isFinalCount,
+          fixedPart: args.fixedPart,
+          variableParts: args.variablePart,
         }),
       );
       break;
@@ -63,14 +91,14 @@ function* dispatchProcessEventAction(
 ) {
   const { channelId } = event;
   switch (event.eventType) {
-    case AdjudicatorEventType.ChallengeCreated:
+    case AdjudicatorEventType.ChallengeRegistered:
       const { finalizedAt } = event.eventArgs;
       yield put(
         actions.challengeExpirySetEvent({
           processId,
           protocolLocator,
           channelId,
-          expiryTime: finalizedAt * 1000,
+          expiryTime: finalizedAt.mul(1000),
         }),
       );
       break;
@@ -120,22 +148,40 @@ function* dispatchProcessEventAction(
 }
 
 function* createAdjudicatorEventChannel(provider) {
-  const adjudicator: ethers.Contract = yield call(getAdjudicatorContract, provider);
+  const adjudicator: ethers.Contract = yield call(getNitroAdjudicatorContract, provider);
 
   return eventChannel(emitter => {
-    const challengeCreatedFilter = adjudicator.filters.ChallengeCreated();
+    const challengeRegisteredFilter = adjudicator.filters.ChallengeRegistered();
     const gameConcludedFilter = adjudicator.filters.Concluded();
     const refutedFilter = adjudicator.filters.Refuted();
     const respondWithMoveFilter = adjudicator.filters.RespondedWithMove();
     const depositedFilter = adjudicator.filters.Deposited();
 
-    adjudicator.on(challengeCreatedFilter, (channelId, commitment, finalizedAt) => {
-      emitter({
-        eventType: AdjudicatorEventType.ChallengeCreated,
+    adjudicator.on(
+      challengeRegisteredFilter,
+      (
         channelId,
-        eventArgs: { commitment, finalizedAt },
-      });
-    });
+        largestTurnNum,
+        challengeDuration,
+        challenger,
+        isFinalCount,
+        fixedPart,
+        variablePart,
+      ) => {
+        emitter({
+          eventType: AdjudicatorEventType.ChallengeRegistered,
+          channelId,
+          eventArgs: {
+            largestTurnNum,
+            challengeDuration,
+            challenger,
+            isFinalCount,
+            fixedPart,
+            variablePart,
+          },
+        });
+      },
+    );
     adjudicator.on(gameConcludedFilter, channelId => {
       emitter({ eventType: AdjudicatorEventType.Concluded, channelId });
     });
@@ -158,7 +204,7 @@ function* createAdjudicatorEventChannel(provider) {
     });
     return () => {
       // This function is called when the channel gets closed
-      adjudicator.removeAllListeners(challengeCreatedFilter);
+      adjudicator.removeAllListeners(challengeRegisteredFilter);
       adjudicator.removeAllListeners(gameConcludedFilter);
       adjudicator.removeAllListeners(refutedFilter);
       adjudicator.removeAllListeners(respondWithMoveFilter);

packages/wallet/src/utils/contract-utils.ts

@@ -9,7 +9,7 @@ export async function getProvider(): Promise<ethers.providers.Web3Provider> {
   return await new ethers.providers.Web3Provider(web3.currentProvider);
 }
 
-export async function getAdjudicatorContract(provider) {
+export async function getNitroAdjudicatorContract(provider) {
   await provider.ready;
   const networkId = (await provider.getNetwork()).chainId;
   const contractAddress = NitroAdjudicatorArtifact.networks[networkId].address;
@@ -56,13 +56,13 @@ export function isDevelopmentNetwork(): boolean {
 }
 
 export async function getAdjudicatorHoldings(provider, channelId) {
-  const contract = await getAdjudicatorContract(provider);
+  const contract = await getNitroAdjudicatorContract(provider);
   const holdingForChannel = await contract.holdings(channelId);
   return holdingForChannel;
 }
 
 export async function getAdjudicatorOutcome(provider, channelId) {
-  const contract = await getAdjudicatorContract(provider);
+  const contract = await getNitroAdjudicatorContract(provider);
   const outcomeForChannel = await contract.outcomes(channelId);
   return outcomeForChannel;
 }
@@ -72,7 +72,7 @@ export async function validateTransition(
   toCommitment: Commitment,
 ): Promise<boolean> {
   const provider = await getProvider();
-  const contract = await getAdjudicatorContract(provider);
+  const contract = await getNitroAdjudicatorContract(provider);
   try {
     return await contract.validTransition(
       asEthersObject(fromCommitment),