👾

Scrypto (Programming Language)

Radix Wiki

✏️ Edit page

Scrypto [ /’skrɪptoʊ/ ] is an open-source, smart-contract programming language, designed specifically for the development of decentralized applications (dApps) on the Radix Network.

Scrypto exists as a set of libraries and compiler extensions that add features, syntax and data types to the Rust programming language, allowing for an ‘asset-oriented’ style of programming that treats tokens, NFTs and other ‘resources’ as native objects.

Blueprints

Blueprints are inactive stateless source codes that live on the ledger.

Packages

Packages cater for when these blueprints need to work together. Packages verify the existence of blueprints because it instantiates them as part of their operations. Grouping blueprints together is expected to help save deployment costs.

Components

Components are like the smart contract of Radix DLT. It is created by instantiating the constructor of the blueprint, and it is responsible for distributing resources according to the logic provided in its' associated blueprint. The address of a newly created instance is generated once the creation process is completed.

Asset-based Token Engineering

Tokens are important in the DeFi space. Many DeFi protocols have tokens that either has a monetary value or are used for accounting purposes. Uniswap, the second largest DEX in the ecosystem with over $3.91 billion in total value locked (TVL), according to DeFillama, also has its token, UNI.

One of the flaws of smart contract design with the languages available today is that tokens are an afterthought when they are a big part of the ecosystem. This is what Scrypto claims to rectify as an asset-oriented language.

Asset-oriented programming is largely associated with Radix and vice versa. Tokens are built into Radix Engine. Tokens are not implemented in smart contracts but can be created by directly requesting them from the platform with some desired parameters. This negates what is obtainable as developers have to deploy a smart contract to create tokens which can open them up to security risks from incorrect contract logic.

Assets are a part of the fabric of the platform. Developers could develop their tokens in seconds by passing desired parameters to suit their needs. Radix built its engine this way to enable developers to create safe and secure tokens (assets).

Installation

MacOS

  1. Download and install VS Code.
  2. In VS Code, click on Terminal > New Terminal.
  3. Install xcode command line tools with the following command line:
    4. xcode-select --install
  4. Install the Homebrew package manager and follow the prompts:
    5. /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
  5. Install the Java SDK, C++ compiler and LLVM:
    6. brew install openjdk gcc llvm
  6. Install Rust compiler
    7. curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
  7. If you already have Rustup installed, make sure you are running the latest stable version:
    8.  rustup update stable
  8. Enable cargo:
    9. source $HOME/.cargo/env
  9. Add WebAssembly target:
    10. rustup target add wasm32-unknown-unknown
  10. Install simulator and command-line tools:
    11. git clone https://github.com/radixdlt/radixdlt-scrypto.git
cd radixdlt-scrypto
cargo install --path ./simulator

Windows

  1. Install git by running the installer from here.
  2. Install Visual Studio Build Tools for Visual Studio 2019
  3. Install Rust from here.
  4. If you already have Rustup installed, make sure you are running the latest stable version:
    5.  rustup update stable
  5. Install LLVM 13.0.1 (tick the option that adds LLVM to the system PATH).
  6. Install the Homebrew package manager and follow the prompts:
    7. /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
  7. Install cmake:
    8. brew install cmake
  8. Install Rust compiler:
    9. curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
  9. Start a new PowerShell
    10. source $HOME/.cargo/env
  10. Add WebAssembly target:
    11. rustup target add wasm32-unknown-unknown
  11. Install simulator and command-line tools:
    12. git clone https://github.com/radixdlt/radixdlt-scrypto.git
cd radixdlt-scrypto
cargo install --path ./simulator

Linux

  1. Install C++ compiler and LLVM is installed:
    2. sudo apt install clang build-essential llvm
  2. Install Rust compiler
    3. curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
  3. If you already have Rustup installed, make sure you are running the latest stable version:
    4.  rustup update stable
  4. Enable cargo in the current shell:
    5. source $HOME/.cargo/env
  5. Add WebAssembly target:
    6. rustup target add wasm32-unknown-unknown
  6. Install simulator and command-line tools:
    7. git clone https://github.com/radixdlt/radixdlt-scrypto.git
cd radixdlt-scrypto
cargo install --path ./simulator

Example

An example Scrypto blueprint that creates a fixed supply of 1000 ‘HelloTokens’.

// Import Scrypto library. Access to types such as buckets and vaults as well as methods.
use scrypto::prelude::*;

// Blueprint macro
blueprint! {
    struct Hello {
        // Define what resources and data will be managed by Hello components
        sample_vault: Vault
    }
    impl Hello {
        // Implement the functions and methods which will manage those resources and data
        
        // This is a function, and can be called directly on the blueprint once deployed
        pub fn instantiate_hello() -> ComponentAddress {
            // Create a new token called "HelloToken," with a fixed supply of 1000, and put that supply into a bucket
            let my_bucket: Bucket = ResourceBuilder::new_fungible()
                .metadata("name", "HelloToken")
                .metadata("symbol", "HT")
                .initial_supply(1000);

            // Instantiate a Hello component, populating its vault with our supply of 1000 HelloToken.
            // Initialize a state.
            Self {
                sample_vault: Vault::with_bucket(my_bucket)
            }
            // Instantiate local function and globalize it to assign an address. No semi-colon returns an address.
            .instantiate().globalize()
        }

        // This is a method, because it needs a reference to self.  Methods can only be called on components
        pub fn free_token(&mut self) -> Bucket {
            info!("My balance is: {} HelloToken. Now giving away a token!", self.sample_vault.amount());
            // If the semi-colon is omitted on the last line, the last value seen is automatically returned
            // In this case, a bucket containing 1 HelloToken is returned
            self.sample_vault.take(1)
        }
    }
}

Resources

Twitter