export const deployContract = async (
contract: any,
wallet: ethers.Wallet,
args?: any[]
): Promise<ethers.Contract> => {
const contractFactory = new ethers.ContractFactory(
contract.abi,
contract.binary,
wallet
);
return contractFactory.deploy(...(args || []));
};
beforeEach(async () => {
const contractFactory = new ethers.ContractFactory(
appInstance.abi,
await appInstance.generateLinkedBytecode(networkID),
unlockedAccount
);
stateChannel = await contractFactory.deploy(
accounts[0],
[A.address, B.address],
ethers.constants.HashZero,
ethers.constants.HashZero,
10
);
});
/**
* Deploy new instance of contract
* @param wallet Wallet (with provider) to use for contract calls
* @param args Optional arguments to pass to contract constructor
* @returns New contract instance
*/
public async deploy(wallet: ethers.Wallet, args?: any[]): Promise<Contract> {
if (!wallet.provider) {
throw new Error("Signer requires provider");
}
const networkId = (await wallet.provider.getNetwork()).chainId;
const bytecode = (await this.links)
? await this.generateLinkedBytecode(networkId)
: this.bytecode;
const contractFactory = new ethers.ContractFactory(
this.abi,
bytecode,
wallet
);
return contractFactory.deploy(...(args || []));
}
beforeEach(async () => {
const networkID = await AbstractContract.getNetworkID(unlockedAccount);
const staticCall = AbstractContract.fromArtifactName("StaticCall");
const signatures = AbstractContract.fromArtifactName("Signatures");
const transfer = AbstractContract.fromArtifactName("Transfer");
const appInstance = await AbstractContract.fromArtifactName("AppInstance", {
Signatures: signatures,
StaticCall: staticCall,
Transfer: transfer
});
const countingApp = await AbstractContract.fromArtifactName("CountingApp", {
StaticCall: staticCall
});
game = await countingApp.deploy(unlockedAccount);
app = {
addr: game.address,
resolve: game.interface.functions.resolve.sighash,
applyAction: game.interface.functions.applyAction.sighash,
getTurnTaker: game.interface.functions.getTurnTaker.sighash,
isStateTerminal: game.interface.functions.isStateTerminal.sighash
};
terms = {
assetType: AssetType.ETH,
limit: Utils.UNIT_ETH.mul(2),
token: ethers.constants.AddressZero
};
const contractFactory = new ethers.ContractFactory(
appInstance.abi,
await appInstance.generateLinkedBytecode(networkID),
unlockedAccount
);
stateChannel = await contractFactory.deploy(
accounts[0],
[A.address, B.address],
keccak256(encode(appEncoding, app)),
keccak256(encode(termsEncoding, terms)),
10
);
});
beforeEach(async () => {
const paymentApp = await AbstractContract.fromArtifactName("PaymentApp");
pc = await paymentApp.deploy(unlockedAccount);
// Specifically for the AppInstance
const appInstance = artifacts.require("AppInstance");
const staticCall = artifacts.require("StaticCall");
const signatures = artifacts.require("Signatures");
const transfer = artifacts.require("Transfer");
appInstance.link("Signatures", signatures.address);
appInstance.link("StaticCall", staticCall.address);
appInstance.link("Transfer", transfer.address);
app = {
addr: pc.address,
resolve: pc.interface.functions.resolve.sighash,
applyAction: "0x00000000",
getTurnTaker: "0x00000000",
isStateTerminal: "0x00000000"
};
terms = {
assetType: AssetType.ETH,
limit: Utils.UNIT_ETH.mul(2),
token: ethers.constants.AddressZero
};
const contractFactory = new ethers.ContractFactory(
appInstance.abi,
appInstance.binary,
unlockedAccount
);
testAppInstance = await contractFactory.deploy(
accounts[0],
[A.address, B.address],
keccak256(encode(appEncoding, app)),
keccak256(encode(termsEncoding, terms)),
10
);
});