# FutarchyFactory

Futarchy factory is used to create price-based futarchy markets.

Market creation logic:

1. Ask reality questions.
2. Prepare condition.
3. Create new erc20 outcome tokens.
4. Initialize a new market contract.

## Variables

### CreateProposalParams

```solidity
struct CreateProposalParams {
  string marketName;
  IERC20 collateralToken1;
  IERC20 collateralToken2;
  string category;
  string lang;
  uint256 minBond;
  uint32 openingTime;
}
```

### REALITY\_SINGLE\_SELECT\_TEMPLATE

```solidity
uint8 REALITY_SINGLE_SELECT_TEMPLATE
```

_Template for categorical markets._

### questionTimeout

```solidity
uint32 questionTimeout
```

_Reality question timeout._

### arbitrator

```solidity
address arbitrator
```

_Arbitrator contract._

### realitio

```solidity
contract IRealityETH_v3_0 realitio
```

_Reality.eth contract._

### wrapped1155Factory

```solidity
contract IWrapped1155Factory wrapped1155Factory
```

_Wrapped1155Factory contract._

### conditionalTokens

```solidity
contract IConditionalTokens conditionalTokens
```

_Conditional Tokens contract._

### collateralToken

```solidity
address collateralToken
```

_Conditional Tokens collateral token contract._

### realityProxy

```solidity
contract RealityProxy realityProxy
```

_Oracle contract._

### proposals

```solidity
address[] proposals
```

_Proposals created by this factory._

### proposal

```solidity
address proposal
```

_Proposal contract._

## Events

### NewProposal

```solidity
event NewProposal(address indexed proposal, string marketName, bytes32 conditionId, bytes32 questionId)
```

_To be emitted when a new proposal is created._

**Parameters**

| Name        | Type    | Description                     |
| ----------- | ------- | ------------------------------- |
| proposal    | address | The new proposal address.       |
| marketName  | string  | The name of the market.         |
| conditionId | bytes32 | Conditional Tokens conditionId. |
| questionId  | bytes32 | Conditional Tokens questionId.  |

## Functions

### constructor

```solidity
constructor(address _proposal, address _arbitrator, contract IRealityETH_v3_0 _realitio, contract IWrapped1155Factory _wrapped1155Factory, contract IConditionalTokens _conditionalTokens, contract RealityProxy _realityProxy, uint32 _questionTimeout) public
```

_Constructor._

| Name                 | Type                         | Description                                                                        |
| -------------------- | ---------------------------- | ---------------------------------------------------------------------------------- |
| \_proposal           | address                      | Address of the proposal contract that is going to be used for each new deployment. |
| \_arbitrator         | address                      | Address of the arbitrator that is going to resolve Realitio disputes.              |
| \_realitio           | contract IRealityETH\_v3\_0  | Address of the Realitio implementation.                                            |
| \_wrapped1155Factory | contract IWrapped1155Factory | Address of the Wrapped1155Factory implementation.                                  |
| \_conditionalTokens  | contract IConditionalTokens  | Address of the ConditionalTokens implementation.                                   |
| \_realityProxy       | contract RealityProxy        | Address of the RealityProxy implementation.                                        |
| \_questionTimeout    | uint32                       | Reality question timeout.                                                          |

### createProposal

```solidity
function createProposal(struct FutarchyFactory.CreateProposalParams params) external returns (address)
```

_Creates a price-based futarchy market and deploys the wrapped ERC20 tokens._

**Parameters**

| Name   | Type                                        | Description                    |
| ------ | ------------------------------------------- | ------------------------------ |
| params | struct FutarchyFactory.CreateProposalParams | CreateProposalParams instance. |

**Return Values**

| Name | Type    | Description               |
| ---- | ------- | ------------------------- |
| \[0] | address | The new proposal address. |

**Logic**

1. Ask reality questions.
2. Prepare condition.
3. Create new erc20 outcome tokens.
4. Initialize a new proposal contract.

### createNewProposalParams

```solidity
function createNewProposalParams(struct FutarchyFactory.CreateProposalParams params, string[] memory tokenNames) internal returns (struct FutarchyProposal.FutarchyProposalParams)
```

_Creates the structures needed to initialize the new proposal._

**Parameters**

| Name       | Type                                        | Description                                 |
| ---------- | ------------------------------------------- | ------------------------------------------- |
| params     | struct FutarchyFactory.CreateProposalParams | CreateProposalParams instance.              |
| tokenNames | string\[] memory                            | Array with the names of the outcome tokens. |

**Return Values**

| Name | Type                                           | Description                                      |
| ---- | ---------------------------------------------- | ------------------------------------------------ |
| \[0] | struct FutarchyProposal.FutarchyProposalParams | FutarchyProposal.FutarchyProposalParam instance. |

### getOutcomesAndTokens

```solidity
function getOutcomesAndTokens(IERC20 collateralToken1, IERC20 collateralToken2) internal view returns (string memory[], string memory[])
```

_Creates the outcomes and token names._

**Parameters**

| Name             | Type   | Description              |
| ---------------- | ------ | ------------------------ |
| collateralToken1 | IERC20 | The token collateral.    |
| collateralToken2 | IERC20 | The currency collateral. |

**Return Values**

| Name | Type      | Description              |
| ---- | --------- | ------------------------ |
| \[0] | string\[] | The outcomes names.      |
| \[1] | string\[] | The wrapped ERC20 names. |

### encodeRealityQuestion

```solidity
function encodeRealityQuestion(string question, string category, string lang) internal pure returns (string)
```

_Encodes the question, category and language following the Reality structure. If any parameter has a special character like quotes, it must be properly escaped._

**Parameters**

| Name     | Type   | Description            |
| -------- | ------ | ---------------------- |
| question | string | The question text.     |
| category | string | The question category. |
| lang     | string | The question language. |

**Return Values**

| Name | Type   | Description           |
| ---- | ------ | --------------------- |
| \[0] | string | The encoded question. |

### askRealityQuestion

```solidity
function askRealityQuestion(string encodedQuestion, uint256 templateId, uint32 openingTime, uint256 minBond) internal returns (bytes32)
```

_Asks a question on reality._

**Parameters**

| Name            | Type    | Description                                             |
| --------------- | ------- | ------------------------------------------------------- |
| encodedQuestion | string  | The encoded question containing the Reality parameters. |
| templateId      | uint256 | The Reality template id.                                |
| openingTime     | uint32  | The question opening time.                              |
| minBond         | uint256 | The question min bond.                                  |

**Return Values**

| Name | Type    | Description     |
| ---- | ------- | --------------- |
| \[0] | bytes32 | The question id |

### prepareCondition

```solidity
function prepareCondition(bytes32 questionId, uint256 outcomeSlotCount) internal returns (bytes32)
```

_Prepares the CTF condition and returns the conditionId._

**Parameters**

| Name             | Type    | Description                                                                             |
| ---------------- | ------- | --------------------------------------------------------------------------------------- |
| questionId       | bytes32 | An identifier for the question to be answered by the oracle.                            |
| outcomeSlotCount | uint256 | The number of outcome slots which must be used for this condition. Must not exceed 256. |

**Return Values**

| Name | Type    | Description   |
| ---- | ------- | ------------- |
| \[0] | bytes32 | Condition ID. |

**Pre-condition**

1. Reality question asked and return <mark style="color:red;">`questionsId`</mark>.

**Logic**

1. It will check if there is a prepared condition on <mark style="color:red;">`ConditionalTokens`</mark>, and call <mark style="color:red;">`conditionalTokens.prepareCondition()`</mark> if there isn't any.

### deployERC20Positions

```solidity
function deployERC20Positions(IERC20 collateralToken1, IERC20 collateralToken2, bytes32 parentCollectionId, bytes32 conditionId, string[] tokenNames) internal returns (contract IERC20[] wrapped1155, bytes[] data)
```

_Wraps the ERC1155 outcome tokens to ERC20._

**Parameters**

| Name               | Type      | Description                     |
| ------------------ | --------- | ------------------------------- |
| collateralToken1   | ERC20     | The token collateral.           |
| collateralToken2   | ERC20     | The currency collateral.        |
| parentCollectionId | bytes32   | The parentCollectionId.         |
| conditionId        | bytes32   | The conditionId.                |
| tokenNames         | string\[] | The name of each outcome token. |

**Return Values**

| Name        | Type               | Description                                    |
| ----------- | ------------------ | ---------------------------------------------- |
| wrapped1155 | contract IERC20\[] | Array of outcome tokens wrapped to ERC20.      |
| data        | bytes\[]           | Array of token data used to create each ERC20. |

**Logic**

1. It will call <mark style="color:red;">`wrapped1155Factory.requireWrapped1155`</mark> to create an ERC20 token contract for each position. The new tokens addresses and data are saved in <mark style="color:red;">`Proposal`</mark> contract.

### toString31

```solidity
function toString31(string value) internal pure returns (bytes32 encodedString)
```

_Encodes a short string (less than than 31 bytes long) as for storage as expected by Solidity. See_ [_https://github.com/gnosis/1155-to-20/pull/4#discussion\_r573630922_](https://github.com/gnosis/1155-to-20/pull/4#discussion_r573630922)_._

**Parameters**

| Name  | Type   | Description      |
| ----- | ------ | ---------------- |
| value | string | String to encode |

**Return Values**

| Name          | Type    | Description         |
| ------------- | ------- | ------------------- |
| encodedString | bytes32 | The encoded string. |

### allMarkets

```solidity
function allMarkets() external view returns (address[])
```

_Returns all the proposals created by this factory._

**Return Values**

| Name | Type       | Description                     |
| ---- | ---------- | ------------------------------- |
| \[0] | address\[] | The addresses of the proposals. |

### marketsCount

```solidity
function marketsCount() external view returns (uint256)
```

Returns the amount of proposals created by this factory.

**Return Values**

| Name | Type    | Description              |
| ---- | ------- | ------------------------ |
| \[0] | uint256 | The amount of proposals. |
