Fabbriche conto terzi

Question

Fabbriche conto terzi

4

160 2019-03-11

Sono stateeffettuate ricerche su comepotrebbeessere realizzata unafabbrica a contratto a Michelson/Liquidity?

Perelaborare,in Solidity unafabbrica a contrattopotrebbeessere:

 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";
  }    
}

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

Questa è unapotentefunzionalitànello sviluppo di DAPP,poichéti consente di costruire una struttura orientata agli oggettiperiltuo DAPPin cui le richiestepossono crearenuovi contratti. È unmodello diprogettazioneben consolidato,quindi quale sarebbe l'equivalentenell'ecosistema Tezos?

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?

fonte
Rob

- Sembra che "CREATE_CONTRACT {storage"g;parametro 'p;code ...} `funzionerebbe,ma questogonfierà unpo 'la dimensione di un contratto,e sembra che dovrebbeesserci unmodopergestirlo congrazia comenell'istanziazione della classein stile Java di Solidity.
  
  It appears like `CREATE_CONTRACT { storage 'g ; parameter 'p ; code ... }` would work, but this will bloat the size of a contract a bit, and it feels like there should be a way to handle this gracefully like in Solidity's Java style class instantiation.
  - 0
  - 2019-03-11
  - Rob
- In caso contrario,un chiaroesempioin Michelson sarebbe carino.
  
  If not, a clean example in Michelson would be nice.
  - 0
  - 2019-03-11
  - Rob
- okfantastico,probabilmente una via d'uscita allora.
  
  ok cool, probably a ways out then.
  - 0
  - 2019-03-12
  - Rob
- Hoinserito un commento che ho cancellatoper convertirloin una risposta.Mi èmancatoiltuo commento aggiuntoin seguito.Lemie scuseper questo.
  
  I put a comment that I deleted to convert it into an answer. I missed your comment that was added afterwards. My apologies for this.
  - 1
  - 2019-03-12
  - FFF

2 risposta

voti

FFF · Answer 1 · 2019-03-12

3

2019-03-12

Nell'annuncio di SmartPy c'è una discussionemolto succinta https://medium.com/@SmartPy_io/introducing-smartpy-and-smartpy-io-d4013bee7d4e#15ee .

L'idea è di avere un contratto che contenga unabig_mape ognielemento dibig_map rappresenta un contratto.

Questonon è assolutamente limitato a SmartPyed è realizzabile direttamentein Michelson,Liquidity o Fi.

Questo argomento è apparso anche qui: Cos'èil contenitore BigMape perché èimportante?

fonte
FFF

Apprezzo latua rispostae non voglio che questo sianegativo,ma sento che dobbiamotrovare una soluzionepiù completa a questoproblema abrevetermineper rendereproduttivo lo sviluppo di DAPP.

I appreciate your response and don't want this to come across negative, but I feel we need to come up with a more comprehensive solution to this problem in the near term to make DAPP development productive.
- 0
- 2019-03-12
- Rob
Possofacilmente convenire che questanon è l'unicae ultima soluzione.

I can easily agree that this is not the final and only solution.
- 0
- 2019-03-12
- FFF
riferimento sottoper vedere unesempio di quello che stavopensando

reference below to see an example of what I was thinking
- 0
- 2019-03-14
- Rob

Rob · Answer 2 · 2019-03-14

2

2019-03-14

Ecco unesempio di un contratto chegestisce questoin liquidità. C'è la sfida unica di scriverefunzioni chepossono utilizzare solo chiamate diprocedure remote allafine della loroesecuzione:

 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);
};

Mi chiedo se questoporterà aendpoint come "ordine"e "ritiro",ovvero un ristorante.

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.

fonte
Rob