39 cooperative cancel

modules/cf-core/src/models/app-instance.ts

@@ -293,12 +293,55 @@ export class AppInstance {
     return this.computeOutcome(this.state, provider, bytecode);
   }
 
+  public async computeTurnTaker(
+    provider: providers.JsonRpcProvider,
+    bytecode?: HexString,
+  ): Promise<string> {
+    let turnTaker: undefined | string = undefined;
+    // attempt evm if available
+    if (bytecode) {
+      try {
+        const functionData = appInterface.encodeFunctionData("getTurnTaker", [
+          this.encodedLatestState,
+          this.participants,
+        ]);
+        const output = await execEvmBytecode(bytecode, functionData);
+        turnTaker = appInterface.decodeFunctionResult("getTurnTaker", output)[0];
+      } catch (e) {}
+    }
+    if (turnTaker) {
+      return turnTaker;
+    }
+    // otherwise, if err or if no bytecode, execute read fn
+    turnTaker = (await this.toEthersContract(provider).getTurnTaker(
+      this.encodedLatestState,
+      this.participants,
+    )) as string;
+    return turnTaker;
+  }
+
+  public async isCorrectTurnTaker(
+    attemptedTurnTaker: string,
+    provider: providers.JsonRpcProvider,
+    bytecode?: HexString,
+  ) {
+    const turnTaker = await this.computeTurnTaker(provider, bytecode);
+    return attemptedTurnTaker === turnTaker;
+  }
+
   public async computeStateTransition(
+    actionTaker: Address,
     action: SolidityValueType,
     provider: providers.JsonRpcProvider,
     bytecode?: HexString,
   ): Promise<SolidityValueType> {
     let computedNextState: SolidityValueType;
+    const turnTaker = await this.computeTurnTaker(provider, bytecode);
+    if (actionTaker !== turnTaker) {
+      throw new Error(
+        `Cannot compute state transition, got invalid turn taker for action on app at ${this.appDefinition}. Expected ${turnTaker}, got ${actionTaker}`,
+      );
+    }
     if (bytecode) {
       try {
         const functionData = appInterface.encodeFunctionData("applyAction", [

modules/cf-core/src/protocol/sync.ts

@@ -11,7 +11,7 @@ import {
   AppInstanceJson,
 } from "@connext/types";
 import { Context, ProtocolExecutionFlow, PersistStateChannelType } from "../types";
-import { stringify, logTime, toBN } from "@connext/utils";
+import { stringify, logTime, toBN, getSignerAddressFromPublicIdentifier } from "@connext/utils";
 import { stateChannelClassFromStoreByMultisig, getPureBytecode } from "./utils";
 import { StateChannel, AppInstance, FreeBalanceClass } from "../models";
 import {
@@ -182,6 +182,7 @@ export const SYNC_PROTOCOL: ProtocolExecutionFlow = {
         postSyncStateChannel = postSyncStateChannel.setState(
           app,
           await app.computeStateTransition(
+            getSignerAddressFromPublicIdentifier(initiatorIdentifier),
             affectedApp!.latestAction,
             provider,
             getPureBytecode(app.appDefinition, contractAddresses),
@@ -391,6 +392,7 @@ export const SYNC_PROTOCOL: ProtocolExecutionFlow = {
         postSyncStateChannel = postSyncStateChannel.setState(
           app,
           await app.computeStateTransition(
+            getSignerAddressFromPublicIdentifier(initiatorIdentifier),
             affectedApp!.latestAction,
             provider,
             getPureBytecode(app.appDefinition, contractAddresses),

modules/cf-core/src/protocol/take-action.ts

@@ -38,6 +38,7 @@ export const TAKE_ACTION_PROTOCOL: ProtocolExecutionFlow = {
       responderIdentifier,
       action,
       stateTimeout,
+      initiatorIdentifier,
     } = params as ProtocolParams.TakeAction;
 
     if (!preProtocolStateChannel) {
@@ -67,12 +68,10 @@ export const TAKE_ACTION_PROTOCOL: ProtocolExecutionFlow = {
     const postProtocolStateChannel = preProtocolStateChannel.setState(
       preAppInstance,
       await preAppInstance.computeStateTransition(
+        getSignerAddressFromPublicIdentifier(initiatorIdentifier),
         action,
         network.provider,
-        getPureBytecode(
-          preAppInstance.appDefinition,
-          network.contractAddresses,
-        ),
+        getPureBytecode(preAppInstance.appDefinition, network.contractAddresses),
       ),
       stateTimeout,
     );
@@ -200,12 +199,10 @@ export const TAKE_ACTION_PROTOCOL: ProtocolExecutionFlow = {
     const postProtocolStateChannel = preProtocolStateChannel.setState(
       preAppInstance,
       await preAppInstance.computeStateTransition(
+        getSignerAddressFromPublicIdentifier(initiatorIdentifier),
         action,
         network.provider,
-        getPureBytecode(
-          preAppInstance.appDefinition,
-          network.contractAddresses,
-        ),
+        getPureBytecode(preAppInstance.appDefinition, network.contractAddresses),
       ),
       stateTimeout,
     );

modules/cf-core/src/protocol/uninstall.ts

@@ -42,6 +42,7 @@ export const UNINSTALL_PROTOCOL: ProtocolExecutionFlow = {
       appIdentityHash,
       action,
       stateTimeout,
+      initiatorIdentifier,
     } = params as ProtocolParams.Uninstall;
 
     if (!preProtocolStateChannel) {
@@ -70,6 +71,7 @@ export const UNINSTALL_PROTOCOL: ProtocolExecutionFlow = {
       // apply action
       substart = Date.now();
       const newState = await appToUninstall.computeStateTransition(
+        getSignerAddressFromPublicIdentifier(initiatorIdentifier),
         action,
         network.provider,
         getPureBytecode(appToUninstall.appDefinition, network.contractAddresses),
@@ -205,6 +207,7 @@ export const UNINSTALL_PROTOCOL: ProtocolExecutionFlow = {
       // apply action
       substart = Date.now();
       const newState = await appToUninstall.computeStateTransition(
+        getSignerAddressFromPublicIdentifier(initiatorIdentifier),
         action,
         network.provider,
         getPureBytecode(appToUninstall.appDefinition, network.contractAddresses),

modules/cf-core/src/testing/scenarios/cant-take-action.spec.ts

@@ -1,5 +1,4 @@
 import { CFCore } from "../../cfCore";
-import { INVALID_ACTION } from "../../errors";
 
 import { TestContractAddresses } from "../contracts";
 import { constructTakeActionRpc, createChannel, installApp } from "../utils";
@@ -35,7 +34,7 @@ describe("Node method follows spec - fails with improper action taken", () => {
       const takeActionReq = constructTakeActionRpc(appIdentityHash, multisigAddress, validAction);
 
       await expect(nodeA.rpcRouter.dispatch(takeActionReq)).to.eventually.be.rejectedWith(
-        INVALID_ACTION,
+        "Cannot compute state transition",
       );
     });
   });

modules/cf-core/src/testing/scenarios/take-action-concurrent.spec.ts

@@ -76,15 +76,15 @@ describe("Node method follows spec - toke action", () => {
 
         let appsTakenActionOn = 0;
 
-        nodeB.on(EventNames.UPDATE_STATE_EVENT, () => {
+        nodeA.on(EventNames.UPDATE_STATE_EVENT, () => {
           appsTakenActionOn += 1;
           if (appsTakenActionOn === 2) done();
         });
 
-        nodeA.rpcRouter.dispatch(
+        nodeB.rpcRouter.dispatch(
           constructTakeActionRpc(appIdentityHashes[0], multisigAddress, validAction),
         );
-        nodeA.rpcRouter.dispatch(
+        nodeB.rpcRouter.dispatch(
           constructTakeActionRpc(appIdentityHashes[1], multisigAddress, validAction),
         );
       });

modules/cf-core/src/testing/scenarios/take-action.spec.ts

@@ -122,7 +122,7 @@ describe("Node method follows spec - takeAction", () => {
             result: {
               result: { newState },
             },
-          } = await nodeA.rpcRouter.dispatch(takeActionReq);
+          } = await nodeB.rpcRouter.dispatch(takeActionReq);
           // allow nodeA to confirm its messages
           await new Promise((resolve) => {
             nodeA.once(EventNames.UPDATE_STATE_EVENT, () => {

modules/cf-core/src/testing/scenarios/uninstall-with-action.spec.ts

@@ -9,6 +9,7 @@ import {
   SimpleLinkedTransferAppName,
   AppActions,
 } from "@connext/types";
+import { getRandomBytes32, getSignerAddressFromPublicIdentifier } from "@connext/utils";
 import { constants, utils } from "ethers";
 
 import { CFCore } from "../../cfCore";
@@ -26,7 +27,6 @@ import {
   getAppInstance,
 } from "../utils";
 import { AppInstance } from "../../models";
-import { getRandomBytes32 } from "@connext/utils";
 import { expect } from "../assertions";
 
 const { One, Two, Zero, HashZero } = constants;
@@ -100,18 +100,25 @@ describe("Node A and B install an app, then uninstall with a given action", () =
     );
     const appPreUninstall = AppInstance.fromJson(await getAppInstance(nodeA, appIdentityHash));
     const expected = appPreUninstall
-      .setState(await appPreUninstall.computeStateTransition(action, provider), Zero)
+      .setState(
+        await appPreUninstall.computeStateTransition(
+          getSignerAddressFromPublicIdentifier(nodeB.publicIdentifier),
+          action,
+          provider,
+        ),
+        Zero,
+      )
       .toJson();
 
     await Promise.all([
       new Promise(async (resolve, reject) => {
-        nodeB.on(EventNames.UNINSTALL_EVENT, async (msg) => {
+        nodeA.on(EventNames.UNINSTALL_EVENT, async (msg) => {
           if (msg.data.appIdentityHash !== appIdentityHash) {
             return;
           }
           try {
             assertUninstallMessage(
-              nodeA.publicIdentifier,
+              nodeB.publicIdentifier,
               multisigAddress,
               appIdentityHash,
               expected,
@@ -131,7 +138,7 @@ describe("Node A and B install an app, then uninstall with a given action", () =
       }),
       new Promise(async (resolve, reject) => {
         try {
-          await nodeA.rpcRouter.dispatch(
+          await nodeB.rpcRouter.dispatch(
             constructUninstallRpc(appIdentityHash, multisigAddress, action),
           );
 

modules/client/src/connext.ts

@@ -378,7 +378,11 @@ export class ConnextClient implements IConnextClient {
     // object might not be in the store yet. We should still wait for at least 1 withdrawal
     const withdrawalsToFind = (await this.getUserWithdrawals()).length || 1;
 
-    this.log.info(`Watching for ${withdrawalsToFind} withdrawal${withdrawalsToFind === 1 ? "s" : ""} starting at block ${startingBlock}`);
+    this.log.info(
+      `Watching for ${withdrawalsToFind} withdrawal${
+        withdrawalsToFind === 1 ? "s" : ""
+      } starting at block ${startingBlock}`,
+    );
 
     const getTransactionResponse = async (
       tx: MinimalTransaction,
@@ -424,17 +428,39 @@ export class ConnextClient implements IConnextClient {
       return responses;
     };
 
-    return new Promise(async (resolve: any, reject: any): Promise<any> => {
-
-      // First, start listener & process the next n blocks. If no withdrawal found, reject.
-      this.ethProvider.on(
-        "block",
-        async (blockNumber: number): Promise<void> => {
-          // in the `WithdrawalController` the user does not store the
-          // commitment until `takeAction` happens, so this may be 0
-          // meaning the withdrawal has not been saved to the store yet
-          (await checkForUserWithdrawals(blockNumber)).forEach(async ([storedValue, tx]) => {
-            if (tx) { // && !transactions.some(t => t.hash === tx.hash)) {
+    return new Promise(
+      async (resolve: any, reject: any): Promise<any> => {
+        // First, start listener & process the next n blocks. If no withdrawal found, reject.
+        this.ethProvider.on(
+          "block",
+          async (blockNumber: number): Promise<void> => {
+            // in the `WithdrawalController` the user does not store the
+            // commitment until `takeAction` happens, so this may be 0
+            // meaning the withdrawal has not been saved to the store yet
+            (await checkForUserWithdrawals(blockNumber)).forEach(async ([storedValue, tx]) => {
+              if (tx) {
+                // && !transactions.some(t => t.hash === tx.hash)) {
+                this.log.info(`Found new tx at block ${tx.blockNumber} for withdrawal: ${tx.hash}`);
+                transactions.push(tx);
+                await this.channelProvider.send(ChannelMethods.chan_setUserWithdrawal, {
+                  withdrawalObject: storedValue,
+                  remove: true,
+                });
+              }
+            });
+            if (blockNumber - startingBlock > blocksAhead) {
+              this.ethProvider.removeAllListeners("block");
+              return reject(`More than ${blocksAhead} have passed`);
+            }
+          },
+        );
+
+        // Second, look for withdrawals in the previous n blocks
+        for (let i = 0; i < blocksBehind; i++) {
+          // eslint-disable-next-line no-loop-func
+          (await checkForUserWithdrawals(startingBlock - i)).forEach(async ([storedValue, tx]) => {
+            if (tx) {
+              // && !transactions.some(t => t.hash === tx.hash)) {
               this.log.info(`Found new tx at block ${tx.blockNumber} for withdrawal: ${tx.hash}`);
               transactions.push(tx);
               await this.channelProvider.send(ChannelMethods.chan_setUserWithdrawal, {
@@ -443,41 +469,23 @@ export class ConnextClient implements IConnextClient {
               });
             }
           });
-          if (blockNumber - startingBlock > blocksAhead) {
-            this.ethProvider.removeAllListeners("block");
-            return reject(`More than ${blocksAhead} have passed`);
-          }
-        },
-      );
+        }
 
-      // Second, look for withdrawals in the previous n blocks
-      for (let i = 0; i < blocksBehind; i++) {
-        // eslint-disable-next-line no-loop-func
-        (await checkForUserWithdrawals(startingBlock - i)).forEach(async ([storedValue, tx]) => {
-          if (tx) { // && !transactions.some(t => t.hash === tx.hash)) {
-            this.log.info(`Found new tx at block ${tx.blockNumber} for withdrawal: ${tx.hash}`);
-            transactions.push(tx);
-            await this.channelProvider.send(ChannelMethods.chan_setUserWithdrawal, {
-              withdrawalObject: storedValue,
-              remove: true,
-            });
+        // Third, wait until the previous two steps have found all the withdrawals
+        while (true) {
+          const withdrawals = await this.getUserWithdrawals();
+          if (transactions.length > 0 && withdrawals.length < 1) {
+            this.log.info(
+              `Found ${transactions.length} transactions, done looking for withdrawals`,
+            );
+            this.ethProvider.removeAllListeners("block");
+            return resolve(transactions);
+          } else {
+            await delay(500);
           }
-        });
-      }
-
-      // Third, wait until the previous two steps have found all the withdrawals
-      while (true) {
-        const withdrawals = await this.getUserWithdrawals();
-        if (transactions.length > 0 && withdrawals.length < 1) {
-          this.log.info(`Found ${transactions.length} transactions, done looking for withdrawals`);
-          this.ethProvider.removeAllListeners("block");
-          return resolve(transactions);
-        } else {
-          await delay(500);
         }
-      }
-
-    });
+      },
+    );
   };
 
   ////////////////////////////////////////
@@ -995,5 +1003,4 @@ export class ConnextClient implements IConnextClient {
     }
     return undefined;
   };
-
 }