Build the Future with Neo Service Layer

using Neo.SmartContract.Framework;
using Neo.SmartContract.Framework.Services;

[DisplayName("NFTMarketplace")]
public class NFTMarketplace : SmartContract
{
    public static bool ListNFT(
        UInt160 nftContract,
        ByteString tokenId,
        BigInteger price,
        UInt160 seller)
    {
        if (!Runtime.CheckWitness(seller))
            throw new Exception("Invalid seller");

        // Verify NFT ownership
        var owner = (UInt160)Contract.Call(nftContract, "ownerOf", 
            CallFlags.ReadOnly, tokenId);
        if (owner != seller)
            throw new Exception("Not NFT owner");

        // Create listing
        var listingId = GenerateListingId(nftContract, tokenId);
        StorageMap listings = new(Storage.CurrentContext, "listings");
        
        listings.Put(listingId, new Listing
        {
            NFTContract = nftContract,
            TokenId = tokenId,
            Price = price,
            Seller = seller,
            IsActive = true,
            ListedAt = Runtime.Time
        }.ToByteArray());

        OnNFTListed(nftContract, tokenId, price, seller);
        return true;
    }

    public static bool PurchaseNFT(
        ByteString listingId,
        UInt160 buyer)
    {
        if (!Runtime.CheckWitness(buyer))
            throw new Exception("Invalid buyer");

        StorageMap listings = new(Storage.CurrentContext, "listings");
        var listingData = listings.Get(listingId);
        if (listingData == null)
            throw new Exception("Listing not found");

        var listing = (Listing)listingData.ToStruct();
        if (!listing.IsActive)
            throw new Exception("Listing inactive");

        // Process payment and transfer
        ProcessPayment(buyer, listing.Seller, listing.Price);
        TransferNFT(listing.NFTContract, listing.TokenId, 
                   listing.Seller, buyer);

        // Mark listing as sold
        listing.IsActive = false;
        listings.Put(listingId, listing.ToByteArray());

        OnNFTPurchased(listing.NFTContract, listing.TokenId, 
                      listing.Price, listing.Seller, buyer);
        return true;
    }
}

using Neo.SmartContract.Framework;
using Neo.SmartContract.Framework.Services;

[DisplayName("DeFiIntegration")]
public class DeFiIntegration : SmartContract
{
    public static bool AddLiquidity(
        UInt160 tokenA,
        UInt160 tokenB,
        BigInteger amountA,
        BigInteger amountB,
        UInt160 provider)
    {
        if (!Runtime.CheckWitness(provider))
            throw new Exception("Invalid provider");

        // Calculate optimal amounts
        var (optimalA, optimalB) = CalculateOptimalAmounts(
            tokenA, tokenB, amountA, amountB);

        // Transfer tokens to pool
        TransferToPool(provider, tokenA, optimalA);
        TransferToPool(provider, tokenB, optimalB);

        // Mint LP tokens
        var lpTokens = CalculateLPTokens(optimalA, optimalB);
        MintLPTokens(provider, lpTokens);

        // Update pool state
        UpdatePoolReserves(tokenA, tokenB, optimalA, optimalB);

        OnLiquidityAdded(provider, tokenA, tokenB, 
                        optimalA, optimalB, lpTokens);
        return true;
    }

    public static bool Stake(
        UInt160 lpToken,
        BigInteger amount,
        UInt160 staker)
    {
        if (!Runtime.CheckWitness(staker))
            throw new Exception("Invalid staker");

        // Transfer LP tokens to staking contract
        var success = (bool)Contract.Call(lpToken, "transfer",
            CallFlags.All, staker, Runtime.ExecutingScriptHash, amount, null);
        
        if (!success) return false;

        // Update staking balance
        UpdateStakingBalance(staker, lpToken, amount);
        
        // Calculate and distribute rewards
        DistributeRewards(staker, lpToken);
        
        OnTokensStaked(staker, lpToken, amount);
        return true;
    }
}

using Neo.SmartContract.Framework;
using Neo.SmartContract.Framework.Services;

[DisplayName("OracleService")]
public class OracleService : SmartContract
{
    public static bool UpdatePrice(
        string symbol,
        BigInteger price,
        uint timestamp,
        UInt160 oracle)
    {
        if (!IsAuthorizedOracle(oracle))
            throw new Exception("Unauthorized oracle");

        // Validate price data
        if (price <= 0 || timestamp == 0)
            throw new Exception("Invalid price data");

        // Store price with validation
        StorageMap prices = new(Storage.CurrentContext, "prices");
        var priceData = new PriceData
        {
            Symbol = symbol,
            Price = price,
            Timestamp = timestamp,
            Oracle = oracle,
            IsValid = true
        };

        prices.Put(symbol, priceData.ToByteArray());
        
        OnPriceUpdated(symbol, price, timestamp, oracle);
        return true;
    }

    public static BigInteger GetPrice(string symbol)
    {
        StorageMap prices = new(Storage.CurrentContext, "prices");
        var priceData = prices.Get(symbol);
        
        if (priceData == null)
            throw new Exception("Price not found");

        var price = (PriceData)priceData.ToStruct();
        
        // Check if price is recent (within 1 hour)
        if (Runtime.Time - price.Timestamp > 3600)
            throw new Exception("Price data stale");

        return price.Price;
    }
}