Jtdylktuy

Has there been any research into how a contract factory might be made in Michelson/Liquidity?

To elaborate, in Solidity a contract factory might look like:

pragma solidity ^0.4.8;



contract Bakery {



  // index of created contracts



  address public contracts;



  // useful to know the row count in contracts index



  function getContractCount() 

    public

    constant

    returns(uint contractCount)

  {

    return contracts.length;

  }



  // deploy a new contract



  function newCookie()

    public

    returns(address newContract)

  {

    Cookie c = new Cookie();

    contracts.push(c);

    return c;

  }

}





contract Cookie {



  // suppose the deployed contract has a purpose



  function getFlavor()

    public

    constant

    returns (string flavor)

  {

    return "mmm ... chocolate chip";

  }    

}

(referenced from https://ethereum.stackexchange.com/questions/13415/deploy-contract-from-contract-in-solidity)

This is a powerful feature in DAPP development, as it allows you to build an object oriented structure for your DAPP where requests can create new contracts. It is a well established design pattern, so what would the equivalent be in the Tezos ecosystem?

There is a very succinct discussion in the announcement for SmartPy https://medium.com/@SmartPy_io/introducing-smartpy-and-smartpy-io-d4013bee7d4e#15ee.

The idea is to have a contract that holds a big_map and each element of the big_map represents a contract.

This is absolutely not restricted to SmartPy and it is directly doable in Michelson, Liquidity or Fi.

This subject also appeared here:
What is the BigMap container and why does it matter?

Here's an example of a contract handling this in liquidity. There's the unique challenge of writing functions that can only utilize remote procedure calls at the end of their execution:

type plus_storage = {

    count: nat,

    plus_owner: address,

  };



contract PlusOne = {

  type storage = plus_storage;

  let%init storage = (y: nat) => {

    count: y,

    plus_owner: Current.sender(),

  };

  let%entry main = (p: nat, storage) => {

    if (Current.sender() != storage.plus_owner) {

      failwith("invalid caller");

    };

    (, storage);

  }

};



type storage = {

  owner: key,

  pl: address,

};



let%init storage = (contract_owner: key) => {

  owner: contract_owner,

  pl: KT1111111111111111111111111111111111,

}



let%entry other = (param: nat, storage) => {

  let t: option(PlusOne.instance) = Contract.at(storage.pl);

  let t = switch(t) {

    | None => Current.failwith()

    | Some(inst) => inst

  };

  let op = Contract.call(

    ~dest=t,

    ~amount=0tz,

    ~entry=main,

    ~parameter=param);

  ([op], storage);

};



let%entry main = ((), storage) => {

  let manager = Crypto.hash_key(storage.owner);

  let delegate = Some(manager);

  let spendable = false;

  let amount = Current.amount();

  let init_value: nat = 0;



  let (c_op, c_addr) =

    Contract.create(

      ~manager,

      ~delegate,

      ~spendable,

      ~delegatable=false,

      ~amount,

      ~storage={count: init_value, plus_owner: Contract.address(Contract.self())},

      (contract PlusOne),

    );



  let storage = storage.pl = c_addr;

  ([c_op], storage);

};

It makes me wonder if this will lead to endpoints that are like "order" and "pickup", ie a restaurant.