tact-lang / tact-by-example Goto Github PK

https://t.me/tondev_zh/15622

in the explainations: https://tact-by-example.org/06-contract-deploy-another , we have this:
When sending any message to a contract, we can attach its stateInit by specifying the code and data fields of the message. This will deploy the contract if it has not already been deployed. If the contract has already been deployed, these fields will be ignored.

Is that meaning it searches in all block chains to find the same address? or how it's doing? And if we send a value below the minimum requirement for storage, what happens?

The recent tact-docs refactoring tact-lang/tact-docs#81 broke links in tact-by-example

Gratitude to all those who contributed to the creation of Tact. I had a pleasant experience recently while reading the website. I was sitting by the beach, enjoying the comments that were elegantly presented in code. However, the absence of a light mode compelled me to return home. It appears that having both dark and light modes has become a standard feature for nearly every website.

Tons of changes after recompilation in the generated HTML files make it harder to review PRs in this repo, so these should be removed and added to .gitignore.

Maybe someone's already working on it or is it going to be planned?

I think it would be easier to read the documents if it goes to the page start when next example or prev example are clicked. currently it stays at the bottom of screen for both of the description and code sections.

sending init data for each message to the child contract has less cost or saving that id uint32 (or address) in my parent contract?

Target:

• the original code didn't properly set with target as TargetValue(since it is Int)
• the second contract with message Reach will need parse the counter contract address. To better understanding and implement / test on test-net. here is my update:

import "@stdlib/deploy";

message CounterValue {
    value: Int as uint32;
}

////////////////////////////////////////////////////////////////////////////
// this is our famous Counter contract, we've seen it before
// this contract is very annoying, it only allows to increment +1 at a time!

contract Counter with Deployable {

    val: Int as uint32;

    init() {
        self.val = 0;
    }

    // step 6: this contract allows anyone to ask it to increment by 1 (ie. the other contract)
    receive("increment") {
        self.val = self.val + 1;
        reply(CounterValue{value: self.val}.toCell());
    }

    // step 3: this contract replies with its current value to anyone asking (ie. the other contract)
    receive("query") {
        reply(CounterValue{value: self.val}.toCell());
    }

    get fun value(): Int {
        return self.val;
    }
}

message Reach {
    target_value: Int as uint32;
}

////////////////////////////////////////////////////////////////////////////
// let's write a second helper contract to make our lives a little easier
// it will keep incrementing the previous contract as many times as we need!

contract BulkAdder with Deployable {

    target_value: Int as uint32;

    init() {
        self.target_value = 10;
    }


    // step 1: users will send this message to tell us what target value we need to reach
    receive(msg: Reach) {
        self.target_value = msg.target_value;
        let CounterAddressInit: StateInit = initOf Counter();

        // step 2: this contract will query the current counter value from the other contract
        send(SendParameters{
            to: contractAddress(CounterAddressInit),
            value: 0, /// TODO: https://github.com/tact-lang/tact/issues/31
            mode: SendRemainingValue + SendIgnoreErrors, /// TODO: issues/31
            body: "query".asComment(),
            data: CounterAddressInit.data,
            code: CounterAddressInit.code
        });
    }

    // step 4: the other contract will tell us what is its current value by sending us this message
    receive(msg: CounterValue) {
        if (msg.value < self.target_value) {
            // step 5: if its value is too low, send it another message to increment it by +1 more
            send(SendParameters{
                to: sender(),
                value: 0, /// TODO: same issue 31
                mode: SendRemainingValue + SendIgnoreErrors, /// TODO: https://github.com/tact-lang/tact/issues/31
                body: "increment".asComment()
            });
        }
    }
}

Hello, I'm a beginner in TON and relative stuff, and I learn those sometimes.
So my question is: how do two developers from around the world who have the same idea deploy their code?

For example, both want to have a counter, and their codes will be equal. So can they deploy their contract?
because in this scenario, their bytecode will be the same! (reference: https://tact-by-example.org/06-calc-contract-address) So the result will be the same unique address !?

I know we can use init and change that with init data.
but it means we should store more variable (and use more gas) just because we have the same idea as another?

the box in lower right corner is very small and shows only 1 or 2 lines at a time so most of results are unreadable and I have to copy and paste them to an outer editor every time. can you do sth about it?

Presseing Send "deploy 2nd" to 1 button shows this error:

Error: Invalid message type

I couldn't find the error myself to fix it and send a PR.

For instance, the Counter contract can use the newly introduced assignment operator +=