Write-write conflict

[Gurshaan7]

Discord user ID

No response

Describe your question in detail.

Issue:
In this piece of code we are firstly submitting X coin to our resource account and then passing resource account signer as an argument to xyz::swap function and then extracting Y Coin from our resource account , and the amount that is extracted is determined by xyz module function - xyz::get_amount_out ,
Now the issue can be if A user is executing the transaction and its fund is submitted to our resource account and then another user B is also executed the transaction and he reached a point where he is getting output token, now if the output token is same as input token of A then B will receive some amount from A reserve if y_exp is greater than actual swap output , Now the issue is will these transaction be executed parallely or serially? As of now we thought that it should run sequentially as parallelly it would lead to a write-write issue, but still need some confirmation on this.

public  fun function_xyz( … )
{ 
                let b_r_signer =get_resource_signer();
                let b_r_address =get_resource_address();
                let v = coin::value(&_x_in);
 
                let (v0, v1) = xyz::token_reserves<X, Y>();
        
                let lp = xyz::liquidity_fee<X, Y>();

                let y_exp = xyz::get_amount_out(v,v0 , v1, lp); 
                
                aptos_account::deposit_coins<X>(b_r_address , _x_in);

                xyz::swap<X, Y>(&b_r_signer, v); 
                
                let coin_y_balance = coin::balance<Y>(b_r_address); 
                let coin_y;

                if(coin_y_balance < y_exp)
                {
                    coin_y = coin::withdraw<Y>(&b_r_signer, coin_y_balance);
                }
                else
                {, 
                    coin_y = coin::withdraw<Y>(&b_r_signer, y_exp);
                };
 

                (option::none() , option::some(coin_y),option::none(),option::none())

     }

What error, if any, are you getting?

No response

What have you tried or looked at? Or how can we reproduce the error?

public fun function_xyz( … )
{
let b_r_signer =get_resource_signer();
let b_r_address =get_resource_address();
let v = coin::value(&_x_in);

            let (v0, v1) = xyz::token_reserves<X, Y>();
    
            let lp = xyz::liquidity_fee<X, Y>();

            let y_exp = xyz::get_amount_out(v,v0 , v1, lp); 
            
            aptos_account::deposit_coins<X>(b_r_address , _x_in);

            xyz::swap<X, Y>(&b_r_signer, v); 
            
            let coin_y_balance = coin::balance<Y>(b_r_address); 
            let coin_y;

            if(coin_y_balance < y_exp)
            {
                coin_y = coin::withdraw<Y>(&b_r_signer, coin_y_balance);
            }
            else
            {, 
                coin_y = coin::withdraw<Y>(&b_r_signer, y_exp);
            };


            (option::none() , option::some(coin_y),option::none(),option::none())

 }

Which operating system are you using?

Linux (Ubuntu, Fedora, Windows WSL, etc.)

Which SDK or tool are you using? (if any)

TypeScript SDK

Describe your environment or tooling in detail

No response

[Alexzander-Stone]

Hey there @Gurshaan7, I have clarifying questions, if you don't mind.

Are you asking if two individual TXs can be ran in parallel against the same code? And furthermore, when the two TXs are resolved in parallel, if the effects (write) of one TX can cause unintended side-effects in the other, mid execution?

Am I understanding your questions correctly?

[Gurshaan7]

Hi @Alexzander-Stone , yes that is exactly what I want to know?

[Alexzander-Stone]

I believe adiryaaggarwal12 has a great response, below. 😌

The fast answer being, the TXs will be executed fully and independent of each other, in an atomic manner.

[adityaaggarwal12]

Two transactions with a read-write conflict are run sequentially unless they use Aggregators. Aggregators, as detailed in AIP-47, enable simple counters to run in parallel.

In your case, which I assume is a DEX swap transaction, the two transactions with a read-write conflict will run sequentially.

If you're interested in reading more about how parallel workloads are handled in Aptos, you can read more here.