Smart contract development proposal

[adrien-zinger]

We can be very complex for the development of a smart contract. We can put the high level complexity very hard to understand to have a simple low level execution.

What if massa makes this simple low level and high level both? 🥳

The first way you want to create a smart contract is simple. You have bytecode and you want to store it in the ledger. Let's make a simple zoo:

// little_zoo.ts
import { Animal } from "./animal_lib"
import { print } from "./massa";
import { JSON } from "json-as";

export function get_animal(name: string): string {
  if (name == "dog") {
    return JSON.stringify<Animal>({name: "dog", sound: "waf waf"});
  } else if (name == "cat") {
    return JSON.stringify<Animal>({name: "cat", sound: "miaw miaw"});
  }
  throw new Error("Animal unknown :-(");
}

// Makes the animal speak
export function speak(_animal: string): string {
  let animal = JSON.parse<Animal>(_animal);
  print(`${animal.name} says: ${animal.sound}!`);
  return "0";
}

In this case, there is no initialization needed, it's a very little zoo that doesn't know a lot of animals. Nevertheless you want to open your zoo to the world.
So you compile your code and you get a little_zoo.wasm.

1. Open massa client
2. Use this command line create_sc little_zoo.wasm
3. Wait for it, the operation CreateSC is send and the ledger will soon get a new entry with your little zoo,
4. Wait a second again... hop! and now you have the information that you just created a zoo at the address 288052e20ddd7fdac82efd65015a35d7f5d23bf0 (let's call it little_zoo_addr ok?)

More complex zoo

Now your zoo can grow and let the world add any animal. Not safe at all but whatever.

// world_wild_zoo.ts
import { JSON } from "json-as";
import { Animal } from "./animal_lib";
import { print, get, set } from "./massa";

export function get_animal(name: string): string {
  // the getter will look at the current smart contract DB
  // if there is a key "name"
  return JSON.stringify<Animal>({name, sound: get(name)});
}

export function add_animal(_animal: string): string {
  // You can limit who can ad using the get_context() ABI
  let animal = JSON.parse<Animal>(_animal);
  set(animal.name, animal.sound);
  return `Animal added (${animal.sound})`;
}

// Makes the animal speak
export function speak(_animal: string): string {
  let animal = JSON.parse<Animal>(_animal);
  print(`${animal.name} says: ${animal.sound}!`);
  return "0";
}

But there is no animal when you open the zoo and that's not a good news for kids 😞 so you have an idea 💡, you want to initialize the smart contract! And you can because the operation CreateSC accept also a constructor bytecode who will be executed with the same context of the executor, and will be able to set datas in the ledger. This constructor look like this:

// constructor.ts
import { set_for, SmartContract } from "./massa";
import { JSON } from "json-as";

// For a smart contract constructor, the main function take the created
// smart contract as input and contain address, bytecode and other usefull information
export function main(arg: string) {
    let sc = JSON.parse<SmartContract>(arg);
    // Set for know that he can write because the context in massa understand that you are the smart contract creator
    // and allow this operation:
    set_for(sc.address, "dog", "waf waf");
    set_for(sc.address, "cat", "miaw miaw");
    // Note: the same operation will fail if you try in another context, and in this context you can also
    // use the `set` function because the massa context know that you are in the constructor of your zoo
    return 0;
}

And now:

1. build your files (world_wild_zoo.wasm and constructor.wasm)
2. Open your massa_client
3. Use the command line create_sc world_wild_zoo.wasm constructor.wasm

Massa will first injects in the ledger your smart contract, and with the context of the smart contract, executes the constructor.wasm, so the constructor has all accesses to modify the smart contract DB and bytecode.

Very simple isn't it?

More complex zoo again

You want to create a zoo that someone can duplicate. In this example, we will just clone the walls of the zoo, and add the animal we want to in there. So you know someone made a private but adaptable zoo called "adaptzoo". It's the same zoo as world_wild_zoo but no one can add a new animal. Instead, he gave access to this function:

// in adaptzoo.ts
export function new_zoo(_animals: string): string {
  let animals = JSON.parse<Array<Animal>>(_animals);
  // create a new smart contract, it can be used:
  // - for creation with a new bytecode
  //    create_sc([0x48, 0x15, 0x16, 0x23, 0x42, ....])
  // - for a duplcation like in this case (equivalent to `let new_sc = duplicate()`)
  let new_zoo = create_sc(get_bytecode(self()));
  for (let i = 0; i < animals.length; ++i) {
    // Set for know that he can write because the context in massa understand that you are the smart contract creator
    set_for(new_zoo.address, animals[i].name, animals[i].sound);
  }
  return new_zoo.address;
}

This function allow any user to create a new zoo with the same function, obviously this example is very simple. You could create a zoo that allow only specifics users in specific cases to add animals and write a configurable list in the ledger.

So if Matteo want to create a zoo. He can simply write this code:

// matteo_zoo.ts
import { Animal } from "./animal_lib";
import { JSON } from "json-as";
import { print, call } from "./massa";

export function main() {
    let animals: Array<Animal> = [
        { name: "wolf", sound: "wof wof" },
        { name: "bird", sound: "tweet tweet" }
    ];
    let addr = call("animal_sc_address", "new_zoo", JSON.stringify(animals));
    print(`My new zoo is here: ${addr}`);
}

And then compile it, open his favorite massa client, and send an execution command exec matteo_zoo.wasm

Hard core level of the zoo

Now, we do know that we can create a zoo (smart contract zoo) with the sugar command create_sc, but we can also create a smart contract from another smart contract. You can so create a smart contract that contain another. Look at these line in the adaptzoo.ts:

  // create a new smart contract, it can be used:
  // - for creation with a new bytecode
  //    create_sc([0x48, 0x15, 0x16, 0x23, 0x42, ....])

That means that you're not obligated to use the create_sc command to create a smart contract, instead, you can put your smart contract in your constructor and use the command exec create_sc.wasm, even if it starting to become unreadable:

// create_sc.ts
import { create_sc } from "./massa"

export function main(_arg: string): i32 {
  // First you need to compile a smart contract and then extract with a tool an array of bytes,
  // then copy past your compiled binary byte's array in your file.
  create_sc([0x48, 0x15, 0x16, 0x23, 0x42, ....]);
  return 0;
}

[damip]

Very entertaining read, thank you @adrien-zinger ! 😄

So if I understand correctly:

• any bytecode can create new smart contracts using the create_sc ABI, and those SCs are immediately available upon return
• once a smart contract was created in an execution context, that context gains write access to the created smart contract until the end of that execution, allowing to initialize it directly with ABIs such as set_as
• an ad hoc CreateSC operation type simplifies creating a smart contract by taking the target SC bytecode as well as an initializer bytecode. This operation creates a new SC entry, then runs the initializer bytecode in the context of that SC.

I agree 100% with the first 2 points.

My question lies more into the necessity and redundancy of a low-level CreateSC operation.
Technically, we could expose a client command create_sc [target_bytecode_file] [initializer_bytecode_file] (same usage as the one you described) that itself generates an ExecuteSC operation with a bytecode that does the following:

new_sc = create_sc()
set_bytecode(new_sc, target_bytecode)
execute_bytecode(initializer_bytecode, context=new_sc)

where target_bytecode and initializer_bytecode are the contents of the two provided files, and are statically added as constants inside the generated bytecode.
Of course, community clients are allowed to extend this in the way they want, for example to programmatically create and link multiple SCs at the same time (something like an atomic docker compose for SCs) etc...
Note that I understand that the solution you propose does not prohibit using ExecuteSC to do this kind of things, it only adds CreateSC as an extra low-level shortcut for the special case of creating and initializing a single smart contract.

It mostly boils down to strategy. My vote was to follow Ethereum's design rules (https://eth.wiki/fundamentals/design-rationale):

• avoid feature redundancy (and therefore future maintenance) and maximize uniformity, simplicity and minimize specialization in low-level security-critical node code
• have the complexity wrapped in user-facing tools (e.g. the client) that can be easily contributed upon by the community, and that are used to conceal the complexity from the end user

That's my personal opinion. That being said, I am not an expert in any way and I am open to remarks and feedback :)

[adrien-zinger]

Just for the joke, Ethereum is a dinosaur 🦖 and we are the meteor ☄️!

May be this redundancy will be the little thing that makes the life of a massa smart contract developer a lot more exiting and simple. We continue to have a big flexibility to create a zoo... smart contract 🙂. In my point of view it also render evident the difference between a classical execution and a smart contract.

Another point, we cannot grind the binaries of the user to make just one. It's just my opinion but I feel it really unsafe and hard to do. However I'm agree with you, we could permit a smart contract developer to get a wasm file locally and insert bytes in his code with a nice tool. As a macro, it can replace some functions just before the compilation with a ✨ massa tool. (The compilation isn't done in massa, it's done by the compiler of AssemblyScript.)

The developer's road can be:

1. Develop the zoo smart contract
2. Compile it and get a zoo.wasm
3. Develop the execution:

//create_zoo.ts
import { set_for, call, include_bytes, create_sc, print } from "./massa";
import { JSON } from "json-as";
import { Animal } from "./animal_lib";

export function main(_arg: string) {
    // The method include_bytes of the massa library is replaced in compile time by a
    // constant containing bytes in the local file zoo.wasm
    let bytecode = include_bytes("./zoo.wasm");
    let addr = create_sc(bytecode).address;
    for (let i = 0; i < 50; ++i) {
        let animal = JSON.parse<Animal>(call("animal_randomizer", "generate", ""));
        set_for(addr, animal.name, animal.sound);
    }
    print(`Just created my new zoo: ${addr}`);
    return 0;
}

Note that we can call another smart contract in the smart contract creation and it looks very nice isn't it?

4. Replace macro with a massa tool massa build
5. Build the execution (we can obviously make just one command line or step 4 and 5)
6. Here we are, just run in massa client exe create_zoo.wasm and you're done, your smart contract zoo is on the massa network!

This method makes the CreateSC useless of course and I like this because it's also simple. As you want, I like both proposals and I'm always happy when I have choices!

[damip]

I like this idea very much !

We can also provide simple predefined execution scripts (or even tools that call them transparently) such as "just create a new smart contract with the following wasm bytecode and optionally the following csv data file". And advanced devs who want more complicated deployment scripts can write their own with only imagination for a limit :)