public async deposit(
    address: Address,
    amount: ethers.utils.BigNumber,
    threshold: ethers.utils.BigNumber
  ) {
    const stateChannelInfo = await this.queryStateChannel();
    const isPeerA =
      stateChannelInfo.data.stateChannel.freeBalance.alice === this.fromAddress;

    const signingKeys = [this.toAddress, this.fromAddress];
    const appInstance = new ETHBalanceRefundApp(address, signingKeys);
    const deposits = {
      [this.fromAddress]: ethers.utils.bigNumberify("0"),
      [this.toAddress]: ethers.utils.bigNumberify("0")
    };
    const state = [this.fromAddress, this.multisigAddress, threshold];

    const balanceRefund = await this.install(
      "ETHBalanceRefundApp",
      appInstance,
      deposits,
      state
    );
    await this.depositToMultisig(amount);
    await balanceRefund.uninstall({
      peerABalance: isPeerA ? amount : ethers.utils.bigNumberify(0),
      peerBBalance: isPeerA ? ethers.utils.bigNumberify(0) : amount
    });
  }

const signaturesAndDigests = ["sig1", "sig3", "sig2"].map(message => {
  const bytes = ethers.utils.toUtf8Bytes(message);
  const digest = ethers.utils.keccak256(bytes);
  const signature = signingKey.signDigest(digest);

  return {
    digest,
    signature
  };
});

 public static terms(): Terms {
   // FIXME: Change implementation of free balance on contracts layer
   // https://github.com/counterfactual/monorepo/issues/118
   return new Terms(
     0, // 0 means ETH
     ethers.utils.parseEther("0.001"), // FIXME: un-hardcode (https://github.com/counterfactual/monorepo/issues/117)
     ethers.constants.AddressZero
   );
 }

  constructor(appAddress: string, signingKeys: string[]) {
    const timeout = 100;
    const terms = new Terms(
      0,
      ethers.utils.bigNumberify("0"),
      ethers.constants.AddressZero
    );
    const abiEncodings = AppInstance.generateAbiEncodings(
      ETHBalanceRefundAppContract.abi
    );

    const appDefinition: AppDefinition = {
      address: appAddress,
      appStateEncoding: abiEncodings.appStateEncoding,
      appActionEncoding: abiEncodings.appActionEncoding
    };

    super(signingKeys, appDefinition, terms, timeout);
  }

  // TODO: temp hack necessary until ethers support https://github.com/ethers-io/ethers.js/issues/325
  static generateAbiEncodings(
    abi: string | (string | ethers.utils.ParamType)[]
  ): AbiEncodings {
    const iface = new ethers.utils.Interface(abi);
    const appFunctionNames = Object.keys(iface.functions).filter(fn => {
      return fn.indexOf("(") === -1;
    });
    const appActions = appFunctionNames.map(fn => {
      const inputs = iface.functions[fn].inputs;
      const tuples = inputs.map(input => {
        return ethers.utils.formatParamType(input);
      });

      return `${fn}(${tuples.join(",")})`;
    });

    return {
      appStateEncoding: ethers.utils.formatParamType(
        iface.functions.resolve.inputs[0]
      ),
      appActionEncoding: JSON.stringify([appActions.join(",")])
    };
  }

 constructor(
   readonly address: Address,
   balance: number | ethers.utils.BigNumber
 ) {
   this.balance = ethers.utils.bigNumberify(balance.toString());
 }

const deserializeBigNumber = data => ethers.utils.bigNumberify(data._hex);

 const tuples = inputs.map(input => {
   return ethers.utils.formatParamType(input);
 });

export function encodePacked(types: string[], values: any[]) {
  return ethers.utils.solidityPack(types, values);
}

 sigs.sort((sigA, sigB) => {
   const addrA = ethers.utils.recoverAddress(digest, signaturesToBytes(sigA));
   const addrB = ethers.utils.recoverAddress(digest, signaturesToBytes(sigB));
   return new ethers.utils.BigNumber(addrA).lt(addrB) ? -1 : 1;
 });