/**
   * Sets the commitment at the end of a protocol's execution.
   * @param internalMessage
   * @param next
   * @param context
   * @throws Error if the counterparty's signature is not set
   */
  public async setCommitment(
    internalMessage: InternalMessage,
    next: Function,
    context: Context
  ) {
    let appId;
    const action: cf.legacy.node.ActionName = internalMessage.actionName;
    const operation = context.intermediateResults.operation!;
    let appCommitments: AppCommitments;

    const incomingMessage = this.incomingMessage(internalMessage, context);

    if (action === cf.legacy.node.ActionName.SETUP) {
      appId = internalMessage.clientMessage.multisigAddress;
    } else if (action === cf.legacy.node.ActionName.INSTALL) {
      const proposal = context.intermediateResults.proposedStateTransition!;
      appId = proposal.cfAddr;
    } else {
      appId = internalMessage.clientMessage.appId;
    }

    if (this.store.has(appId)) {
      appCommitments = AppCommitments.deserialize(appId, this.store.get(appId));
    } else {
      appCommitments = new AppCommitments(appId);
      this.appCount += 1;
      this.store.put(appId, Object(appCommitments.serialize()));
    }

    const signature = context.intermediateResults.signature!;

    const counterpartySignature = incomingMessage!.signature!;
    if (
      counterpartySignature === undefined ||
      cf.utils.signaturesToBytes(signature) ===
        cf.utils.signaturesToBytes(counterpartySignature)
    ) {
      // FIXME: these errors should be handled more gracefully
      // https://github.com/counterfactual/monorepo/issues/99
      throw Error(
        `Cannot make commitment for operation ${action}.
        The counterparty hasn't signed the commitment.`
      );
    }

    await appCommitments.addCommitment(action, operation, [
      signature,
      counterpartySignature
    ]);
    this.store.put(appId, Object(appCommitments.serialize()));
    next();
  }

function constructSetStateData(signatures: ethers.utils.Signature[]): string {
  return constructContractCall(
    "proxyCall(address,bytes32,bytes)",
    TEST_NETWORK_CONTEXT.registryAddr,
    TEST_APP_INSTANCE.cfAddress(),
    constructContractCall(
      "setState(bytes32,uint256,uint256,bytes)",
      TEST_APP_STATE_HASH,
      TEST_LOCAL_NONCE,
      TEST_TIMEOUT,
      cf.utils.signaturesToBytes(...signatures)
    )
  );
}

export function constructMultisigExecTransaction(
  operation: "delegatecall" | "call",
  to: string,
  value: string | number,
  transactionData: string,
  signatures: ethers.utils.Signature[]
): string {
  return constructContractCall(
    "execTransaction(address, uint256, bytes, uint8, bytes)",
    to,
    value,
    transactionData,
    operation === "delegatecall" ? 1 : 0,
    cf.utils.signaturesToBytes(...signatures)
  );
}

 public transaction(sigs: ethers.utils.Signature[]): Transaction {
   const multisigInput = this.multisigInput();
   const signatureBytes = cf.utils.signaturesToSortedBytes(
     this.hashToSign(),
     ...sigs
   );
   const txData = new ethers.utils.Interface(
     MinimumViableMultisigJson.abi
   ).functions.execTransaction.encode([
     multisigInput.to,
     multisigInput.val,
     multisigInput.data,
     multisigInput.op,
     signatureBytes
   ]);
   return new Transaction(this.multisig, 0, txData);
 }

 /**
  * @returns a tx that executes a proxyCall through the registry to call
  *          `setState` on AppInstance.sol.
  */
 public transaction(sigs: ethers.utils.Signature[]): Transaction {
   const appCfAddr = new cf.legacy.app.AppInstance(
     this.ctx,
     this.multisig,
     this.signingKeys,
     this.app,
     this.terms,
     this.timeout,
     this.appUniqueId
   ).cfAddress();
   const to = this.ctx.registryAddr;
   const val = 0;
   const data = common.proxyCallSetStateData(
     this.ctx,
     this.appStateHash,
     appCfAddr,
     this.appLocalNonce,
     this.timeout,
     cf.utils.signaturesToSortedBytes(this.hashToSign(), ...sigs)
   );
   return new Transaction(to, val, data);
 }