_section: ContractFactory @<ContractFactory> @SRC<contracts:class.ContractFactory>

@TODO: Fill this in, including @SRC links

_subsection: Creating Instances  @<ContractFactory--creating>

_property: new ethers.ContractFactory(interface, bydecode [ , signer ]) @SRC<contracts:constructor.ContractFactory>

_property: ContractFactory.fromSolidity(compilerOutput [ , signer ]) => [[ContractFactory]]

_property: contractFactory.connect(signer) => [[Contract]] @<ContractFactory-connect>


_subsection: Properties  @<ContractFactory--properties>

_property: contractFactory.interface => [[Interface]]

_property: contractFactory.bytecode => string<[[DataHexString]]>

_property: contractFactory.signer => [[Signer]]


_subsection: Methods  @<ContractFactory--methods>

_property: contractFactory.attach(address) => [[Contract]] @<ContractFactory-attach>

Return an instance of a [[Contract]] attched to //address//. This is the
same as using the [Contract constructor](Contract--creating) with
//address// and this the the //interface// and //signerOrProvider// passed
in when creating the ContractFactory.

_property: contractFactory.getDeployTransaction(...args) => [[UnsignedTransaction]]

Returns the unsigned transaction which would deploy this Contract with //args// passed
to the Contract's constructor.

_property: contractFactory.deploy(...args) => Promise<[[Contract]]> @<ContractFactory-deploy>

Uses the signer to deploy the Contract with //args// passed into the constructor and
retruns a Contract which is attached to  the address where this contract **will** be
deployed once the transaction is mined.

The transaction can be found at ``contract.deployTransaction``, and no interactions
should be made until the transaction is mined.

_code: Deploying a Contract

// <hide>
const signer = ethers.LocalSigner();
const ContractFactory = ethers.ContractFactory;
// </hide>

// If your contract constructor requires parameters, the ABI
// must include the constructor
const abi = [
  "constructor(address owner, uint256 initialValue)"
];

const factory = new ContractFactory(abi, bytecode, signer)

const contract = await factory.deploy("ricmoo.eth", 42);

// The address is available immediately, but the contract
// is NOT deployed yet
contract.address
//!

// The transaction that the signer sent to deploy
contract.deployTransaction
//!

// Wait until the transaction is mined
contract.deployTransaction.wait()
//!

// Now the contract is safe to interact with
contract.value()
//!