Building on Sui Blockchain: A Developer's Comprehensive Guide

# Install Sui CLI (macOS/Linux)
cargo install --locked --git https://github.com/MystenLabs/sui.git --branch devnet sui

# Verify installation
sui --version

# Create a new Sui project
sui move new my_first_project
cd my_first_project

# Initialize Sui client
sui client

# Get testnet SUI tokens from faucet
sui client faucet

# Check your address and balance
sui client active-address
sui client gas

// Example: Simple Move module on Sui
module my_project::counter {
    use sui::object::{Self, UID};
    use sui::transfer;
    use sui::tx_context::{Self, TxContext};

    /// A counter object with owner
    struct Counter has key {
        id: UID,
        value: u64,
        owner: address,
    }

    /// Create a new counter
    public entry fun create(ctx: &mut TxContext) {
        let counter = Counter {
            id: object::new(ctx),
            value: 0,
            owner: tx_context::sender(ctx),
        };
        transfer::transfer(counter, tx_context::sender(ctx));
    }

    /// Increment the counter
    public entry fun increment(counter: &mut Counter) {
        counter.value = counter.value + 1;
    }

    /// Get counter value
    public fun get_value(counter: &Counter): u64 {
        counter.value
    }
}

module my_project::simple_swap {
    use sui::coin::{Self, Coin};
    use sui::balance::{Self, Balance};
    use sui::sui::SUI;
    use sui::tx_context::{Self, TxContext};
    use sui::transfer;

    /// Liquidity pool for token swaps
    struct Pool<phantom CoinA, phantom CoinB> has key {
        id: UID,
        balance_a: Balance<CoinA>,
        balance_b: Balance<CoinB>,
        lp_supply: u64,
    }

    /// Add liquidity to the pool
    public entry fun add_liquidity<CoinA, CoinB>(
        pool: &mut Pool<CoinA, CoinB>,
        coin_a: Coin<CoinA>,
        coin_b: Coin<CoinB>,
        ctx: &mut TxContext
    ) {
        let amount_a = coin::value(&coin_a);
        let amount_b = coin::value(&coin_b);

        coin::put(&mut pool.balance_a, coin_a);
        coin::put(&mut pool.balance_b, coin_b);

        pool.lp_supply = pool.lp_supply + amount_a;
        // LP token minting logic here
    }

    /// Swap CoinA for CoinB
    public entry fun swap_a_to_b<CoinA, CoinB>(
        pool: &mut Pool<CoinA, CoinB>,
        coin_in: Coin<CoinA>,
        ctx: &mut TxContext
    ) {
        let amount_in = coin::value(&coin_in);

        // Calculate output amount with constant product formula
        let balance_a = balance::value(&pool.balance_a);
        let balance_b = balance::value(&pool.balance_b);

        let amount_out = (amount_in * balance_b) / (balance_a + amount_in);

        // Execute swap
        coin::put(&mut pool.balance_a, coin_in);
        let coin_out = coin::take(&mut pool.balance_b, amount_out, ctx);

        transfer::public_transfer(coin_out, tx_context::sender(ctx));
    }
}

// Example: Unit test for counter module
#[test_only]
module my_project::counter_tests {
    use my_project::counter;
    use sui::test_scenario;

    #[test]
    fun test_counter_increment() {
        let owner = @0xA;
        let scenario_val = test_scenario::begin(owner);
        let scenario = &mut scenario_val;

        // Create counter
        {
            counter::create(test_scenario::ctx(scenario));
        };

        // Increment counter
        test_scenario::next_tx(scenario, owner);
        {
            let counter = test_scenario::take_from_sender<counter::Counter>(scenario);
            counter::increment(&mut counter);
            assert!(counter::get_value(&counter) == 1, 0);
            test_scenario::return_to_sender(scenario, counter);
        };

        test_scenario::end(scenario_val);
    }
}

// Run tests
// sui move test

// Example: React component for interacting with Sui
import { useWallet, useAccounts } from '@mysten/dapp-kit';
import { TransactionBlock } from '@mysten/sui.js/transactions';
import { SuiClient } from '@mysten/sui.js/client';

function CounterApp() {
  const { currentWallet } = useWallet();
  const accounts = useAccounts();
  const client = new SuiClient({ url: 'https://fullnode.devnet.sui.io' });

  const incrementCounter = async () => {
    if (!currentWallet) return;

    const tx = new TransactionBlock();
    tx.moveCall({
      target: '${PACKAGE_ID}::counter::increment',
      arguments: [tx.object(COUNTER_OBJECT_ID)],
    });

    try {
      const result = await currentWallet.signAndExecuteTransactionBlock({
        transactionBlock: tx,
      });
      console.log('Transaction:', result);
    } catch (error) {
      console.error('Error:', error);
    }
  };

  return (
    <div>
      <button onClick={incrementCounter}>Increment Counter</button>
    </div>
  );
}