sway Documentation

File: docs/intro/what-is-fuel.mdx Copy Chapter

What is Fuel?

Fuel is an operating system purpose built for Ethereum Rollups.
Fuel allows rollups to solve for PSI (parallelization, state minimized execution, interoperability) without making any sacrifices.

Here is how we do it:

FuelVM Copy Chapter

The FuelVM learns from the Ethereum ecosystem.
It implements improvements suggested to the Ethereum VM (EVM) for many years that couldn’t be implemented due to the need to maintain backward compatibility, including parallel transaction execution and multiple native assets.

Fuel delivers unmatched processing capacity through its ability to execute transactions in parallel by using strict state access lists in the form of a UTXO model.
With the FuelVM, Fuel full nodes identify the accounts a transaction touches, mapping out dependencies before execution.
This enables Fuel to use far more threads and cores of your CPU that are typically idle in single-threaded blockchains.
As a result, Fuel can deliver far more compute, state accesses, and transactional throughput than its single-threaded counterparts.

Sway Language Copy Chapter

Fuel provides a powerful and sleek developer experience with our own domain-specific language (DSL) called Sway.
Sway is based on Rust and includes syntax to leverage a blockchain VM without needlessly verbose boilerplate.
Sway was created alongside the FuelVM and designed for the high-compute Fuel environment.

Rust + Solidity = Sway Copy Section

Sway prioritizes compile-time analysis and safety, similar to Rust’s borrow checker and safety-first semantics.
Additionally, it has the syntax of Rust. From Solidity, Sway took the notion of a smart-contract-paradigm language with built-in top-level contract storage and blockchain mechanisms for ergonomic and safe contract programming.

Sway brings the notion of static auditing to smart contracts.
In addition, Sway is highly performant and has extensible optimization passes and a modular backend for targeting different blockchain architectures.

<CardSection
versionSet={props.versionSet}
cardsInfo={[
{
link: '/docs/sway',
nightlyLink: '/docs/nightly/sway',
isExternal: false,
heading: 'Sway',
headingIcon: 'Code',
body: 'Read the official Sway documentation.',
},
{
link: 'https://sway-playground.org/',
isExternal: true,
heading: 'Sway Playground',
headingIcon: 'Browser',
body: 'Get started experimenting with Sway in the browser.',
},
{
link: 'https://swaybyexample.com/',
isExternal: true,
heading: 'Sway By Example',
headingIcon: 'Beach',
body: 'An introduction to Sway with bite-sized simple examples',
},
{
link: 'https://github.com/FuelLabs/sway-examples',
isExternal: true,
heading: 'Sway Examples',
headingIcon: 'Robot',
body: 'Examples of full-stack DeFi applications',
},
{
link: '/docs/sway-libs',
nightlyLink: '/docs/nightly/sway-libs',
isExternal: false,
heading: 'Sway Libraries',
headingIcon: 'Book',
body: 'Find useful libraries written in Sway.',
},
{
link: '/docs/sway-standards',
nightlyLink: '/docs/nightly/sway-standards',
isExternal: false,
heading: 'Sway Standards',
headingIcon: 'Book',
body: 'Learn about standards for the Sway language',
},
{
link: 'https://fuellabs.github.io/sway/master/std/',
isExternal: true,
heading: 'std-lib Reference',
headingIcon: 'Book',
body: 'Find definitions for helpful types and methods in Sway.',
},
{
link: 'https://github.com/FuelLabs/sway-applications',
isExternal: true,
heading: 'Example Applications',
headingIcon: 'Apps',
body: 'Explore end-to-end applications written in Sway.',
},
]}
/>

Developer Tooling Copy Chapter

Part of what makes Sway so powerful is the fantastic suite of developer tools surrounding it.
The Fuel development environment retains the benefits of smart contract languages like Solidity, while adopting the paradigms introduced in the Rust tooling ecosystem.

Now, developers can have a completely vertically integrated experience where every component, from the virtual machine to the CLI, works in harmony.

Sway Tooling Copy Section

<CardSection
versionSet={props.versionSet}
cardsInfo={[
{
link: '/docs/forc',
nightlyLink:'/docs/nightly/forc',
isExternal: false,
heading: 'Forc',
headingIcon: 'Tool',
body: 'Explore the Fuel Orchestrator that helps you build, test, and deploy your Sway projects.',
},
{
link: '/guides/installation/',
nightlyLink: '/guides/installation/',
isExternal: false,
heading: 'Fuelup',
headingIcon: 'Settings',
body: 'Learn more about the official Fuel toolchain manager that helps install and manage versions.',
}
]}
/>

SDKs & API Copy Section

<CardSection
versionSet={props.versionSet}
cardsInfo={[
{
link: '/docs/fuels-rs',
nightlyLink: '/docs/nightly/fuels-rs',
isExternal: false,
heading: 'Rust SDK',
headingIcon: 'BrandRust',
body: 'Test and interact with your Sway program in Rust.',
},
{
link: '/docs/fuels-ts',
nightlyLink: '/docs/nightly/fuels-ts',
isExternal: false,
heading: 'Typescript SDK',
headingIcon: 'BrandTypescript',
body: 'Test and interact with your Sway program in TypeScript.',
},
{
link: '/docs/wallet',
nightlyLink: '/docs/nightly/wallet',
isExternal: false,
heading: 'Wallet SDK',
headingIcon: 'Wallet',
body: 'Seamlessly integrate a wallet into your application.',
},
{
link: '/docs/graphql',
nightlyLink: '/docs/nightly/graphql',
isExternal: false,
heading: 'GraphQL API',
headingIcon: 'ChartDots3',
body: 'Learn about the GraphQL API and interact with the Fuel Network.',
},
]}
/>

Network Copy Section

<CardSection
versionSet={props.versionSet}
cardsInfo={[
{
link: /docs/specs,
nightlyLink: /docs/nightly/specs,
isExternal: false,
heading: 'Specs',
headingIcon: 'ListDetails',
body: 'Explore the specifications for the Fuel Network.',
},
{
link: props.explorerUrl,
isExternal: true,
heading: 'Explorer',
headingIcon: 'Search',
body: 'Explore transactions on the Fuel network.',
},
{
link: props.bridgeUrl,
isExternal: true,
heading: 'Bridge',
headingIcon: 'BuildingBridge',
body: 'Bridge assets to the Fuel network.',
},
{
link: props.faucetUrl,
isExternal: true,
heading: 'Faucet',
headingIcon: 'Coin',
body: Get ${props.fuelTestnet} testnet tokens.,
}
]}
/>

File: docs/guides/examples/counter-dapp/frontend/README.md Copy Chapter

React + TypeScript + Vite

This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.

Currently, two official plugins are available:

• @vitejs/plugin-react uses Babel for Fast Refresh
• @vitejs/plugin-react-swc uses SWC for Fast Refresh

Expanding the ESLint configuration Copy Chapter

If you are developing a production application, we recommend updating the configuration to enable type aware lint rules:

• Configure the top-level parserOptions property like this:

export default {
  // other rules...
  parserOptions: {
    ecmaVersion: 'latest',
    sourceType: 'module',
    project: ['./tsconfig.json', './tsconfig.node.json', './tsconfig.app.json'],
    tsconfigRootDir: __dirname,
  },
}

• Replace plugin:@typescript-eslint/recommended to plugin:@typescript-eslint/recommended-type-checked or plugin:@typescript-eslint/strict-type-checked
• Optionally add plugin:@typescript-eslint/stylistic-type-checked
• Install eslint-plugin-react and add plugin:react/recommended & plugin:react/jsx-runtime to the extends list

File: docs/guides/docs/contract-quickstart/index.mdx Copy Chapter

title: Contract Quickstart category: Contract Quickstart parent: label: All Guides link: /guides Copy Chapter

Smart Contract Quickstart

Getting started with Fuel as a smart contract developer is as simple as:

1. Installing fuelup
2. Generating a counter contract
3. Building the contract
4. Setting up a local wallet
5. Deploying the contract

Installation Copy Chapter

Already have `fuelup` installed? Copy Section

Generating a counter contract Copy Chapter

Run the command below to generate a counter contract in Sway:

{/* TODO: Replace when forc template command is stable

forc template --template-name counter counter-contract

*/}

{/TODO: Remove when forc template command is stable/}

<TestAction
id="create-contract-project"
action={{
name: 'runCommand',
commandFolder: 'guides-testing/'
}}
/>

The contract will be in the src/main.sw file.

Building the contract Copy Chapter

To build a contract, move inside the counter-contract folder:

cd counter-contract

{/TODO: Remove when forc template command is stable/}

Copy and paste the code below into your src/main.sw file

<TestAction
id="copy-contract"
action={{
name: 'writeToFile',
filepath: 'guides-testing/counter-contract/src/main.sw'
}}
/>

Next, run the forc build command:

<TestAction
id="build-contract"
action={{
name: 'runCommand',
commandFolder: 'guides-testing/counter-contract'
}}
/>

forc build

Setting up a local wallet Copy Chapter

You can get test funds using the faucet.

Deploying the contract Copy Chapter

To deploy the contract to the testnet, you can run:

forc deploy --testnet

Next Steps Copy Chapter

Ready to learn more? Check out the following resources:

• Learn the step-by-step instructions for how to build a full-stack counter contract dapp
• Build a full-stack marketplace dapp with the Intro to Sway guide
• Try building with Predicates
• Read the Sway docs

File: docs/guides/docs/counter-dapp/building-a-frontend.mdx Copy Chapter

title: Building a Frontend category: Counter Dapp parent: label: All Guides link: /guides Copy Chapter

Building a Frontend to Interact With Your Contract

To build a frontend application for the counter contract, we'll do the following:

1. Install the Fuel Browser Wallet.
2. Initialize a React project.
3. Install the fuels SDK dependency.
4. Generate contract types.
5. Write our frontend code.
6. Run our project.

Install the Fuel Browser Wallet Copy Chapter

{/install_wallet:example:start/}
Our frontend application will allow users to connect with a wallet, so you'll need to have a browser wallet installed.

Before going to the next steps, install the Fuel Wallet extension.

Once you've setup your wallet, click the "Faucet" button in the wallet to get some testnet tokens.
{/install_wallet:example:end/}

Initialize a React project Copy Chapter

To split our project's contract from frontend code, let's initialize our frontend project: assuming that your terminal is open at your contract's folder /home/user/path/to/counter-contract let's go back up one directory.

cd ..

Now, initialize a React project with TypeScript using Vite.

<TestAction
id="create-vite-project"
action={{
name: 'runCommand',
commandFolder: 'guides-testing/fuel-project'
}}
/>

npm create vite@latest frontend -- --template react-ts

The output should be similar to this:

Scaffolding project in Fuel/fuel-project/frontend...

Done. Now run:

  cd frontend
  npm install
  npm run dev

Installing Copy Section

Move into the frontend folder and install the dependencies by running:

<TestAction
id="install-basic-deps"
action={{
name: 'runCommand',
commandFolder: 'guides-testing/fuel-project'
}}
/>

cd frontend && npm install

You should now have two folders inside your fuel-project folder: counter-contract and frontend.

Install the `fuels` SDK dependency Copy Chapter

The fuels package includes all the main tools you need to interact with your Sway programs and the Fuel network.
The @fuel-wallet packages include everything you need to interact with user wallets.

fuels requires Node version {props.nodeVersion}.

Install the following packages in your frontend folder:

<TestAction
id="install-deps"
action={{
name: 'runCommand',
commandFolder: 'guides-testing/fuel-project/frontend'
}}
/>

npm install fuels @fuels/react @fuels/connectors @tanstack/react-query

Generate contract types Copy Chapter

The fuels init command generates a fuels.config.ts file that is used by the SDK to generate contract types.
Use the contracts flag to define where your contract folder is located, and the output flag to define where you want the generated files to be created.

Run the command below in your frontend folder to generate the config file:

<TestAction
id="fuels_config"
action={{
name: 'runCommand',
commandFolder: 'guides-testing/fuel-project/frontend'
}}
/>

npx fuels init --contracts ../counter-contract/ --output ./src/sway-api

Now that you have a fuels.config.ts file, you can use the fuels build command to rebuild your contract and generate types.
Running this command will interpret the output ABI JSON from your contract and generate the correct TypeScript definitions.
If you see the folder fuel-project/counter-contract/out you will be able to see the ABI JSON there.

Inside the fuel-project/frontend directory run:

<TestAction
id="typegen"
action={{
name: 'runCommand',
commandFolder: 'guides-testing/fuel-project/frontend'
}}
/>

npx fuels build

A successful process should print and output like the following:

Building..
Building Sway programs using source 'forc' binary
Generating types..
🎉  Build completed successfully!

Now you should be able to find a new folder fuel-project/frontend/src/sway-api.

Modify the App Copy Chapter

Inside the frontend/src folder let's add code that interacts with our contract.

Because we'll be using @fuels/react, first we need to wrap our app with the FuelProvider component.

Add the imports below to the top of your frontend/src/main.tsx file and setup a query client:

<TestAction
id="provider-import"
action={{
name: 'modifyFile',
filepath: 'guides-testing/fuel-project/frontend/src/main.tsx',
atLine: 5,
}}
/>

Next, modify your frontend/src/main.tsx file to wrap the App component with the FuelProvider and QueryClientProvider components.

<TestAction
id="fuel-wallet-provider"
action={{
name: 'modifyFile',
filepath: 'guides-testing/fuel-project/frontend/src/main.tsx',
atLine: 11,
removeLines: [11,12,13,14,15],
}}
/>

Next, change the file fuel-project/frontend/src/App.tsx to:

<TestAction
id="app-code"
action={{
name: 'writeToFile',
filepath: 'guides-testing/fuel-project/frontend/src/App.tsx'
}}
/>

Finally, replace the value of the CONTRACT_ID variable at the top of your App.tsx file with the address of the contract you just deployed.

<TestAction
id="app-contract-id"
action={{
name: 'modifyFile',
filepath: 'guides-testing/fuel-project/frontend/src/App.tsx',
atLine: 13,
removeLines: [13],
useSetData: ' "0x92073699bd78dac70756a9e0e8bca1c7121c7adc4b90570800f0916fe4ac33dd";'
}}
/>

Run your project Copy Chapter

Inside the fuel-project/frontend directory run:

<TestAction
id="start-app"
action={{
name: 'runCommand',
preCommand: "pnpm pm2 start 'BROWSER=none ' --name 'react-dapp' --cwd ./guides-testing/fuel-project/frontend"
}}
/>

npm run dev

VITE v5.3.5  ready in 108 ms

  ➜  Local:   http://localhost:5173/
  ➜  Network: use --host to expose
  ➜  press h + enter to show help

Click the "Connect" button and select the wallet you have installed to connect your wallet.

Once connected, if there are no funds in your wallet, you will see a link to get testnet funds.

If you have testnet ETH on Fuel, you should see the counter value and increment button:

You just built a fullstack dapp on Fuel! ⛽ Copy Chapter

Here is the repo for this project.

If you run into any problems, a good first step is to compare your code to this repo and resolve any differences.

Tweet us @fuel_network letting us know you just built a dapp on Fuel, you might get invited to a private group of builders, be invited to the next Fuel dinner, get alpha on the project, or something 👀.

Updating The Contract Copy Section

To develop and test faster, we recommend using the fuels dev command to start a local node and automatically redeploy and generate types for your contract on each change.

Once you're ready to redeploy your contract to the testnet, here are the steps you should take to get your frontend and contract back in sync:

• In your frontend directory, re-run this command: npx fuels build.
• In your contract directory, redeploy the contract.
• In your frontend directory, update the contract ID in your App.tsx file.

Need Help? Copy Chapter

Get help from the team by posting your question in the Fuel Forum.

<TestAction
id="wait-after-start-app"
action={{
name: 'wait',
timeout: 20000
}}
/>

<TestAction
id="go-to-frontend"
action={{
name: 'goToUrl',
url: "http://localhost:5173"
}}
/>

<TestAction
id="click-connect-button"
action={{
name: 'clickByRole',
role: "button",
elementName: "Connect"
}}
/>

<TestAction
id="click-fuel-wallet"
action={{
name: 'clickByLabel',
label: 'Connect to Fuel Wallet'
}}
/>

<TestAction
id="approve-connect"
action={{
name: 'walletApproveConnect',
}}
/>

<TestAction
id="wait-after-connect"
action={{
name: 'wait',
timeout: 5000
}}
/>

<TestAction
id="get-initial-count"
action={{
name: 'getByLocator-save',
locator: "h3 ~ div",
}}
/>

{/*
<TestAction
id="click-increment-button"
action={{
name: 'clickByRole',
role: "button",
elementName: "Increment"
}}
/>
<TestAction
id="approve-txn"
action={{
name: 'walletApprove',
}}
/>

<TestAction
id="wait-after-approve"
action={{
name: 'wait',
timeout: 15000
}}
/>

<TestAction
id="reload-after-approve"
action={{
name: 'reload',
}}
/>

<TestAction
id="wait-after-reload"
action={{
name: 'wait',
timeout: 7000
}}
/>

<TestAction
id="get-final-count"
action={{
name: 'getByLocator-save',
locator: "h3 ~ div",
}}
/>

<TestAction
id="check-count"
action={{
name: 'checkIfIsIncremented',
initialIndex: 0,
finalIndex: 1
}}
/> */}

File: docs/guides/docs/counter-dapp/building-a-smart-contract.mdx Copy Chapter

title: Building a Smart Contract category: Counter Dapp parent: label: All Guides link: /guides Copy Chapter

Writing A Sway Smart Contract

Installation Copy Chapter

{/install_help:example:start/}

Having problems? Visit the installation guide or post your question in our forum.
{/install_help:example:end/}

Already have `fuelup` installed? Copy Section

{/already_installed:example:start/}
If you already have fuelup installed, run the commands below to make sure you are on the most up-to-date toolchain.

fuelup self update
fuelup update
fuelup default latest

{/already_installed:example:end/}

Your First Sway Project Copy Chapter

We'll build a simple counter contract with two functions: one to increment the counter, and one to return the value of the counter.

Start by creating a new, empty folder. We'll call it fuel-project.

<TestAction
id="create-project-folder"
action={{
name: 'runCommand',
commandFolder: 'guides-testing'
}}
/>

mkdir fuel-project

Writing the Contract Copy Section

Move inside of your fuel-project folder:

cd fuel-project

Then create a contract project using forc:

<TestAction
id="create-contract"
action={{
name: 'runCommand',
commandFolder: 'guides-testing/fuel-project'
}}
/>

{/ANCHOR: new_forc_contract/}

forc new counter-contract

{/ANCHOR_END: new_forc_contract/}

You will get this output:

To compile, use `forc build`, and to run tests use `forc test`
----
Read the Docs:
- Sway Book: https://docs.fuel.network/docs/sway
- Forc Book: https://docs.fuel.network/docs/forc
- Rust SDK Book: https://docs.fuel.network/docs/fuels-rs
- TypeScript SDK: https://docs.fuel.network/docs/fuels-ts

Join the Community:
- Follow us @SwayLang: https://twitter.com/SwayLang
- Ask questions on Discourse: https://forum.fuel.network/

Report Bugs:
- Sway Issues: https://github.com/FuelLabs/sway/issues/new

{/This example should include a tree for a new forc project and explain the boilerplate files/}
{/forc_new:example:start/}
Here is the project that forc has initialized:

<TestAction
id="contract-tree"
action={{
name: 'runCommand',
commandFolder: 'guides-testing/fuel-project'
}}
/>

tree counter-contract

counter-contract
├── Forc.toml
└── src
    └── main.sw

1 directory, 2 files

forc.toml is the manifest file (similar to Cargo.toml for Cargo or package.json for Node) and defines project metadata such as the project name and dependencies.
{/forc_new:example:end/}

Open your project in a code editor and delete everything in src/main.sw apart from the first line.

Every Sway file must start with a declaration of what type of program the file contains; here, we've declared that this file is a contract.
You can learn more about Sway program types in the Sway Book.

<TestAction
id="program-type"
action={{
name: 'writeToFile',
filepath: 'guides-testing/fuel-project/counter-contract/src/main.sw'
}}
/>

Next, we'll define a storage value.
In our case, we have a single counter that we'll call counter of type u64 (a 64-bit unsigned integer) and initialize it to 0.

<TestAction
id="storage"
action={{
name: 'modifyFile',
filepath: 'guides-testing/fuel-project/counter-contract/src/main.sw'
}}
/>

ABI Copy Section

ABI stands for Application Binary Interface.
An ABI defines an interface for a contract.
A contract must either define or import an ABI declaration.

It is considered best practice to define your ABI in a separate library and import it into your contract.
This allows callers of the contract to import and use the ABI more easily.

For simplicity, we will define the ABI directly in the contract file itself.

<TestAction
id="abi"
action={{
name: 'modifyFile',
filepath: 'guides-testing/fuel-project/counter-contract/src/main.sw'
}}
/>

Implement ABI Copy Section

Below your ABI definition, you will write the implementation of the functions defined in your ABI.

<TestAction
id="impl"
action={{
name: 'modifyFile',
filepath: 'guides-testing/fuel-project/counter-contract/src/main.sw'
}}
/>

storage.counter.read() is an implicit return and is equivalent to return storage.counter.read();.

Here's what your code should look like so far:

File: ./counter-contract/src/main.sw

<TestAction
id="entire-contract"
action={{
name: 'compareToFile',
filepath: 'guides-testing/fuel-project/counter-contract/src/main.sw'
}}
/>

Build the Contract Copy Section

Navigate to your contract folder:

cd counter-contract

Then run the following command to build your contract:

<TestAction
id="build-contract"
action={{
name: 'runCommand',
commandFolder: 'guides-testing/fuel-project/counter-contract'
}}
/>

forc build

Compiled library "core".
  Compiled library "std".
  Compiled contract "counter-contract".
  Bytecode size: 84 bytes.

Let's have a look at the content of the counter-contract folder after building:

<TestAction
id="built-contract-tree"
action={{
name: 'runCommand',
commandFolder: 'guides-testing/fuel-project/counter-contract'
}}
/>

tree .

.
├── Forc.lock
├── Forc.toml
├── out
│   └── debug
│       ├── counter-contract-abi.json
│       ├── counter-contract-storage_slots.json
│       └── counter-contract.bin
└── src
    └── main.sw

3 directories, 6 files

We now have an out directory that contains our build artifacts such as the JSON representation of our ABI and the contract bytecode.

Testing your Contract with Rust Copy Chapter

Don't want to test with Rust? Skip this section and jump to Deploy the Contract.

We will start by adding a Rust integration test harness using a Cargo generate template.
If you don't already have Rust installed, you can install it by running this command:

Next, if you don't already have it installed, let's install cargo generate:

cargo install cargo-generate --locked

Now, let's generate the default test harness with the following command:

<TestAction
id="cargo-generate-test"
action={{
name: 'runCommand',
commandFolder: 'guides-testing/fuel-project/counter-contract'
}}
/>

cargo generate --init fuellabs/sway templates/sway-test-rs --name counter-contract

⚠️   Favorite `fuellabs/sway` not found in config, using it as a git repository: https://github.com/fuellabs/sway.git
🔧   Destination: /home/user/path/to/counter-contract ...
🔧   project-name: counter-contract ...
🔧   Generating template ...
🔧   Moving generated files into: `/home/user/path/to/counter-contract`...
✨   Done! New project created /home/user/path/to/counter-contract

Let's have a look at the result:

<TestAction
id="cargo-test-tree"
action={{
name: 'runCommand',
commandFolder: 'guides-testing/fuel-project/counter-contract'
}}
/>

tree .

.
├── Cargo.toml
├── Forc.lock
├── Forc.toml
├── out
│   └── debug
│       ├── counter-contract-abi.json
│       ├── counter-contract-storage_slots.json
│       └── counter-contract.bin
├── src
│   └── main.sw
└── tests
    └── harness.rs

4 directories, 8 files

Now that we have our default test harness, let's add a useful test to it.

At the bottom of test/harness.rs below the can_get_contract_id() test, add the test_increment test function below to verify that the value of the counter gets incremented:

<TestAction
id="test-harness"
action={{
name: 'modifyFile',
filepath: 'guides-testing/fuel-project/counter-contract/tests/harness.rs',
addSpacesBefore: 1,
}}
/>

Here is what your file should look like:

File: ./counter-contract/tests/harness.rs

<TestAction
id="final-test-harness"
action={{
name: 'compareToFile',
filepath: 'guides-testing/fuel-project/counter-contract/tests/harness.rs'
}}
/>

Run cargo test in the terminal:

cargo test

If all goes well, the output should look as follows:

...
  running 2 tests
  test can_get_contract_id ... ok
  test test_increment ... ok
  test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.25s

Deploy the Contract Copy Chapter

It's now time to deploy . We will show how to do this using forc from the command line, but you can also do it using the Rust SDK or the TypeScript SDK.

In order to deploy a contract, you need to have a wallet to sign the transaction and coins to pay for gas. Fuelup will guide you in this process.

Setting up a local wallet Copy Section

You can get test funds using the faucet.

Deploy To Testnet Copy Section

Now, you can deploy the contract to the latest testnet with the forc deploy command.

forc deploy --testnet

{/forc_wallet:example:start/}
The terminal will ask for the password of the wallet:

Please provide the password of your encrypted wallet vault at "~/.fuel/wallets/.wallet":

Once you have unlocked the wallet, the terminal will show a list of the accounts:

Account 0 -- fuel18caanqmumttfnm8qp0eq7u9yluydxtqmzuaqtzdjlsww5t2jmg9skutn8n:
  Asset ID                                                           Amount
  0000000000000000000000000000000000000000000000000000000000000000 499999940

Just below the list, you'll see this prompt:

Please provide the index of account to use for signing:

Then you'll enter the number of the account of preference and press Y when prompted to accept the transaction.

Finally, you will get back the network endpoint where the contract was deployed, a Contract ID and the block where the transaction was signed.
{/forc_wallet:example:end/}

Save the Contract ID, as you'll need this later to connect the frontend.

Contract counter-contract Deployed!

Network: https://testnet.fuel.network
Contract ID: 0x8342d413de2a678245d9ee39f020795800c7e6a4ac5ff7daae275f533dc05e08
Deployed in block 0x4ea52b6652836c499e44b7e42f7c22d1ed1f03cf90a1d94cd0113b9023dfa636

Congrats, you have completed your first smart contract on Fuel ⛽ Copy Section

Here is the repo for this project. If you run into any problems, a good first step is to compare your code to this repo and resolve any differences.

Tweet us @fuel_network letting us know you just built a dapp on Fuel, you might get invited to a private group of builders, be invited to the next Fuel dinner, get alpha on the project, or something 👀.

Need Help? Copy Chapter

Get help from the team by posting your question in the Fuel Forum.