Deploying to Testnet
In the previous sections, we saw how a simple auction smart contract is implemented, and checked its correctness using sandbox testing.
The time has come to release it on the actual blockchain and interact with it! In this section, we will show you how to create a simple testnet account, deploy the contract, and interact with it from the CLI.
NEAR has two main networks for you to use: testnet and mainnet. The testnet network behaves exactly as the main network but uses test tokens with no real value
Testnet Account
To deploy a contract, you need a testnet account. If you don't have one, you can create one using the following command:
# create-account using near-cli (contractId has end with .testnet)
near create <contractId> --useFaucet
Replace <contractId> with the name you want to give to your account, and make sure it ends with .testnet.
The account will be created with 10 NEAR (these are test tokens).
Notice that we are using the --useFaucet flag to automatically request test tokens from the NEAR faucet.
The faucet is only available on the testnet network - which is the default network for the CLI
Deploying the Contract
To deploy the contract, you need to compile the contract code into WebAssembly (WASM) and then deploy it to the network
- 🌐 JavaScript
- 🦀 Rust
# compile the contract
npm run build
# deploy the contract
near deploy <contractId> ./build/auction.wasm
# initialize the contract, it finishes in 2 minutes
MINUTE_FROM_NOW=$(date -v+2M +%s000000000)
near call <contractId> init '{"end_time": "'$MINUTE_FROM_NOW'", "auctioneer": "<auctioneerId>"}' --accountId <contractId>
Replace <auctioneerId> with the name of another account, this should not be the same as the contract account as we intend on removing its keys.
# compile the contract using cargo-near
cargo near build
# deploy the contract
near deploy <contractId> ./target/near/contract_rs.wasm
# initialize the contract, it finishes in 2 minutes
MINUTE_FROM_NOW=$(date -v+2M +%s000000000)
near call <contractId> init '{"end_time": "'$MINUTE_FROM_NOW'"}' --accountId <contractId>
Locking the contract
As mentioned previously we should lock the account by removing the keys. This allows our users to interact with the contract without having to trust the account owner.
near account delete-keys
Next, specify the contract account and click the right arrow → to delete all the keys. Make sure you select testnet.
Be extra careful to delete the keys from the correct account as you'll never be able to access the account again!
Now that the contract is deployed, initialized, and locked we can send transactions to it using the CLI.
NEAR's CLI is interactive meaning you can type near and click through all the possible options without having to remember certain commands
Interacting with the Contract
We are now ready to start bidding by calling the bid function on the contract. We recommend that you create two new accounts to simulate different bidders.
# call the contract to bid
near call <contractId> bid --accountId <bidderId> --amount 1
# get the highest bid
near view <contractId> get_highest_bid
Notice that we call the bid function without arguments, but attach 1 NEAR to the transaction. This is the amount we are bidding.
For the get_highest_bid function, we don't need to specify which user is calling it, as it is a view function and does not require gas to be executed.
Conclusion
We have now seen how to deploy a contract to testnet and interact with it using the NEAR CLI.
A word of advice before moving forward. When people learn how to use the CLI, they get lazy and start testing new contract features directly on the testnet. While this is tempting, it is not recommended.
Do not use testnet as your only way to test contracts. Always test your contracts on the sandbox environment first, and only deploy to the testnet when you are confident that everything is working as expected.
Generally, you will use the CLI only to deploy and initialize the contract. Afterward, all interactions will be made from a frontend. This is why in the next section we'll move on to creating a frontend to interact with the contract.
