pragma solidity ^0.4.13;

contract ERC20Basic {
  function totalSupply() public view returns (uint256);
  function balanceOf(address who) public view returns (uint256);
  function transfer(address to, uint256 value) public returns (bool);
  event Transfer(address indexed from, address indexed to, uint256 value);
}

library SafeMath {

  /**
  * @dev Multiplies two numbers, throws on overflow.
  */
  function mul(uint256 a, uint256 b) internal pure returns (uint256) {
    if (a == 0) {
      return 0;
    }
    uint256 c = a * b;
    assert(c / a == b);
    return c;
  }

  /**
  * @dev Integer division of two numbers, truncating the quotient.
  */
  function div(uint256 a, uint256 b) internal pure returns (uint256) {
    // assert(b > 0); // Solidity automatically throws when dividing by 0
    uint256 c = a / b;
    // assert(a == b * c + a % b); // There is no case in which this doesn't hold
    return c;
  }

  /**
  * @dev Substracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
  */
  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    assert(b <= a);
    return a - b;
  }

  /**
  * @dev Adds two numbers, throws on overflow.
  */
  function add(uint256 a, uint256 b) internal pure returns (uint256) {
    uint256 c = a + b;
    assert(c >= a);
    return c;
  }
}

contract ERC20 is ERC20Basic {
  function allowance(address owner, address spender) public view returns (uint256);
  function transferFrom(address from, address to, uint256 value) public returns (bool);
  function approve(address spender, uint256 value) public returns (bool);
  event Approval(address indexed owner, address indexed spender, uint256 value);
}

contract BasicToken is ERC20Basic {
  using SafeMath for uint256;

  mapping(address => uint256) balances;

  uint256 totalSupply_;

  /**
  * @dev total number of tokens in existence
  */
  function totalSupply() public view returns (uint256) {
    return totalSupply_;
  }

  /**
  * @dev transfer token for a specified address
  * @param _to The address to transfer to.
  * @param _value The amount to be transferred.
  */
  function transfer(address _to, uint256 _value) public returns (bool) {
    require(_to != address(0));
    require(_value <= balances[msg.sender]);

    // SafeMath.sub will throw if there is not enough balance.
    balances[msg.sender] = balances[msg.sender].sub(_value);
    balances[_to] = balances[_to].add(_value);
    Transfer(msg.sender, _to, _value);
    return true;
  }

  /**
  * @dev Gets the balance of the specified address.
  * @param _owner The address to query the the balance of.
  * @return An uint256 representing the amount owned by the passed address.
  */
  function balanceOf(address _owner) public view returns (uint256 balance) {
    return balances[_owner];
  }

}

contract StandardToken is ERC20, BasicToken {

  mapping (address => mapping (address => uint256)) internal allowed;


  /**
   * @dev Transfer tokens from one address to another
   * @param _from address The address which you want to send tokens from
   * @param _to address The address which you want to transfer to
   * @param _value uint256 the amount of tokens to be transferred
   */
  function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
    require(_to != address(0));
    require(_value <= balances[_from]);
    require(_value <= allowed[_from][msg.sender]);

    balances[_from] = balances[_from].sub(_value);
    balances[_to] = balances[_to].add(_value);
    allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
    Transfer(_from, _to, _value);
    return true;
  }

  /**
   * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
   *
   * Beware that changing an allowance with this method brings the risk that someone may use both the old
   * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
   * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
   * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
   * @param _spender The address which will spend the funds.
   * @param _value The amount of tokens to be spent.
   */
  function approve(address _spender, uint256 _value) public returns (bool) {
    allowed[msg.sender][_spender] = _value;
    Approval(msg.sender, _spender, _value);
    return true;
  }

  /**
   * @dev Function to check the amount of tokens that an owner allowed to a spender.
   * @param _owner address The address which owns the funds.
   * @param _spender address The address which will spend the funds.
   * @return A uint256 specifying the amount of tokens still available for the spender.
   */
  function allowance(address _owner, address _spender) public view returns (uint256) {
    return allowed[_owner][_spender];
  }

  /**
   * @dev Increase the amount of tokens that an owner allowed to a spender.
   *
   * approve should be called when allowed[_spender] == 0. To increment
   * allowed value is better to use this function to avoid 2 calls (and wait until
   * the first transaction is mined)
   * From MonolithDAO Token.sol
   * @param _spender The address which will spend the funds.
   * @param _addedValue The amount of tokens to increase the allowance by.
   */
  function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
    allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
    Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
    return true;
  }

  /**
   * @dev Decrease the amount of tokens that an owner allowed to a spender.
   *
   * approve should be called when allowed[_spender] == 0. To decrement
   * allowed value is better to use this function to avoid 2 calls (and wait until
   * the first transaction is mined)
   * From MonolithDAO Token.sol
   * @param _spender The address which will spend the funds.
   * @param _subtractedValue The amount of tokens to decrease the allowance by.
   */
  function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
    uint oldValue = allowed[msg.sender][_spender];
    if (_subtractedValue > oldValue) {
      allowed[msg.sender][_spender] = 0;
    } else {
      allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
    }
    Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
    return true;
  }

}

contract Fysical is StandardToken {
    using SafeMath for uint256;

    // To increase consistency and reduce the opportunity for human error, the '*sById' mappings, '*Count' values,
    // 'get*ById' function declarations/implementations, and 'create*' function declarations/implementations have been
    // programmatically-generated based on the each struct's name, member types/names, and the comments sharing a line
    // with a member.
    //
    // This programmatic generation builds 'require' function calls based on the following rules:
    //      - 'string' values must have length > 0
    //      - 'bytes' and uint256[] values may have any length
    //      - 'uint256' values representing a quantity must be > 0 (identifiers and Ethereum block numbers do not represent a quantity)
    //
    // The implementation of 'createProposal' contains one operation not found in the other programmatically-generated
    // 'create*' functions, a call to 'transferTokensToEscrow'.
    //
    // None of the other members or functions have been programmatically generated.

    // See https://en.wikipedia.org/wiki/Uniform_Resource_Identifier.
    // The risk of preventing support for a future addition to the URI syntax outweighs the benefit of validating URI
    // values within this immutable smart contract, so readers of Uri values should expect values that do not conform
    // to the formal syntax of a URI.
    struct Uri {
        string value;
    }

    // A set of URIs may describe multiple methods to access a particular resource.
    struct UriSet {
        uint256[] uniqueUriIdsSortedAscending;    // each value must be key in 'urisById'
    }

    // See https://en.wikipedia.org/wiki/Checksum#Algorithms. The description of the algorithm referred to by each URI
    // in the set should give a reader enough information to interpret the 'value' member of a 'Checksum' object
    // referring to this algorithm object.
    struct ChecksumAlgorithm {
        uint256 descriptionUriSetId;    // must be key in 'uriSetsById'
    }

    // See https://en.wikipedia.org/wiki/Checksum. The 'resourceByteCount' indicates the number of bytes contained in
    // the resource. Though this is not strictly part of most common Checksum algorithms, its validation may also be
    // useful. The 'value' field should contain the expected output of passing the resource content to the checksum
    // algorithm.
    struct Checksum {
        uint256 algorithmId; // must be key in 'checksumAlgorithmsById'
        uint256 resourceByteCount;
        bytes value;
    }

    // See https://en.wikipedia.org/wiki/Encryption. The description of the algorithm referred to by each URI
    // in the set should give a reader enough information to access the content of an encrypted resource. The algorithm
    // may be a symmetric encryption algorithm or an asymmetric encryption algorithm
    struct EncryptionAlgorithm {
        uint256 descriptionUriSetId;    // must be key in 'uriSetsById'
    }

    // For each resource, an Ethereum account may describe a checksum for the encrypted content of a resource and a
    // checksum for the decrypted content of a resource. When the resource is encrypted with a null encryption
    // algorithm, the resource is effectively unencrypted, so these two checksums should be identical
    // (See https://en.wikipedia.org/wiki/Null_encryption).
    struct ChecksumPair {
        uint256 encryptedChecksumId; // must be key in 'checksumsById'
        uint256 decryptedChecksumId; // must be key in 'checksumsById'
    }

    // A 'Resource' is content accessible with each URI referenced in the 'uriSetId'. This content should be
    // encrypted with the algorithm described by the 'EncryptionAlgorithm' referenced in 'encryptionAlgorithmId'. Each
    // resource referenced in 'metaResourceSetId' should describe the decrypted content in some way.
    //
    // For example, if the decrypted content conforms to a Protocol Buffers schema, the corresponding proto definition
    // file should be included in the meta-resources. Likewise, that proto definition resource should refer to a
    // resource like https://en.wikipedia.org/wiki/Protocol_Buffers among its meta-resources.
    struct Resource {
        uint256 uriSetId;                // must be key in 'uriSetsById'
        uint256 encryptionAlgorithmId;   // must be key in 'encryptionAlgorithmsById'
        uint256 metaResourceSetId;       // must be key in 'resourceSetsById'
    }

    // See https://en.wikipedia.org/wiki/Public-key_cryptography. This value should be the public key used in an
    // asymmetric encryption operation. It should be useful for encrypting an resource destined for the holder of the
    // corresponding private key or for decrypting a resource encrypted with the corresponding private key.
    struct PublicKey {
        bytes value;
    }

    // A 'ResourceSet' groups together resources that may be part of a trade proposal involving Fysical tokens. The
    // creator of a 'ResourceSet' must include a public key for use in the encryption operations of creating and
    // accepting a trade proposal. The creator must also specify the encryption algorithm a proposal creator should
    // use along with this resource set creator's public key. Just as a single resource may have meta-resources
    // describing the content of a resource, a 'ResourceSet' may have resources describing the whole resource set.
    //
    // Creators should be careful to not include so many resources that an Ethereum transaction to accept a proposal
    // might run out of gas while storing the corresponding encrypted decryption keys.
    //
    // While developing reasonable filters for un-useful data in this collection, developers should choose a practical
    // maximum depth of traversal through the meta-resources, since an infinite loop is possible.
    struct ResourceSet {
        address creator;
        uint256 creatorPublicKeyId;                     // must be key in 'publicKeysById'
        uint256 proposalEncryptionAlgorithmId;          // must be key in 'encryptionAlgorithmsById'
        uint256[] uniqueResourceIdsSortedAscending;     // each value must be key in 'resourcesById'
        uint256 metaResourceSetId;                      // must be key in 'resourceSetsById'
    }

    // The creator of a trade proposal may include arbitrary content to be considered part of the agreement the
    // resource set is accepting. This may be useful for license agreements to be enforced within a jurisdiction
    // governing the trade partners. The content available through each URI in the set should be encrypted first with
    // the public key of a resource set's creator and then with the private key of a proposal's creator.
    struct Agreement {
        uint256 uriSetId;           // must be key in 'uriSetsById'
        uint256 checksumPairId;     // must be key in 'checksumPairsById'
    }

    // Many agreements may be grouped together in an 'AgreementSet'
    struct AgreementSet {
        uint256[] uniqueAgreementIdsSortedAscending; // each value must be key in 'agreementsById'
    }

    // A 'TokenTransfer' describes a transfer of tokens to occur between two Ethereum accounts.
    struct TokenTransfer {
        address source;
        address destination;
        uint256 tokenCount;
    }

    // Many token transfers may be grouped together in a "TokenTransferSet'
    struct TokenTransferSet {
        uint256[] uniqueTokenTransferIdsSortedAscending; // each value must be key in 'tokenTransfersById'
    }

    // A 'Proposal' describes the conditions for the atomic exchange of Fysical tokens and a keys to decrypt resources
    // in a resource set. The creator must specify the asymmetric encryption algorithm for use when accepting the
    // proposal, along with this creator's public key. The creator may specify arbitrary agreements that should be
    // considered a condition of the trade.
    //
    // During the execution of 'createProposal', the count of tokens specified in each token transfer will be transfered
    // from the specified source account to the account with the Ethereum address of 0. When the proposal state changes
    // to a final state, these tokens will be returned to the source accounts or tranfserred to the destination account.
    //
    // By including a 'minimumBlockNumberForWithdrawal' value later than the current Ethereum block, the proposal
    // creator can give the resource set creator a rough sense of how long the proposal will remain certainly
    // acceptable. This is particularly useful because the execution of an Ethereum transaction to accept a proposal
    // exposes the encrypted decryption keys to the Ethereum network regardless of whether the transaction succeeds.
    // Within the time frame that a proposal acceptance transaction will certainly succeed, the resource creator need
    // not be concerned with the possibility that an acceptance transaction might execute after a proposal withdrawal
    // submitted to the Ethereum network at approximately the same time.
    struct Proposal {
        uint256 minimumBlockNumberForWithdrawal;
        address creator;
        uint256 creatorPublicKeyId;                 // must be key in 'publicKeysById'
        uint256 acceptanceEncryptionAlgorithmId;    // must be key in 'encryptionAlgorithmsById'
        uint256 resourceSetId;                      // must be key in 'resourceSetsById'
        uint256 agreementSetId;                     // must be key in 'agreementSetsById'
        uint256 tokenTransferSetId;                 // must be key in 'tokenTransferSetsById'
    }

    // When created, the proposal is in the 'Pending' state. All other states are final states, so a proposal may change
    // state exactly one time based on a call to 'withdrawProposal', 'acceptProposal', or 'rejectProposal'.
    enum ProposalState {
        Pending,
        WithdrawnByCreator,
        RejectedByResourceSetCreator,
        AcceptedByResourceSetCreator
    }

    // solium would warn "Constant name 'name' doesn't follow the UPPER_CASE notation", but this public constant is
    // recommended by https://theethereum.wiki/w/index.php/ERC20_Token_Standard, so we'll disable warnings for the line.
    //
    /* solium-disable-next-line */
    string public constant name = "Fysical";

    // solium would warn "Constant name 'symbol' doesn't follow the UPPER_CASE notation", but this public constant is
    // recommended by https://theethereum.wiki/w/index.php/ERC20_Token_Standard, so we'll disable warnings for the line.
    //
    /* solium-disable-next-line */
    string public constant symbol = "FYS";

    // solium would warn "Constant name 'decimals' doesn't follow the UPPER_CASE notation", but this public constant is
    // recommended by https://theethereum.wiki/w/index.php/ERC20_Token_Standard, so we'll disable warnings for the line.
    //
    /* solium-disable-next-line */
    uint8 public constant decimals = 9;

    uint256 public constant ONE_BILLION = 1000000000;
    uint256 public constant ONE_QUINTILLION = 1000000000000000000;

    // See https://en.wikipedia.org/wiki/9,223,372,036,854,775,807
    uint256 public constant MAXIMUM_64_BIT_SIGNED_INTEGER_VALUE = 9223372036854775807;

    uint256 public constant EMPTY_PUBLIC_KEY_ID = 0;
    uint256 public constant NULL_ENCRYPTION_ALGORITHM_DESCRIPTION_URI_ID = 0;
    uint256 public constant NULL_ENCRYPTION_ALGORITHM_DESCRIPTION_URI_SET_ID = 0;
    uint256 public constant NULL_ENCRYPTION_ALGORITHM_ID = 0;
    uint256 public constant EMPTY_RESOURCE_SET_ID = 0;

    mapping(uint256 => Uri) internal urisById;
    uint256 internal uriCount = 0;

    mapping(uint256 => UriSet) internal uriSetsById;
    uint256 internal uriSetCount = 0;

    mapping(uint256 => ChecksumAlgorithm) internal checksumAlgorithmsById;
    uint256 internal checksumAlgorithmCount = 0;

    mapping(uint256 => Checksum) internal checksumsById;
    uint256 internal checksumCount = 0;

    mapping(uint256 => EncryptionAlgorithm) internal encryptionAlgorithmsById;
    uint256 internal encryptionAlgorithmCount = 0;

    mapping(uint256 => ChecksumPair) internal checksumPairsById;
    uint256 internal checksumPairCount = 0;

    mapping(uint256 => Resource) internal resourcesById;
    uint256 internal resourceCount = 0;

    mapping(uint256 => PublicKey) internal publicKeysById;
    uint256 internal publicKeyCount = 0;

    mapping(uint256 => ResourceSet) internal resourceSetsById;
    uint256 internal resourceSetCount = 0;

    mapping(uint256 => Agreement) internal agreementsById;
    uint256 internal agreementCount = 0;

    mapping(uint256 => AgreementSet) internal agreementSetsById;
    uint256 internal agreementSetCount = 0;

    mapping(uint256 => TokenTransfer) internal tokenTransfersById;
    uint256 internal tokenTransferCount = 0;

    mapping(uint256 => TokenTransferSet) internal tokenTransferSetsById;
    uint256 internal tokenTransferSetCount = 0;

    mapping(uint256 => Proposal) internal proposalsById;
    uint256 internal proposalCount = 0;

    mapping(uint256 => ProposalState) internal statesByProposalId;

    mapping(uint256 => mapping(uint256 => bytes)) internal encryptedDecryptionKeysByProposalIdAndResourceId;

    mapping(address => mapping(uint256 => bool)) internal checksumPairAssignmentsByCreatorAndResourceId;

    mapping(address => mapping(uint256 => uint256)) internal checksumPairIdsByCreatorAndResourceId;

    function Fysical() public {
        assert(ProposalState(0) == ProposalState.Pending);

        // The total number of Fysical tokens is intended to be one billion, with the ability to express values with
        // nine decimals places of precision. The token values passed in ERC20 functions and operations involving
        // TokenTransfer operations must be counts of nano-Fysical tokens (one billionth of one Fysical token).
        //
        // See the initialization of the total supply in https://theethereum.wiki/w/index.php/ERC20_Token_Standard.

        assert(0 < ONE_BILLION);
        assert(0 < ONE_QUINTILLION);
        assert(MAXIMUM_64_BIT_SIGNED_INTEGER_VALUE > ONE_BILLION);
        assert(MAXIMUM_64_BIT_SIGNED_INTEGER_VALUE > ONE_QUINTILLION);
        assert(ONE_BILLION == uint256(10)**decimals);
        assert(ONE_QUINTILLION == ONE_BILLION.mul(ONE_BILLION));

        totalSupply_ = ONE_QUINTILLION;

        balances[msg.sender] = totalSupply_;

        // From "https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md#transfer-1" on 2018-02-08 (commit cea1db05a3444870132ec3cb7dd78a244cba1805):
        //  "A token contract which creates new tokens SHOULD trigger a Transfer event with the _from address set to 0x0 when tokens are created."
        Transfer(0x0, msg.sender, balances[msg.sender]);

        // This mimics the behavior of the 'createPublicKey' external function.
        assert(EMPTY_PUBLIC_KEY_ID == publicKeyCount);
        publicKeysById[EMPTY_PUBLIC_KEY_ID] = PublicKey(new bytes(0));
        publicKeyCount = publicKeyCount.add(1);
        assert(1 == publicKeyCount);

        // This mimics the behavior of the 'createUri' external function.
        assert(NULL_ENCRYPTION_ALGORITHM_DESCRIPTION_URI_ID == uriCount);
        urisById[NULL_ENCRYPTION_ALGORITHM_DESCRIPTION_URI_ID] = Uri("https://en.wikipedia.org/wiki/Null_encryption");
        uriCount = uriCount.add(1);
        assert(1 == uriCount);

        // This mimics the behavior of the 'createUriSet' external function.
        assert(NULL_ENCRYPTION_ALGORITHM_DESCRIPTION_URI_SET_ID == uriSetCount);
        uint256[] memory uniqueIdsSortedAscending = new uint256[](1);
        uniqueIdsSortedAscending[0] = NULL_ENCRYPTION_ALGORITHM_DESCRIPTION_URI_ID;
        validateIdSet(uniqueIdsSortedAscending, uriCount);
        uriSetsById[NULL_ENCRYPTION_ALGORITHM_DESCRIPTION_URI_SET_ID] = UriSet(uniqueIdsSortedAscending);
        uriSetCount = uriSetCount.add(1);
        assert(1 == uriSetCount);

        // This mimics the behavior of the 'createEncryptionAlgorithm' external function.
        assert(NULL_ENCRYPTION_ALGORITHM_ID == encryptionAlgorithmCount);
        encryptionAlgorithmsById[NULL_ENCRYPTION_ALGORITHM_ID] = EncryptionAlgorithm(NULL_ENCRYPTION_ALGORITHM_DESCRIPTION_URI_SET_ID);
        encryptionAlgorithmCount = encryptionAlgorithmCount.add(1);
        assert(1 == encryptionAlgorithmCount);

        // This mimics the behavior of the 'createResourceSet' external function, but allows for a self-reference in
        // the assignment of the 'metaResourceSetId' member, which the function would prohibit.
        assert(EMPTY_RESOURCE_SET_ID == resourceSetCount);
        resourceSetsById[EMPTY_RESOURCE_SET_ID] = ResourceSet(
            msg.sender,
            EMPTY_PUBLIC_KEY_ID,
            NULL_ENCRYPTION_ALGORITHM_ID,
            new uint256[](0),
            EMPTY_RESOURCE_SET_ID
        );
        resourceSetCount = resourceSetCount.add(1);
        assert(1 == resourceSetCount);
    }

    function getUriCount() external view returns (uint256) {
        return uriCount;
    }

    function getUriById(uint256 id) external view returns (string) {
        require(id < uriCount);

        Uri memory object = urisById[id];
        return object.value;
    }

    function getUriSetCount() external view returns (uint256) {
        return uriSetCount;
    }

    function getUriSetById(uint256 id) external view returns (uint256[]) {
        require(id < uriSetCount);

        UriSet memory object = uriSetsById[id];
        return object.uniqueUriIdsSortedAscending;
    }

    function getChecksumAlgorithmCount() external view returns (uint256) {
        return checksumAlgorithmCount;
    }

    function getChecksumAlgorithmById(uint256 id) external view returns (uint256) {
        require(id < checksumAlgorithmCount);

        ChecksumAlgorithm memory object = checksumAlgorithmsById[id];
        return object.descriptionUriSetId;
    }

    function getChecksumCount() external view returns (uint256) {
        return checksumCount;
    }

    function getChecksumById(uint256 id) external view returns (uint256, uint256, bytes) {
        require(id < checksumCount);

        Checksum memory object = checksumsById[id];
        return (object.algorithmId, object.resourceByteCount, object.value);
    }

    function getEncryptionAlgorithmCount() external view returns (uint256) {
        return encryptionAlgorithmCount;
    }

    function getEncryptionAlgorithmById(uint256 id) external view returns (uint256) {
        require(id < encryptionAlgorithmCount);

        EncryptionAlgorithm memory object = encryptionAlgorithmsById[id];
        return object.descriptionUriSetId;
    }

    function getChecksumPairCount() external view returns (uint256) {
        return checksumPairCount;
    }

    function getChecksumPairById(uint256 id) external view returns (uint256, uint256) {
        require(id < checksumPairCount);

        ChecksumPair memory object = checksumPairsById[id];
        return (object.encryptedChecksumId, object.decryptedChecksumId);
    }

    function getResourceCount() external view returns (uint256) {
        return resourceCount;
    }

    function getResourceById(uint256 id) external view returns (uint256, uint256, uint256) {
        require(id < resourceCount);

        Resource memory object = resourcesById[id];
        return (object.uriSetId, object.encryptionAlgorithmId, object.metaResourceSetId);
    }

    function getPublicKeyCount() external view returns (uint256) {
        return publicKeyCount;
    }

    function getPublicKeyById(uint256 id) external view returns (bytes) {
        require(id < publicKeyCount);

        PublicKey memory object = publicKeysById[id];
        return object.value;
    }

    function getResourceSetCount() external view returns (uint256) {
        return resourceSetCount;
    }

    function getResourceSetById(uint256 id) external view returns (address, uint256, uint256, uint256[], uint256) {
        require(id < resourceSetCount);

        ResourceSet memory object = resourceSetsById[id];
        return (object.creator, object.creatorPublicKeyId, object.proposalEncryptionAlgorithmId, object.uniqueResourceIdsSortedAscending, object.metaResourceSetId);
    }

    function getAgreementCount() external view returns (uint256) {
        return agreementCount;
    }

    function getAgreementById(uint256 id) external view returns (uint256, uint256) {
        require(id < agreementCount);

        Agreement memory object = agreementsById[id];
        return (object.uriSetId, object.checksumPairId);
    }

    function getAgreementSetCount() external view returns (uint256) {
        return agreementSetCount;
    }

    function getAgreementSetById(uint256 id) external view returns (uint256[]) {
        require(id < agreementSetCount);

        AgreementSet memory object = agreementSetsById[id];
        return object.uniqueAgreementIdsSortedAscending;
    }

    function getTokenTransferCount() external view returns (uint256) {
        return tokenTransferCount;
    }

    function getTokenTransferById(uint256 id) external view returns (address, address, uint256) {
        require(id < tokenTransferCount);

        TokenTransfer memory object = tokenTransfersById[id];
        return (object.source, object.destination, object.tokenCount);
    }

    function getTokenTransferSetCount() external view returns (uint256) {
        return tokenTransferSetCount;
    }

    function getTokenTransferSetById(uint256 id) external view returns (uint256[]) {
        require(id < tokenTransferSetCount);

        TokenTransferSet memory object = tokenTransferSetsById[id];
        return object.uniqueTokenTransferIdsSortedAscending;
    }

    function getProposalCount() external view returns (uint256) {
        return proposalCount;
    }

    function getProposalById(uint256 id) external view returns (uint256, address, uint256, uint256, uint256, uint256, uint256) {
        require(id < proposalCount);

        Proposal memory object = proposalsById[id];
        return (object.minimumBlockNumberForWithdrawal, object.creator, object.creatorPublicKeyId, object.acceptanceEncryptionAlgorithmId, object.resourceSetId, object.agreementSetId, object.tokenTransferSetId);
    }

    function getStateByProposalId(uint256 proposalId) external view returns (ProposalState) {
        require(proposalId < proposalCount);

        return statesByProposalId[proposalId];
    }

    // Check to see if an Ethereum account has assigned a checksum for a particular resource.
    function hasAddressAssignedResourceChecksumPair(address address_, uint256 resourceId) external view returns (bool) {
        require(resourceId < resourceCount);

        return checksumPairAssignmentsByCreatorAndResourceId[address_][resourceId];
    }

    // Retrieve the checksum assigned assigned to particular resource
    function getChecksumPairIdByAssignerAndResourceId(address assigner, uint256 resourceId) external view returns (uint256) {
        require(resourceId < resourceCount);
        require(checksumPairAssignmentsByCreatorAndResourceId[assigner][resourceId]);

        return checksumPairIdsByCreatorAndResourceId[assigner][resourceId];
    }

    // Retrieve the encrypted key to decrypt a resource referenced by an accepted proposal.
    function getEncryptedResourceDecryptionKey(uint256 proposalId, uint256 resourceId) external view returns (bytes) {
        require(proposalId < proposalCount);
        require(ProposalState.AcceptedByResourceSetCreator == statesByProposalId[proposalId]);
        require(resourceId < resourceCount);

        uint256[] memory validResourceIds = resourceSetsById[proposalsById[proposalId].resourceSetId].uniqueResourceIdsSortedAscending;
        require(0 < validResourceIds.length);

        if (1 == validResourceIds.length) {
            require(resourceId == validResourceIds[0]);

        } else {
            uint256 lowIndex = 0;
            uint256 highIndex = validResourceIds.length.sub(1);
            uint256 middleIndex = lowIndex.add(highIndex).div(2);

            while (resourceId != validResourceIds[middleIndex]) {
                require(lowIndex <= highIndex);

                if (validResourceIds[middleIndex] < resourceId) {
                    lowIndex = middleIndex.add(1);
                } else {
                    highIndex = middleIndex.sub(1);
                }

                middleIndex = lowIndex.add(highIndex).div(2);
            }
        }

        return encryptedDecryptionKeysByProposalIdAndResourceId[proposalId][resourceId];
    }

    function createUri(
        string value
    ) external returns (uint256)
    {
        require(0 < bytes(value).length);

        uint256 id = uriCount;
        uriCount = id.add(1);
        urisById[id] = Uri(
            value
        );

        return id;
    }

    function createUriSet(
        uint256[] uniqueUriIdsSortedAscending
    ) external returns (uint256)
    {
        validateIdSet(uniqueUriIdsSortedAscending, uriCount);

        uint256 id = uriSetCount;
        uriSetCount = id.add(1);
        uriSetsById[id] = UriSet(
            uniqueUriIdsSortedAscending
        );

        return id;
    }

    function createChecksumAlgorithm(
        uint256 descriptionUriSetId
    ) external returns (uint256)
    {
        require(descriptionUriSetId < uriSetCount);

        uint256 id = checksumAlgorithmCount;
        checksumAlgorithmCount = id.add(1);
        checksumAlgorithmsById[id] = ChecksumAlgorithm(
            descriptionUriSetId
        );

        return id;
    }

    function createChecksum(
        uint256 algorithmId,
        uint256 resourceByteCount,
        bytes value
    ) external returns (uint256)
    {
        require(algorithmId < checksumAlgorithmCount);
        require(0 < resourceByteCount);

        uint256 id = checksumCount;
        checksumCount = id.add(1);
        checksumsById[id] = Checksum(
            algorithmId,
            resourceByteCount,
            value
        );

        return id;
    }

    function createEncryptionAlgorithm(
        uint256 descriptionUriSetId
    ) external returns (uint256)
    {
        require(descriptionUriSetId < uriSetCount);

        uint256 id = encryptionAlgorithmCount;
        encryptionAlgorithmCount = id.add(1);
        encryptionAlgorithmsById[id] = EncryptionAlgorithm(
            descriptionUriSetId
        );

        return id;
    }

    function createChecksumPair(
        uint256 encryptedChecksumId,
        uint256 decryptedChecksumId
    ) external returns (uint256)
    {
        require(encryptedChecksumId < checksumCount);
        require(decryptedChecksumId < checksumCount);

        uint256 id = checksumPairCount;
        checksumPairCount = id.add(1);
        checksumPairsById[id] = ChecksumPair(
            encryptedChecksumId,
            decryptedChecksumId
        );

        return id;
    }

    function createResource(
        uint256 uriSetId,
        uint256 encryptionAlgorithmId,
        uint256 metaResourceSetId
    ) external returns (uint256)
    {
        require(uriSetId < uriSetCount);
        require(encryptionAlgorithmId < encryptionAlgorithmCount);
        require(metaResourceSetId < resourceSetCount);

        uint256 id = resourceCount;
        resourceCount = id.add(1);
        resourcesById[id] = Resource(
            uriSetId,
            encryptionAlgorithmId,
            metaResourceSetId
        );

        return id;
    }

    function createPublicKey(
        bytes value
    ) external returns (uint256)
    {
        uint256 id = publicKeyCount;
        publicKeyCount = id.add(1);
        publicKeysById[id] = PublicKey(
            value
        );

        return id;
    }

    function createResourceSet(
        uint256 creatorPublicKeyId,
        uint256 proposalEncryptionAlgorithmId,
        uint256[] uniqueResourceIdsSortedAscending,
        uint256 metaResourceSetId
    ) external returns (uint256)
    {
        require(creatorPublicKeyId < publicKeyCount);
        require(proposalEncryptionAlgorithmId < encryptionAlgorithmCount);
        validateIdSet(uniqueResourceIdsSortedAscending, resourceCount);
        require(metaResourceSetId < resourceSetCount);

        uint256 id = resourceSetCount;
        resourceSetCount = id.add(1);
        resourceSetsById[id] = ResourceSet(
            msg.sender,
            creatorPublicKeyId,
            proposalEncryptionAlgorithmId,
            uniqueResourceIdsSortedAscending,
            metaResourceSetId
        );

        return id;
    }

    function createAgreement(
        uint256 uriSetId,
        uint256 checksumPairId
    ) external returns (uint256)
    {
        require(uriSetId < uriSetCount);
        require(checksumPairId < checksumPairCount);

        uint256 id = agreementCount;
        agreementCount = id.add(1);
        agreementsById[id] = Agreement(
            uriSetId,
            checksumPairId
        );

        return id;
    }

    function createAgreementSet(
        uint256[] uniqueAgreementIdsSortedAscending
    ) external returns (uint256)
    {
        validateIdSet(uniqueAgreementIdsSortedAscending, agreementCount);

        uint256 id = agreementSetCount;
        agreementSetCount = id.add(1);
        agreementSetsById[id] = AgreementSet(
            uniqueAgreementIdsSortedAscending
        );

        return id;
    }

    function createTokenTransfer(
        address source,
        address destination,
        uint256 tokenCount
    ) external returns (uint256)
    {
        require(address(0) != source);
        require(address(0) != destination);
        require(0 < tokenCount);

        uint256 id = tokenTransferCount;
        tokenTransferCount = id.add(1);
        tokenTransfersById[id] = TokenTransfer(
            source,
            destination,
            tokenCount
        );

        return id;
    }

    function createTokenTransferSet(
        uint256[] uniqueTokenTransferIdsSortedAscending
    ) external returns (uint256)
    {
        validateIdSet(uniqueTokenTransferIdsSortedAscending, tokenTransferCount);

        uint256 id = tokenTransferSetCount;
        tokenTransferSetCount = id.add(1);
        tokenTransferSetsById[id] = TokenTransferSet(
            uniqueTokenTransferIdsSortedAscending
        );

        return id;
    }

    function createProposal(
        uint256 minimumBlockNumberForWithdrawal,
        uint256 creatorPublicKeyId,
        uint256 acceptanceEncryptionAlgorithmId,
        uint256 resourceSetId,
        uint256 agreementSetId,
        uint256 tokenTransferSetId
    ) external returns (uint256)
    {
        require(creatorPublicKeyId < publicKeyCount);
        require(acceptanceEncryptionAlgorithmId < encryptionAlgorithmCount);
        require(resourceSetId < resourceSetCount);
        require(agreementSetId < agreementSetCount);
        require(tokenTransferSetId < tokenTransferSetCount);

        transferTokensToEscrow(msg.sender, tokenTransferSetId);

        uint256 id = proposalCount;
        proposalCount = id.add(1);
        proposalsById[id] = Proposal(
            minimumBlockNumberForWithdrawal,
            msg.sender,
            creatorPublicKeyId,
            acceptanceEncryptionAlgorithmId,
            resourceSetId,
            agreementSetId,
            tokenTransferSetId
        );

        return id;
    }

    // Each Ethereum account may assign a 'ChecksumPair' to a resource exactly once. This ensures that each claim that a
    // checksum should match a resource is attached to a particular authority. This operation is not bound to the
    // creation of the resource because the resource's creator may not know the checksum when creating the resource.
    function assignResourceChecksumPair(
        uint256 resourceId,
        uint256 checksumPairId
    ) external
    {
        require(resourceId < resourceCount);
        require(checksumPairId < checksumPairCount);
        require(false == checksumPairAssignmentsByCreatorAndResourceId[msg.sender][resourceId]);

        checksumPairIdsByCreatorAndResourceId[msg.sender][resourceId] = checksumPairId;
        checksumPairAssignmentsByCreatorAndResourceId[msg.sender][resourceId] = true;
    }

    // This function moves a proposal to a final state of `WithdrawnByCreator' and returns tokens to the sources
    // described by the proposal's transfers.
    function withdrawProposal(
        uint256 proposalId
    ) external
    {
        require(proposalId < proposalCount);
        require(ProposalState.Pending == statesByProposalId[proposalId]);

        Proposal memory proposal = proposalsById[proposalId];
        require(msg.sender == proposal.creator);
        require(block.number >= proposal.minimumBlockNumberForWithdrawal);

        returnTokensFromEscrow(proposal.creator, proposal.tokenTransferSetId);
        statesByProposalId[proposalId] = ProposalState.WithdrawnByCreator;
    }

    // This function moves a proposal to a final state of `RejectedByResourceSetCreator' and returns tokens to the sources
    // described by the proposal's transfers.
    function rejectProposal(
        uint256 proposalId
    ) external
    {
        require(proposalId < proposalCount);
        require(ProposalState.Pending == statesByProposalId[proposalId]);

        Proposal memory proposal = proposalsById[proposalId];
        require(msg.sender == resourceSetsById[proposal.resourceSetId].creator);

        returnTokensFromEscrow(proposal.creator, proposal.tokenTransferSetId);
        statesByProposalId[proposalId] = ProposalState.RejectedByResourceSetCreator;
    }

    // This function moves a proposal to a final state of `RejectedByResourceSetCreator' and sends tokens to the
    // destinations described by the proposal's transfers.
    //
    // The caller should encrypt each decryption key corresponding
    // to each resource in the proposal's resource set first with the public key of the proposal's creator and then with
    // the private key assoicated with the public key referenced in the resource set. The caller should concatenate
    // these encrypted values and pass the resulting byte array as 'concatenatedResourceDecryptionKeys'.
    // The length of each encrypted decryption key should be provided in the 'concatenatedResourceDecryptionKeyLengths'.
    // The index of each value in 'concatenatedResourceDecryptionKeyLengths' must correspond to an index in the resource
    // set referenced by the proposal.
    function acceptProposal(
        uint256 proposalId,
        bytes concatenatedResourceDecryptionKeys,
        uint256[] concatenatedResourceDecryptionKeyLengths
    ) external
    {
        require(proposalId < proposalCount);
        require(ProposalState.Pending == statesByProposalId[proposalId]);

        Proposal memory proposal = proposalsById[proposalId];
        require(msg.sender == resourceSetsById[proposal.resourceSetId].creator);

        storeEncryptedDecryptionKeys(
            proposalId,
            concatenatedResourceDecryptionKeys,
            concatenatedResourceDecryptionKeyLengths
        );

        transferTokensFromEscrow(proposal.tokenTransferSetId);

        statesByProposalId[proposalId] = ProposalState.AcceptedByResourceSetCreator;
    }

    function validateIdSet(uint256[] uniqueIdsSortedAscending, uint256 idCount) private pure {
        if (0 < uniqueIdsSortedAscending.length) {

            uint256 id = uniqueIdsSortedAscending[0];
            require(id < idCount);

            uint256 previousId = id;
            for (uint256 index = 1; index < uniqueIdsSortedAscending.length; index = index.add(1)) {
                id = uniqueIdsSortedAscending[index];
                require(id < idCount);
                require(previousId < id);

                previousId = id;
            }
        }
    }

    function transferTokensToEscrow(address proposalCreator, uint256 tokenTransferSetId) private {
        assert(tokenTransferSetId < tokenTransferSetCount);
        assert(address(0) != proposalCreator);

        uint256[] memory tokenTransferIds = tokenTransferSetsById[tokenTransferSetId].uniqueTokenTransferIdsSortedAscending;
        for (uint256 index = 0; index < tokenTransferIds.length; index = index.add(1)) {
            uint256 tokenTransferId = tokenTransferIds[index];
            assert(tokenTransferId < tokenTransferCount);

            TokenTransfer memory tokenTransfer = tokenTransfersById[tokenTransferId];
            assert(0 < tokenTransfer.tokenCount);
            assert(address(0) != tokenTransfer.source);
            assert(address(0) != tokenTransfer.destination);

            require(tokenTransfer.tokenCount <= balances[tokenTransfer.source]);

            if (tokenTransfer.source != proposalCreator) {
                require(tokenTransfer.tokenCount <= allowed[tokenTransfer.source][proposalCreator]);

                allowed[tokenTransfer.source][proposalCreator] = allowed[tokenTransfer.source][proposalCreator].sub(tokenTransfer.tokenCount);
            }

            balances[tokenTransfer.source] = balances[tokenTransfer.source].sub(tokenTransfer.tokenCount);
            balances[address(0)] = balances[address(0)].add(tokenTransfer.tokenCount);

            Transfer(tokenTransfer.source, address(0), tokenTransfer.tokenCount);
        }
    }

    function returnTokensFromEscrow(address proposalCreator, uint256 tokenTransferSetId) private {
        assert(tokenTransferSetId < tokenTransferSetCount);
        assert(address(0) != proposalCreator);

        uint256[] memory tokenTransferIds = tokenTransferSetsById[tokenTransferSetId].uniqueTokenTransferIdsSortedAscending;
        for (uint256 index = 0; index < tokenTransferIds.length; index = index.add(1)) {
            uint256 tokenTransferId = tokenTransferIds[index];
            assert(tokenTransferId < tokenTransferCount);

            TokenTransfer memory tokenTransfer = tokenTransfersById[tokenTransferId];
            assert(0 < tokenTransfer.tokenCount);
            assert(address(0) != tokenTransfer.source);
            assert(address(0) != tokenTransfer.destination);
            assert(tokenTransfer.tokenCount <= balances[address(0)]);

            balances[tokenTransfer.source] = balances[tokenTransfer.source].add(tokenTransfer.tokenCount);
            balances[address(0)] = balances[address(0)].sub(tokenTransfer.tokenCount);

            Transfer(address(0), tokenTransfer.source, tokenTransfer.tokenCount);
        }
    }

    function transferTokensFromEscrow(uint256 tokenTransferSetId) private {
        assert(tokenTransferSetId < tokenTransferSetCount);

        uint256[] memory tokenTransferIds = tokenTransferSetsById[tokenTransferSetId].uniqueTokenTransferIdsSortedAscending;
        for (uint256 index = 0; index < tokenTransferIds.length; index = index.add(1)) {
            uint256 tokenTransferId = tokenTransferIds[index];
            assert(tokenTransferId < tokenTransferCount);

            TokenTransfer memory tokenTransfer = tokenTransfersById[tokenTransferId];
            assert(0 < tokenTransfer.tokenCount);
            assert(address(0) != tokenTransfer.source);
            assert(address(0) != tokenTransfer.destination);

            balances[address(0)] = balances[address(0)].sub(tokenTransfer.tokenCount);
            balances[tokenTransfer.destination] = balances[tokenTransfer.destination].add(tokenTransfer.tokenCount);
            Transfer(address(0), tokenTransfer.destination, tokenTransfer.tokenCount);
        }
    }

    function storeEncryptedDecryptionKeys(
        uint256 proposalId,
        bytes concatenatedEncryptedResourceDecryptionKeys,
        uint256[] encryptedResourceDecryptionKeyLengths
    ) private
    {
        assert(proposalId < proposalCount);

        uint256 resourceSetId = proposalsById[proposalId].resourceSetId;
        assert(resourceSetId < resourceSetCount);

        ResourceSet memory resourceSet = resourceSetsById[resourceSetId];
        require(resourceSet.uniqueResourceIdsSortedAscending.length == encryptedResourceDecryptionKeyLengths.length);

        uint256 concatenatedEncryptedResourceDecryptionKeysIndex = 0;
        for (uint256 resourceIndex = 0; resourceIndex < encryptedResourceDecryptionKeyLengths.length; resourceIndex = resourceIndex.add(1)) {
            bytes memory encryptedResourceDecryptionKey = new bytes(encryptedResourceDecryptionKeyLengths[resourceIndex]);
            require(0 < encryptedResourceDecryptionKey.length);

            for (uint256 encryptedResourceDecryptionKeyIndex = 0; encryptedResourceDecryptionKeyIndex < encryptedResourceDecryptionKey.length; encryptedResourceDecryptionKeyIndex = encryptedResourceDecryptionKeyIndex.add(1)) {
                require(concatenatedEncryptedResourceDecryptionKeysIndex < concatenatedEncryptedResourceDecryptionKeys.length);
                encryptedResourceDecryptionKey[encryptedResourceDecryptionKeyIndex] = concatenatedEncryptedResourceDecryptionKeys[concatenatedEncryptedResourceDecryptionKeysIndex];
                concatenatedEncryptedResourceDecryptionKeysIndex = concatenatedEncryptedResourceDecryptionKeysIndex.add(1);
            }

            uint256 resourceId = resourceSet.uniqueResourceIdsSortedAscending[resourceIndex];
            assert(resourceId < resourceCount);

            encryptedDecryptionKeysByProposalIdAndResourceId[proposalId][resourceId] = encryptedResourceDecryptionKey;
        }

        require(concatenatedEncryptedResourceDecryptionKeysIndex == concatenatedEncryptedResourceDecryptionKeys.length);
    }
}

{
  "compilationTarget": {
    "Fysical.sol": "Fysical"
  },
  "libraries": {},
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": []
}