Contract Factories

Question

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?

Answer 1

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?

Answer 2

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.