counterfactual / monorepo

Home for all packages related to the Counterfactual project

NOTE: This repository has been moved. Work is continuing under the @statechannels organization as part of statechannels.org project to unify state channels initiatives.

Counterfactual

Simple off-chain applications framework for Ethereum.

Counterfactual is a simple off-chain framework for building state channel applications on top of the Ethereum blockchain. It aims to make it simpler to build permissionless applications that have instant finality with zero-fee transactions.

You can learn more about what state channels are by reading our whitepaper or a less technical written description. Further, if you want to dive into the specifications of the Counterfactual protocol you can read them here.

• Packages
  • Solidity Packages
  • Typescript/Javascript Packages
• Contributing
  • Ethereum Networks
  • Installing dependencies
  • Building packages
  • Clean
  • Lint
  • Tests
  • Patches

Packages

Solidity Packages

Package	Version	Description
@counterfactual/cf-funding-protocol-contracts		Contracts implementation of the Counterfactual funding protocol
@counterfactual/cf-adjudicator-contracts		Contracts implementation of an AppInstance Adjudicator

Typescript/Javascript Packages

Counterfactual-specific packages

Package	Version	Description
@counterfactual/node		The core state channels client that a user runs
@counterfactual/cf.js		A JS API for interacting with off-chain apps
@counterfactual/node-provider		Wrapper around API calls to a Node

Utilities

Package	Version	Description
@counterfactual/types		Shared type declarations
@counterfactual/typescript-typings		Shims for external library typings

Contributing

• Join us in Discord to help with development or to hang out with some ethereum hackers :)
• Create a new issue to report bugs
• Fix an issue. Counterfactual is an Open Source Project!

Ethereum Networks

The Playground currently only supports the Kovan network.

Installing dependencies

Make sure you have Yarn v1.19.0 installed. For easy management of specific Yarn versions, we recommend using Yarn Version Manager (YVM).

To install the dependencies:

yarn

Building packages

It is recommended (optional) that you installed solc compiler binary on your machine (installation guide) and specify the following in your .env under cf-funding-protocol-contracts and apps

NATIVE_SOLC=true

To build all packages:

yarn build

Clean

To clean all packages:

yarn clean

Lint

To lint all packages:

yarn lint

To also apply automatic fixes:

yarn lint:fix

Tests

To run all tests:

yarn test

To run E2E tests:

• If you're using E2E tests for the first time or have done recent changes to the code, run:

yarn test:e2e:setup

• If you're re-running tests or writing new scenarios, run:

NODE_EXTENDED_PRIVATE_KEY="..." yarn test:e2e

See the "Funding the Hub Account for Playground Testing" section on the Simple Hub Server package for more information about NODE_EXTENDED_PRIVATE_KEY.

Patches

We generate patches using the patch-package tool with a workaround described in this issue for yarn workspaces.

monorepo's Issues

[machine] CfOperations tests should use a ProxyFactory instead of manually linking bytcode

monorepo/packages/machine/test/integration/cf-operations.spec.ts

Lines 111 to 117 in 95462c8

	// TODO: Truffle migrate does not auto-link the bytecode in the build folder,
	// so we have to do it manually. Will fix later of course :)
	const multisig = await new ethers.ContractFactory(
	MinimumViableMultisigJson.abi,
	devEnvNetworkContext7777777.linkBytecode(MinimumViableMultisigJson.bytecode),
	ethersMasterWallet
	).deploy();

[machine] Integration tests in ResumeProtocolSpec shouldn't print out deliberately-thrown errors as "real" errors

[machine] CfOperations tests do not explain properly the need for a MULTISIG_PRIVATE_KEY

monorepo/packages/machine/test/integration/cf-operations.spec.ts

Lines 87 to 88 in 1a20e08

	// TODO: What is a MULTISIG_PRIVATE_KEY 🤔
	const ethersMasterWallet = new ethers.Wallet(MULTISIG_PRIVATE_KEY, ganache);

[machine] Document that signingKey.address *must* be a hex, otherwise InstallProposer will fail

[machine] AppChannelInfo interface shouldn't be aware of any StateChannelInfo instance

monorepo/packages/machine/src/types.ts

Lines 315 to 336 in bb2a480

	export interface AppChannelInfo {
	// cf address
	id: H256;
	// used to generate cf address
	uniqueId: number;
	peerA: PeerBalance;
	peerB: PeerBalance;
	// ephemeral keys
	keyA?: Address;
	keyB?: Address;
	encodedState: any;
	appState?: any;
	appStateHash?: H256;
	localNonce: number;
	timeout: number;
	terms: Terms;
	cfApp: CfAppInterface;
	dependencyNonce: CfNonce;
	// TODO: Move this into a method that is outside the data structure
	stateChannel?: StateChannelInfo;
	}

[machine] StateChannelInfo interface should't be aware of owners()

monorepo/packages/machine/src/types.ts

Lines 300 to 313 in bb2a480

	export interface StateChannelInfo {
	counterParty: Address;
	me: Address;
	multisigAddress: Address;
	appChannels: AppChannelInfos;
	freeBalance: CfFreeBalance;
	// TODO: Move this out of the datastructure
	/**
	* @returns the addresses of the owners of this state channel sorted
	* in alphabetical order.
	*/
	owners(): string[];
	}

[machine] TestResponseSink.sendIoMessageToClient() can be confused with TestResponseSink.sendMessageToClient()

monorepo/packages/machine/test/integration/test-response-sink.ts

Lines 143 to 149 in 95462c8

	// TODO: Figure out which client to send the response to
	// TODO: Refactor to clarify difference with sendMessageToClient
	public sendIoMessageToClient(message: ClientActionMessage) {
	if (this.messageListener) {
	this.messageListener(message);
	}
	}

[machine] TestResponseSink requires clarification on why is necessary to bind ACK methods between the IO protocol and VM

monorepo/packages/machine/test/integration/test-response-sink.ts

Lines 68 to 69 in 95462c8

	// TODO: Document why this is needed.
	this.io.ackMethod = this.vm.startAck.bind(this.vm);

[machine] CfAppInterface.hash() shouldn't console.error() if address is 0x0

monorepo/packages/machine/src/middleware/cf-operation/types.ts

Lines 52 to 59 in 1a20e08

	public hash(): string {
	if (this.address === "0x0") {
	// FIXME:
	console.error(
	"WARNING: Can't compute hash for AppInterface because its address is 0x0"
	);
	return ethers.constants.HashZero;
	}

[machine] ActionName shouldn't mix operations and client actions

monorepo/packages/machine/src/types.ts

Lines 425 to 438 in 1a20e08

	// FIXME: move operation action names away from client action names
	export enum ActionName {
	SETUP = "setup",
	INSTALL = "install",
	UPDATE = "update",
	UNINSTALL = "uninstall",
	DEPOSIT = "deposit",
	ADD_OBSERVER = "addObserver",
	REMOVE_OBSERVER = "removeObserver",
	REGISTER_IO = "registerIo",
	RECEIVE_IO = "receiveIo",
	QUERY = "query",
	CONNECT = "connect"
	}

[machine] getStateChannelFromAddressable() should support lookups via non-appID data

monorepo/packages/machine/src/vm.ts

Lines 96 to 102 in 1a20e08

	// TODO: add support for not appID
	public getStateChannelFromAddressable(data: Addressable): StateChannelInfo {
	if (data.appId) {
	return this.cfState.appChannelInfos[data.appId].stateChannel;
	}
	throw Error("No app id available");
	}

[machine] Document that state proposals require valid Ethereum addresses, otherwise the proposers will fail

[machine] Commitments interface shouldn't use a Map for storing commitments

monorepo/packages/machine/test/integration/test-commitment-store.ts

Lines 106 to 115 in 95462c8

	public serialize(): string {
	// FIXME: This is absurd, we shouldn't even be using a Map for this use case
	// considering that the keys are all strings anyway.
	// https://stackoverflow.com/a/29085474/2680092
	const pairs: [ActionName, Transaction][] = [];
	this.commitments.forEach((v, k) => {
	pairs.push([k, v]);
	});
	return JSON.stringify(pairs);
	}

[machine] KeyGenerator.generate() must assign ephemeral keys

monorepo/packages/machine/src/middleware/middleware.ts

Lines 176 to 186 in 1a20e08

	public static generate(message: InternalMessage, next: Function) {
	const wallet = ethers.Wallet.createRandom();
	const installData = message.clientMessage.data;
	// FIXME: properly assign ephemeral keys
	// if (installData.peerA.address === message.clientMessage.fromAddress) {
	// installData.keyA = wallet.address;
	// } else {
	// installData.keyB = wallet.address;
	// }
	// return wallet;
	}

[machine] Attempts to make a commitment with a missing counterparty signature shouldn't throw an unhandled error

monorepo/packages/machine/test/integration/test-commitment-store.ts

Lines 182 to 192 in 95462c8

	const counterpartySignature = incomingMessage!.signature;
	if (
	counterpartySignature === undefined ||
	signature.toString() === counterpartySignature.toString()
	) {
	// FIXME: these errors should be handled more gracefully
	throw Error(
	`Cannot make commitment for operation ${action}.
	The counterparty hasn't signed the commitment.`
	);
	}

Take advantage of EIP 165 for App interface verification

It seems like EIP 165 is being worked on to support one of our use cases; to verify that a particular interface is supported. For us, we'd want to verify that the reduce, resolve, and similar methods are supported on an App that is committed to in the state channel

Resources

• https://github.com/ethereum/EIPs/blob/master/EIPS/eip-165.md
• https://github.com/OpenZeppelin/openzeppelin-solidity/blob/master/contracts/introspection/ERC165.sol

[machine] getLastResult() should return a nullable value

monorepo/packages/machine/src/middleware/middleware.ts

Lines 137 to 152 in bb2a480

	/**
	* @returns the last received client message for this protocol. If the
	* protocol just started, then we haven't received a message from
	* our peer, so just return our starting message. Otherwise, return
	* the last message from our peer (from IO_WAIT).
	*/
	public static lastClientMsg(
	internalMessage: InternalMessage,
	context: Context
	) {
	const res = getLastResult(Instruction.IO_WAIT, context.results);
	// TODO: make getLastResult's return value nullable
	return JSON.stringify(res) === JSON.stringify({})
	? internalMessage.clientMessage
	: res.value;
	}

[machine] Several integration test functions lack nonce + uniqueId validation

cf-operations.spec.ts

validateNoAppsAndFreeBalance()

monorepo/packages/machine/test/integration/cf-operations.spec.ts

Lines 312 to 323 in 95462c8

	/**
	* Validates the correctness of walletAs free balance *not* walletBs.
	*/
	function validateNoAppsAndFreeBalance(
	multisigAddr: string,
	walletA: TestResponseSink,
	walletB: TestResponseSink,
	amountAgiven: ethers.utils.BigNumber,
	amountBgiven: ethers.utils.BigNumber
	) {
	// todo: add nonce and uniqueId params and check them
	const state = walletA.vm.cfState;

validateUninstalledAndFreeBalance()

monorepo/packages/machine/test/integration/cf-operations.spec.ts

Lines 564 to 576 in 95462c8

	/**
	* Validates the correctness of walletA's free balance *not* walletB's.
	*/
	function validateUninstalledAndFreeBalance(
	multisigAddr: string,
	cfAddr: string,
	walletA: TestResponseSink,
	walletB: TestResponseSink,
	amountAgiven: ethers.utils.BigNumber,
	amountBgiven: ethers.utils.BigNumber
	) {
	// TODO: add nonce and uniqueId params and check them
	const state = walletA.vm.cfState;

lifecycle.spec.ts

validateUninstall()

monorepo/packages/machine/test/integration/lifecycle.spec.ts

Lines 227 to 241 in 95462c8

	public static validateUninstall(
	cfAddr: string,
	peerA: TestResponseSink,
	peerB: TestResponseSink,
	amountA: ethers.utils.BigNumber,
	amountB: ethers.utils.BigNumber
	) {
	// TODO: add nonce and uniqueId params and check them
	const state = peerA.vm.cfState;
	const canon = PeerBalance.balances(
	peerA.signingKey.address!,
	amountA,
	peerB.signingKey.address!,
	amountB
	);

test-setup.ts

validateWallet()

monorepo/packages/machine/test/integration/test-setup.ts

Lines 61 to 77 in 95462c8

	/**
	* Validates the correctness of walletAs free balance *not* walletBs.
	*/
	public static validateWallet(
	peerA: TestResponseSink,
	peerB: TestResponseSink,
	amountA: ethers.utils.BigNumber,
	amountB: ethers.utils.BigNumber
	) {
	// TODO: add nonce and uniqueId params and check them
	const state = peerA.vm.cfState;
	const canon = PeerBalance.balances(
	peerA.signingKey.address,
	amountA,
	peerB.signingKey.address,
	amountB
	);

[machine] Integration tests for CfOperations shouldn't depend on Ganache

monorepo/packages/machine/test/integration/cf-operations.spec.ts

Lines 34 to 35 in 95462c8

	// FIXME: Remove this dependency!
	const ganache = new ethers.providers.JsonRpcProvider("http://127.0.0.1:9545");

[machine] TestResponseSink.sendIoMessageToClient() should which client gets the message

monorepo/packages/machine/test/integration/test-response-sink.ts

Lines 143 to 149 in 95462c8

	// TODO: Figure out which client to send the response to
	// TODO: Refactor to clarify difference with sendMessageToClient
	public sendIoMessageToClient(message: ClientActionMessage) {
	if (this.messageListener) {
	this.messageListener(message);
	}
	}

[machine] Signing keys creation shouldn't take care of sorting such keys

monorepo/packages/machine/src/middleware/state-transition/install-proposer.ts

Lines 87 to 103 in bb2a480

	private static newSigningKeys(context: Context, data: InstallData): string[] {
	const lastResult = getLastResult(Instruction.IO_WAIT, context.results);
	let signingKeys;
	if (lastResult && lastResult.value && lastResult.value.data) {
	signingKeys = [lastResult.value.data.keyA, lastResult.value.data.keyB];
	} else {
	signingKeys = [data.keyA!, data.keyB!];
	}
	// TODO: Feels like this is the wrong place for this sorting...
	signingKeys.sort((addrA: Address, addrB: Address) => {
	return new ethers.utils.BigNumber(addrA).lt(addrB) ? -1 : 1;
	});
	return signingKeys;
	}

[machine] NetworkContext shouldn't link contract byte-code relying on dynamic references and object inspection

monorepo/packages/machine/src/types.ts

Lines 260 to 282 in 1a20e08

	export class NetworkContext {
	// FIXME: This is just bad practice :S
	private contractToVar = {
	Registry: "registryAddr",
	PaymentApp: "paymentAppAddr",
	ConditionalTransaction: "conditionalTransactionAddr",
	MultiSend: "multiSendAddr",
	NonceRegistry: "nonceRegistryAddr",
	Signatures: "signaturesAddr",
	StaticCall: "staticCallAddr",
	ETHBalanceRefundApp: "ethBalanceRefundAppAddr"
	};
	constructor(
	readonly registryAddr: Address,
	readonly paymentAppAddr: Address,
	readonly conditionalTransactionAddr: Address,
	readonly multiSendAddr: Address,
	readonly nonceRegistryAddr: Address,
	readonly signaturesAddr: Address,
	readonly staticCallAddr: Address,
	readonly ethBalanceRefundAppAddr: Address
	) {}

[machine] SignatureValidator needs implementation

monorepo/packages/machine/src/middleware/middleware.ts

Lines 189 to 203 in bb2a480

	export class SignatureValidator {
	public static async validate(
	message: InternalMessage,
	next: Function,
	context: Context
	) {
	const incomingMessage = getFirstResult(
	Instruction.IO_WAIT,
	context.results
	);
	const op = getFirstResult(Instruction.OP_GENERATE, context.results);
	// TODO: now validate the signature against the op hash
	next();
	}
	}

[machine] Signature class constructor arguments need better typing

monorepo/packages/machine/src/types.ts

Lines 411 to 412 in bb2a480

	// TODO: fix types
	constructor(readonly v: number, readonly r: string, readonly s: string) {}

[machine] Resolver code shouldn't be part of the contractInterface() method

monorepo/packages/machine/src/middleware/cf-operation/types.ts

Lines 168 to 185 in d822904

	public static contractInterface(ctx: NetworkContext): CfAppInterface {
	const address = ctx.paymentAppAddr;
	const applyAction = "0x00000000"; // not used
	const resolver = new ethers.utils.Interface([
	// TODO: Put this somewhere eh
	"resolve(tuple(address,address,uint256,uint256),tuple(uint8,uint256,address))"
	]).functions.resolve.sighash;
	const turn = "0x00000000"; // not used
	const isStateTerminal = "0x00000000"; // not used
	return new CfAppInterface(
	address,
	applyAction,
	resolver,
	turn,
	isStateTerminal,
	"tuple(address alice, address bob, uint256 aliceBalance, uint256 bobBalance)"
	);
	}

[machine] Should remove `tslint:disable-next-line` from CfOperations tests for number-named references

monorepo/packages/machine/test/integration/cf-operations.spec.ts

Lines 48 to 51 in 1a20e08

	// TODO: The linter can't handle files with numbers as names. This should be fixed
	// when we have a different method for retrieving the network addresses anyway.
	// tslint:disable-next-line
	const networkFile = require("@counterfactual/contracts/networks/7777777.json");

[machine] getFirstResult() has unused parameter `value`

monorepo/packages/machine/src/middleware/middleware.ts

Lines 208 to 214 in 1a20e08

	export function getFirstResult(
	toFindOpCode: Instruction,
	results: { value: any; opCode }[]
	): OpCodeResult {
	// FIXME: (ts-strict) we should change the results data structure or design
	return results.find(({ opCode, value }) => opCode === toFindOpCode)!;
	}

[machine] ResponseSink interface has no known purpose

monorepo/packages/machine/src/types.ts

Lines 351 to 354 in bb2a480

	// TODO: document what this is
	export interface ResponseSink {
	sendResponse(res: Response);
	}

[machine] TestResponseSink.responseListener should support multiple callbacks

monorepo/packages/machine/test/integration/test-response-sink.ts

Lines 138 to 141 in 95462c8

	// TODO: Make responseListener a map/array
	public onResponse(callback: Function) {
	this.responseListener = callback;
	}

Add an example app that is upgradeable using ZeppelinOS

The apps in appDefinitions are natural candidates for ZeppelinOS upgradeable contracts. To exhibit this, it would be nice to show an example application in the contracts codebase using this.

[machine] VM reference breaks encapsulation in ActionExecution.createContext()

monorepo/packages/machine/src/action.ts

Lines 80 to 88 in d822904

	public createContext(): Context {
	return {
	results: this.results,
	instructionPointer: this.instructionPointer,
	// TODO: Should probably not pass the whole VM in, it breaks the encapsulation
	// We should figure out what others args from the VM are used and copy those over
	vm: this.vm
	};
	}

[machine] Deploys for integration tests shouldn't use a hardcoded gas limit

monorepo/packages/machine/test/integration/cf-operations.spec.ts

Lines 148 to 149 in 95462c8

	// TODO: Figure out how to not have to put the insanely high gasLimit here
	await registry.functions.deploy(initcode, 0, { gasLimit: 6e9 });

Explore 0x's AssetProxy paradigm further to see if it is compatible

As it stands right now, transactions are either ETH, ERC20, or "Other" in the Transfer.Transaction objects implementation. Of course this means we can encode the data off-chain for arbitrary transactions to be made that distribute state, but there are limitations when we want to apply restrictions (e.g., limiting the scope of a resolution to "max 10 ETH" or, "max 10 DAI", or perhaps something more complicated like "only this specific CryptoKitty"). These limitations have to be encoded on-chain. Thus, there are probably some similarities in the implementation of 0x's AssetProxy that we could re-use.

[machine] Return a better error mesage if no middleware is found (instead of `cannot read property '0' of undefined`)

monorepo/packages/machine/src/middleware/middleware.ts

Lines 56 to 81 in d822904

	public async run(msg: InternalMessage, context: Context) {
	let counter = 0;
	const middlewares = this.middlewares;
	const opCode = msg.opCode;
	this.executeAllMiddlewares(msg, context);
	async function callback() {
	if (counter === middlewares[opCode].length - 1) {
	return Promise.resolve(null);
	}
	// This is hacky, prevents next from being called more than once
	counter += 1;
	const middleware = middlewares[opCode][counter];
	if (opCode === Instruction.ALL || middleware.scope === opCode) {
	return middleware.method(msg, callback, context);
	}
	return callback();
	}
	// TODO: Document or throw error about the fact that you _need_ to have
	// a middleware otherwise this will error with:
	// `TypeError: Cannot read property '0' of undefined`
	return this.middlewares[opCode][0].method(msg, callback, context);
	}

[machine] TestCommitmentStore.addCommitment() shouldn't allow any other action other than UPDATE if there are any actions in `commitments` collection

monorepo/packages/machine/test/integration/test-commitment-store.ts

Lines 73 to 85 in 95462c8

	public async addCommitment(
	action: ActionName,
	cfOperation: CfOperation,
	signatures: Signature[]
	) {
	const commitment = cfOperation.transaction(signatures);
	if (action !== ActionName.UPDATE && this.commitments.has(action)) {
	return;
	// FIXME: we should never non-maliciously get to this state
	throw Error("Can't reset setup/install/uninstall commitments");
	}
	this.commitments.set(action, commitment);
	}

[machine] Members in `cfApp` should be typed (`any` should be removed)

monorepo/packages/machine/src/middleware/cf-operation/cf-op-generator.ts

Lines 75 to 84 in d822904

	// TODO: ensure these members are typed instead of having to reconstruct
	// class instances
	appChannel.cfApp = new CfAppInterface(
	appChannel.cfApp.address,
	appChannel.cfApp.applyAction,
	appChannel.cfApp.resolve,
	appChannel.cfApp.getTurnTaker,
	appChannel.cfApp.isStateTerminal,
	appChannel.cfApp.abiEncoding
	);

[machine] Linter doesn't like Symbol.asyncIterator declaration in ActionExecution

monorepo/packages/machine/src/action.ts

Lines 113 to 119 in d822904

	// TODO: Figure out the correct structure to be compliant with linter
	// tslint:disable
	public [Symbol.asyncIterator]() {
	return {
	next: () => this.next()
	};
	}

[contracts] Set up Typechain to set up typings for contracts in tests

It would be nice to have typings for the contracts when we test them in the contracts package.

I spent some time trying this out, but there were a few limitations that will have to be considered before we fully integrate it into the code base.

1. At the moment the set of typings in the related package truffle-typings are fairly limited. For example, there is no address property on a TruffleContract object. We still use TruffleContract objects in the repo, for example when we use artifacts.require. We'll need to extend that package or just extend our own package( packages/typescript-typings).

2. In many places, we actually don't even use the TruffleContract object, we actually use ethers.Contract. Thus, we need to wait until this pull request is merged into Typechain adding support for ethers.js as a "target".

[machine] CounterfactualVM.run() method uses async iteration with hard-to-read syntax

monorepo/packages/machine/src/vm.ts

Lines 132 to 144 in 1a20e08

	public async run(execution: ActionExecution) {
	try {
	// Temporary error handling for testing resuming protocols
	let val;
	// TODO: Bizarre syntax...
	for await (val of execution) {
	}
	this.sendResponse(execution, ResponseStatus.COMPLETED);
	} catch (e) {
	console.error(e);
	this.sendResponse(execution, ResponseStatus.ERROR);
	}
	}

[machine] TestResponseSink.messageListener should support multiple callbacks

monorepo/packages/machine/test/integration/test-response-sink.ts

Lines 151 to 154 in 95462c8

	// TODO: Make messageListener a map/array
	public onMessage(callback: Function) {
	this.messageListener = callback;
	}

[machine] SetupProcotol.run2() integration test method should be better named

monorepo/packages/machine/test/integration/test-setup.ts

Lines 90 to 98 in 95462c8

	// TODO: Better name
	private static async run2(peerA: TestResponseSink, peerB: TestResponseSink) {
	const msg = SetupProtocol.setupStartMsg(
	peerA.signingKey.address,
	peerB.signingKey.address
	);
	const response = await peerA.runProtocol(msg);
	expect(response.status).toEqual(ResponseStatus.COMPLETED);
	}

[machine] EthCfOpGenerator.update() shouldn't fail completely if no appID is provided

monorepo/packages/machine/src/middleware/cf-operation/cf-op-generator.ts

Lines 61 to 71 in 1a20e08

	public update(
	message: InternalMessage,
	context: Context,
	cfState: CfState,
	proposedUpdate: any
	): CfOperation {
	const multisig: Address = message.clientMessage.multisigAddress;
	if (message.clientMessage.appId === undefined) {
	// FIXME: handle more gracefully
	throw Error("update message must have appId set");
	}

[machine] EthCfOpGenerator.update() should return a CfOpSetState with app-specific ephemeral keys

monorepo/packages/machine/src/middleware/cf-operation/cf-op-generator.ts

Lines 100 to 111 in 1a20e08

	return new CfOpSetState(
	cfState.networkContext,
	multisig,
	// FIXME: signing keys should be app-specific ephemeral keys
	signingKeys,
	appChannel.appStateHash,
	appChannel.uniqueId,
	appChannel.terms,
	appChannel.cfApp,
	appChannel.localNonce,
	appChannel.timeout
	);

[machine] ClientResponse type must be further specified (no "any" declarations)

monorepo/packages/machine/src/types.ts

Lines 104 to 110 in bb2a480

	export interface ClientResponse {
	requestId: string;
	// TODO: tighten the type
	status?: any;
	data?: any;
	appId?: string;
	}

[machine] Execution of Instruction.ALL should do middleware cascading instead of plain iteration

monorepo/packages/machine/src/middleware/middleware.ts

Lines 83 to 97 in d822904

	/**
	* Runs the middlewares for Instruction.ALL.
	*/
	// TODO: currently this method seems to be passing null as the middleware callback and
	// just iterating through all the middlewares. We should pass the callback similarly to how
	// run does it, and rely on that for middleware cascading
	private executeAllMiddlewares(msg, context) {
	const all = this.middlewares[Instruction.ALL];
	if (all && all.length > 0) {
	all.forEach(middleware => {
	middleware.method(msg, null, context);
	});
	}
	}
	}

[machine] CfFreeBalance.terms() should not use a hard-coded limit

monorepo/packages/machine/src/middleware/cf-operation/types.ts

Lines 161 to 165 in 1a20e08

	return new Terms(
	0, // 0 means ETH
	ethers.utils.parseEther("0.001"), // FIXME: un-hardcode
	ethers.constants.AddressZero
	);

[machine] Remove timeout from CfMultisendOp.dependencyNonceInput()

monorepo/packages/machine/src/middleware/cf-operation/cf-multisend-op.ts

Lines 108 to 121 in 1a20e08

	public dependencyNonceInput(): MultisigInput {
	const timeout = 0; // FIXME: new NonceRegistryJson design will obviate timeout
	const to = this.networkContext.nonceRegistryAddr;
	const val = 0;
	const data = new ethers.utils.Interface(
	NonceRegistryJson.abi
	).functions.setNonce.encode([
	timeout,
	this.dependencyNonce.salt,
	this.dependencyNonce.nonceValue
	]);
	const op = Operation.Call;
	return new MultisigInput(to, val, data, op);
	}

Can not run `yarn test`

hello

I git clone this Repositories and Run yarn ganache in a separate terminal

but when I type yarn test ,it gose wrong:

ubuntu@ip-172-31-15-69:~/counterfactual$ yarn test
yarn run v1.9.4
$ yarn ganache &> ganache.log & yarn build:pre && yarn build:packages && wsrun test $PKG --exclude-missing && yarn build:post
$ ./bin/prebuild
$ ganache-cli --gasLimit 0xfffffffffff --port 9545 --account="${npm_package_config_unlockedAccount}" -m "${npm_package_config_mnemonic}"
$ wsrun build $PKG --fast-exit -r --serial --exclude-missing
@counterfactual/configs has no  build script, skipping missing
@counterfactual/run-with-ganache has no  build script, skipping missing
@counterfactual/typescript-typings has no  build script, skipping missing
@counterfactual/test-utils
$ tsc --project tsconfig.json.modified
 | error TS5014: Failed to parse file 'packages/test-utils/tsconfig.json.modified/tsconfig.json': Unexpected token u in JSON at position 0.
error Command failed with exit code 1.
info Visit https://yarnpkg.com/en/docs/cli/run for documentation about this command.
`yarn build` failed with exit code 1
Stopping 1 active children
Aborted execution due to previous error
error Command failed with exit code 1.
info Visit https://yarnpkg.com/en/docs/cli/run for documentation about this command.
error Command failed with exit code 1.
info Visit https://yarnpkg.com/en/docs/cli/run for documentation about this command.
ubuntu@ip-172-31-15-69:~/counterfactual$ Ganache CLI v6.1.7 (ganache-core: 2.2.0)
Error: listen EADDRINUSE 127.0.0.1:9545
    at Server.setupListenHandle [as _listen2] (net.js:1336:14)
    at listenInCluster (net.js:1384:12)
    at doListen (net.js:1510:7)
    at process._tickCallback (internal/process/next_tick.js:63:19)
    at Function.Module.runMain (internal/modules/cjs/loader.js:745:11)
    at startup (internal/bootstrap/node.js:266:19)
    at bootstrapNodeJSCore (internal/bootstrap/node.js:596:3)
error Command failed with exit code 1.
info Visit https://yarnpkg.com/en/docs/cli/run for documentation about this command.

system configuration

ubuntu@ip-172-31-15-69:~/counterfactual$ uname -a 
Linux ip-172-31-15-69 4.4.0-1061-aws #70-Ubuntu SMP Fri May 25 21:47:34 UTC 2018 x86_64 x86_64 x86_64 GNU/Linux
ubuntu@ip-172-31-15-69:~/counterfactual$ node -v
v10.8.0
ubuntu@ip-172-31-15-69:~/counterfactual$ nodejs -v
v8.11.3
ubuntu@ip-172-31-15-69:~/counterfactual$ yarn -v
1.9.4
ubuntu@ip-172-31-15-69:~/counterfactual$ 

NEED HELP!

[machine] Initcode encoding shouldn't have a hardcoded timeout

monorepo/packages/machine/test/integration/cf-operations.spec.ts

Lines 133 to 146 in 95462c8

	const initcode = new ethers.utils.Interface(
	AppInstanceJson.abi
	).deployFunction.encode(
	devEnvNetworkContext7777777.linkBytecode(AppInstanceJson.bytecode),
	[
	multisig.address,
	signingKeys,
	app.hash(),
	terms.hash(),
	// TODO: Don't hard-code the timeout, make it dependant on some
	// function(blockchain) to in the future check for congestion... :)
	100
	]
	);

[machine] CfFreeBalance requires implementation changes on the contracts layer

monorepo/packages/machine/src/middleware/cf-operation/types.ts

Lines 154 to 166 in 1a20e08

	/**
	* The state of a free balance object. Passing this into an install or uninstall
	* will update the free balance object to the values given here.
	*/
	export class CfFreeBalance {
	public static terms(): Terms {
	// FIXME: Change implementation of free balance on contracts layer
	return new Terms(
	0, // 0 means ETH
	ethers.utils.parseEther("0.001"), // FIXME: un-hardcode
	ethers.constants.AddressZero
	);
	}